Golang基于Zanzibar论文实现细粒度授权系统插件库OpenFGA(CNCF)的使用

OpenFGA是一个高性能且灵活的授权/权限引擎，专为开发者设计，灵感来源于Google的Zanzibar论文。它旨在帮助开发者轻松建模应用程序权限，并将细粒度授权集成到应用中。

OpenFGA简介

OpenFGA支持内存数据存储用于快速开发，以及可插拔的数据库模块。目前支持PostgreSQL 14+、MySQL 8和SQLite(目前处于测试阶段)。

它提供HTTP API和gRPC API，并有多种语言的SDK支持，包括Java、Node.js/JavaScript、GoLang、Python和.NET。

安装OpenFGA

使用Docker安装

docker pull openfga/openfga
docker run -p 8080:8080 -p 3000:3000 openfga/openfga run

使用Docker Compose安装

1. 下载docker-compose.yaml文件：

curl -LO https://openfga.dev/docker-compose.yaml

1. 启动服务：

docker compose up

使用Homebrew安装

brew install openfga

从源码构建

使用go install

export PATH=$PATH:$(go env GOBIN)
go install github.com/openfga/openfga/cmd/openfga
./openfga run

使用go build

git clone https://github.com/openfga/openfga.git && cd openfga
go build -o ./openfga ./cmd/openfga
./openfga run

验证安装

创建OpenFGA存储来验证安装：

curl -X POST 'localhost:8080/stores' \
--header 'Content-Type: application/json' \
--data-raw '{
    "name": "openfga-demo"
}'

成功响应示例：

{
  "id": "01G3EMTKQRKJ93PFVDA1SJHWD2",
  "name": "openfga-demo",
  "created_at": "2022-05-19T17:11:12.888680Z",
  "updated_at": "2022-05-19T17:11:12.888680Z"
}

使用Go SDK示例

以下是一个完整的Go示例，展示如何使用OpenFGA Go SDK：

package main

import (
	"context"
	"fmt"
	"log"

	openfga "github.com/openfga/go-sdk"
	"github.com/openfga/go-sdk/client"
)

func main() {
	// 初始化OpenFGA客户端配置
	configuration, err := client.NewConfiguration(client.Configuration{
		ApiScheme: "http",
		ApiHost:   "localhost:8080",
	})
	if err != nil {
		log.Fatal(err)
	}

	// 创建OpenFGA客户端
	fgaClient := client.NewAPIClient(configuration)

	// 创建存储
	store, _, err := fgaClient.OpenFgaApi.CreateStore(context.Background()).Body(client.ClientCreateStoreRequest{
		Name: "go-sdk-demo",
	}).Execute()
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Created store with id: %s\n", store.Id)

	// 定义授权模型
	model := client.ClientWriteAuthorizationModelRequest{
		TypeDefinitions: []openfga.TypeDefinition{
			{
				Type: "user",
			},
			{
				Type: "document",
				Relations: &map[string]openfga.Userset{
					"reader": {
						This: &map[string]interface{}{},
					},
					"writer": {
						This: &map[string]interface{}{},
					},
					"owner": {
						This: &map[string]interface{}{},
					},
				},
				Metadata: &openfga.Metadata{
					Relations: &map[string]openfga.RelationMetadata{
						"reader": {
							DirectlyRelatedUserTypes: &[]openfga.RelationReference{
								{Type: "user"},
							},
						},
						"writer": {
							DirectlyRelatedUserTypes: &[]openfga.RelationReference{
								{Type: "user"},
							},
						},
						"owner": {
							DirectlyRelatedUserTypes: &[]openfga.RelationReference{
								{Type: "user"},
							},
						},
					},
				},
			},
		},
		SchemaVersion: "1.1",
	}

	// 写入授权模型
	authModel, _, err := fgaClient.OpenFgaApi.WriteAuthorizationModel(context.Background()).Body(model).Execute()
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Created authorization model with id: %s\n", authModel.AuthorizationModelId)

	// 写入关系元组
	_, err = fgaClient.OpenFgaApi.Write(context.Background()).Body(client.ClientWriteRequest{
		Writes: &[]client.ClientTupleKey{
			{
				User:     "user:anne",
				Relation: "owner",
				Object:   "document:1",
			},
			{
				User:     "user:anne",
				Relation: "writer",
				Object:   "document:1",
			},
		},
	}).Execute()
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Successfully wrote tuples")

	// 检查权限
	check, _, err := fgaClient.OpenFgaApi.Check(context.Background()).Body(client.ClientCheckRequest{
		User:     "user:anne",
		Relation: "reader",
		Object:   "document:1",
	}).Execute()
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Check result: %v\n", check.Allowed)
}

生产环境注意事项

OpenFGA核心服务自2021年12月起已在Auth0 FGA生产环境中使用。内存存储适配器仅用于开发目的，不建议在生产环境中使用。

社区支持

OpenFGA有一个活跃的社区，定期举行社区会议讨论项目发展和收集反馈。