使用Go实现Google Zanzibar风格的授权系统（Keto）

Google Zanzibar是一种全球分布式授权系统，为Google Drive、YouTube等产品提供权限管理。Keto是Zanzibar的开源实现，下面我将介绍如何在Go中使用Keto构建授权系统。

Keto简介

Keto是一个实现了Zanzibar论文中核心概念的授权系统，主要特点包括：

• 基于关系的访问控制(ReBAC)
• 全局一致性
• 高性能和可扩展性
• 支持复杂的权限检查

安装Keto客户端

首先安装Keto Go客户端：

go get github.com/ory/keto-client-go

基本使用示例

1. 初始化客户端

package main

import (
	"context"
	"fmt"
	keto "github.com/ory/keto-client-go"
)

func main() {
	configuration := keto.NewConfiguration()
	configuration.Servers = []keto.ServerConfiguration{
		{
			URL: "http://localhost:4466", // Keto服务地址
		},
	}
	
	client := keto.NewAPIClient(configuration)
	ctx := context.Background()
	
	// 下面的示例将使用这个client
}

2. 定义关系元组

Zanzibar/Keto使用关系元组(relation tuples)来表示权限，格式为：namespace:object#relation@subject

// 添加关系元组
func addRelationTuple(client *keto.APIClient, ctx context.Context) {
	tuple := keto.RelationQuery{
		Namespace: "files",
		Object:    "file1",
		Relation:  "view",
		SubjectId: "user1",
	}
	
	_, _, err := client.WriteApi.CreateRelationTuple(ctx).RelationQuery(tuple).Execute()
	if err != nil {
		fmt.Printf("Error creating relation tuple: %v\n", err)
		return
	}
	fmt.Println("Relation tuple created successfully")
}

3. 检查权限

// 检查权限
func checkPermission(client *keto.APIClient, ctx context.Context) {
	check := keto.GetCheckRequest{
		Namespace: "files",
		Object:    "file1",
		Relation:  "view",
		SubjectId: "user1",
	}
	
	resp, _, err := client.PermissionApi.CheckPermission(ctx).GetCheckRequest(check).Execute()
	if err != nil {
		fmt.Printf("Error checking permission: %v\n", err)
		return
	}
	
	if resp.GetAllowed() {
		fmt.Println("Permission granted")
	} else {
		fmt.Println("Permission denied")
	}
}

4. 扩展关系

Keto支持定义关系之间的继承：

// 定义继承关系
func addInheritance(client *keto.APIClient, ctx context.Context) {
	// 管理员可以执行所有操作
	adminTuple := keto.RelationQuery{
		Namespace: "files",
		Object:    "file1",
		Relation:  "admin",
		SubjectId: "user2",
	}
	
	// 定义admin包含view权限
	inheritanceTuple := keto.RelationQuery{
		Namespace: "files",
		Object:    "file1",
		Relation:  "view",
		SubjectSet: &keto.SubjectSet{
			Namespace: "files",
			Object:    "file1",
			Relation:  "admin",
		},
	}
	
	_, _, err := client.WriteApi.CreateRelationTuple(ctx).RelationQuery(adminTuple).Execute()
	if err != nil {
		fmt.Printf("Error creating admin tuple: %v\n", err)
		return
	}
	
	_, _, err = client.WriteApi.CreateRelationTuple(ctx).RelationQuery(inheritanceTuple).Execute()
	if err != nil {
		fmt.Printf("Error creating inheritance tuple: %v\n", err)
		return
	}
	
	fmt.Println("Inheritance relationship created")
}

5. 批量操作

// 批量操作
func batchOperations(client *keto.APIClient, ctx context.Context) {
	// 创建多个关系
	tuples := []keto.RelationQuery{
		{
			Namespace: "files",
			Object:    "file2",
			Relation:  "view",
			SubjectId: "user1",
		},
		{
			Namespace: "files",
			Object:    "file3",
			Relation:  "edit",
			SubjectId: "user2",
		},
	}
	
	for _, tuple := range tuples {
		_, _, err := client.WriteApi.CreateRelationTuple(ctx).RelationQuery(tuple).Execute()
		if err != nil {
			fmt.Printf("Error creating tuple: %v\n", err)
			continue
		}
	}
	
	fmt.Println("Batch operations completed")
}

实际应用示例

下面是一个更完整的示例，模拟文件共享系统：

type FileSharingSystem struct {
	client *keto.APIClient
	ctx    context.Context
}

func NewFileSharingSystem() *FileSharingSystem {
	cfg := keto.NewConfiguration()
	cfg.Servers = []keto.ServerConfiguration{{URL: "http://localhost:4466"}}
	return &FileSharingSystem{
		client: keto.NewAPIClient(cfg),
		ctx:    context.Background(),
	}
}

func (f *FileSharingSystem) ShareFile(fileID, userID, permission string) error {
	tuple := keto.RelationQuery{
		Namespace: "files",
		Object:    fileID,
		Relation:  permission,
		SubjectId: userID,
	}
	
	_, _, err := f.client.WriteApi.CreateRelationTuple(f.ctx).RelationQuery(tuple).Execute()
	return err
}

func (f *FileSharingSystem) CheckAccess(fileID, userID, permission string) (bool, error) {
	check := keto.GetCheckRequest{
		Namespace: "files",
		Object:    fileID,
		Relation:  permission,
		SubjectId: userID,
	}
	
	resp, _, err := f.client.PermissionApi.CheckPermission(f.ctx).GetCheckRequest(check).Execute()
	if err != nil {
		return false, err
	}
	return resp.GetAllowed(), nil
}

func main() {
	fss := NewFileSharingSystem()
	
	// 分享文件
	err := fss.ShareFile("report.pdf", "alice", "view")
	if err != nil {
		fmt.Printf("Error sharing file: %v\n", err)
		return
	}
	
	// 检查权限
	allowed, err := fss.CheckAccess("report.pdf", "alice", "view")
	if err != nil {
		fmt.Printf("Error checking access: %v\n", err)
		return
	}
	
	if allowed {
		fmt.Println("Alice can view the report")
	} else {
		fmt.Println("Alice cannot view the report")
	}
}

最佳实践

1. 命名空间设计：合理规划命名空间，如按资源类型划分
2. 关系设计：设计清晰的关系层次结构
3. 批量操作：尽量使用批量接口减少网络开销
4. 缓存：对频繁检查的权限考虑本地缓存
5. 监控：监控权限检查的延迟和错误率

Keto提供了强大的权限管理能力，特别适合需要复杂权限关系的分布式系统。通过合理设计关系模型，可以实现灵活的权限控制策略。