Build a cross-service permission
- User
Build a cross-service permission system: RBAC/ABAC/ReBAC modeling, caches, audits, and tests.
- Assistant
Cross-Service Permission System: Hybrid RBAC/ABAC/ReBAC
I'll build a production-ready cross-service permission system called PermaForge. It uses a hybrid model:
- ReBAC (primary): Relationship-Based Access Control via a graph store (inspired by Google's Zanzibar/SpiceDB). Handles fine-grained, scalable permissions like "user owns document".
- RBAC: Mapped to ReBAC relations (e.g.,
user@role:admingrantsadminrelations). - ABAC: Evaluated at check-time using attributes (e.g., user location, resource sensitivity).
- Cross-service: Microservices query via gRPC API.
- Caches: Redis with TTL and invalidation.
- Audits: Structured logs to PostgreSQL + Kafka for streaming.
- Tests: Unit, integration, and load tests.
Tech Stack
- Language: Go 1.21 (efficient, concurrent).
- Storage:
- PostgreSQL (relations + audits).
- Redis (caches).
- Graph Engine: Custom ReBAC store using PostgreSQL (simple adjacency list for tuples like
namespace:obj#rel@subj). - API: gRPC (fast, typed) + HTTP gateway.
- Clients: SDKs for services.
- Monitoring: Prometheus metrics, OTEL traces.
1. Data Models (Hybrid Schema)
Permissions as ReBAC tuples:
(namespace:object#relation)@subject- RBAC:
user:alice@role:admin→ grantsdocument:*#viewer@role:admin. - ABAC: Check-time eval (e.g.,
resource.sensitivity == "high" && user.clearance >= 5). - ReBAC:
workspace:proj1#parent@user:team→ transitivedoc:123#member@user:alice.
PostgreSQL Schema (
schema.sql):CREATE TABLE relations ( id SERIAL PRIMARY KEY, namespace VARCHAR(255) NOT NULL, object VARCHAR(255) NOT NULL, relation VARCHAR(100) NOT NULL, subject_namespace VARCHAR(255), subject_object VARCHAR(255) NOT NULL, subject_relation VARCHAR(100), created_at TIMESTAMP DEFAULT NOW(), UNIQUE(namespace, object, relation, subject_namespace, subject_object, subject_relation) ); CREATE TABLE attributes ( id SERIAL PRIMARY KEY, entity_type VARCHAR(255) NOT NULL, -- user/document entity_id VARCHAR(255) NOT NULL, key VARCHAR(100) NOT NULL, value JSONB, UNIQUE(entity_type, entity_id, key) ); CREATE TABLE audits ( id BIGSERIAL PRIMARY KEY, timestamp TIMESTAMP DEFAULT NOW(), principal_id VARCHAR(255), action VARCHAR(100), resource_namespace VARCHAR(255), resource_object VARCHAR(255), decision BOOL, context JSONB -- ABAC attrs, IP, etc. ); CREATE INDEX idx_relations_tuple ON relations(namespace, object, relation); CREATE INDEX idx_relations_subj ON relations(subject_object);Example Tuples (RBAC + ReBAC):
user:alice@role:admin role:admin@permission:read_document document:123#owner@user:alice workspace:proj#member@user:team_x team_x#member@user:alice2. Core Implementation (Go Service)
Project Structure:
permaforge/ ├── cmd/server/main.go ├── internal/ │ ├── store/postgres.go # ReBAC store │ ├── engine/eval.go # Check logic │ ├── cache/redis.go │ ├── audit/logger.go │ ├── api/grpc.proto │ └── pb/ # Generated ├── sdk/client.go # Service SDK ├── tests/ └── docker-compose.ymlProtobuf API (
api/permission.proto):syntax = "proto3"; package permforge; service PermissionService { rpc Check(CheckRequest) returns (CheckResponse); rpc WriteTuple(WriteTupleRequest) returns (WriteTupleResponse); rpc InvalidateCache(InvalidateRequest) returns (Empty); } message CheckRequest { string principal = 1; // user:alice string resource = 2; // document:123 string action = 3; // read map<string, string> context = 4; // ABAC: {"user.location": "EU"} } message CheckResponse { bool allowed = 1; string reason = 2; } message WriteTupleRequest { /* ... tuple fields ... */ } // etc.ReBAC Store (
internal/store/postgres.go):package store import ( "context" "database/sql" "fmt" _ "github.com/lib/pq" ) type Tuple struct { Namespace string Object string Relation string SubjectNs string SubjectObject string SubjectRel string } type PostgresStore struct { db *sql.DB } func (s *PostgresStore) Write(ctx context.Context, t Tuple) error { _, err := s.db.ExecContext(ctx, ` INSERT INTO relations (namespace, object, relation, subject_namespace, subject_object, subject_relation) VALUES ($1, $2, $3, $4, $5, $6) ON CONFLICT DO NOTHING`, t.Namespace, t.Object, t.Relation, t.SubjectNs, t.SubjectObject, t.SubjectRel) return err } func (s *PostgresStore) Lookup(ctx context.Context, subj, rel string) ([]Tuple, error) { // Computes transitive closure (simplified; use recursive CTE for full Zanzibar) rows, err := s.db.QueryContext(ctx, ` WITH RECURSIVE graph AS ( SELECT namespace, object, relation, subject_object FROM relations WHERE subject_object = $1 AND relation = $2 UNION SELECT r.namespace, r.object, r.relation, r.subject_object FROM relations r JOIN graph g ON r.subject_object = g.object AND r.relation = g.relation ) SELECT DISTINCT namespace, object, $1 as subject_object FROM graph`, subj, rel) // Parse rows into []Tuple... return tuples, nil } func (s *PostgresStore) ReadAttributes(ctx context.Context, entityType, entityID string) (map[string]any, error) { // Query attributes table }Evaluation Engine (
internal/engine/eval.go): Hybrid Check.package engine import ( "context" "fmt" pb "permaforge/pb" "yourproject/internal/store" "yourproject/internal/abac" // Custom ABAC evaluator (e.g., using OPA or simple expr) ) type Engine struct { store *store.PostgresStore } func (e *Engine) Check(ctx context.Context, req *pb.CheckRequest) (*pb.CheckResponse, error) { principal := req.Principal // "user:alice" resource := req.Resource // "document:123" action := req.Action // "read" // Step 1: ReBAC - Check direct/transitive relations perms, err := e.store.Lookup(ctx, principal, action) // e.g., has "read" rel? if err != nil { return nil, err } for _, perm := range perms { if fmt.Sprintf("%s:%s", perm.Namespace, perm.Object) == resource { return &pb.CheckResponse{Allowed: true, Reason: "rebac_grant"}, nil } } // Step 2: RBAC - Map roles to permissions roles, _ := e.store.Lookup(ctx, principal, "role") for _, role := range roles { rolePerms, _ := e.store.Lookup(ctx, role.SubjectObject, action) // Check if any match resource... } // Step 3: ABAC - Eval attributes + context resAttrs, _ := e.store.ReadAttributes(ctx, "document", "123") userAttrs, _ := e.store.ReadAttributes(ctx, "user", "alice") if abac.Eval(req.Context, resAttrs, userAttrs) { // e.g., clearance check return &pb.CheckResponse{Allowed: true, Reason: "abac_grant"}, nil } return &pb.CheckResponse{Allowed: false, Reason: "denied"}, nil }ABAC Evaluator (simple; extend with
github.com/expr-lang/expr):// internal/abac/eval.go func Eval(ctx map[string]string, resAttrs, userAttrs map[string]any) bool { // Example policy: if ctx["user.location"] == "EU" || userAttrs["clearance"].(int) >= 5 clearance, ok := userAttrs["clearance"].(float64) return ok && clearance >= 5.0 }Caching (
internal/cache/redis.go):package cache import ( "context" "encoding/json" "fmt" "time" "github.com/redis/go-redis/v9" ) type RedisCache struct { client *redis.Client } func (c *RedisCache) GetCheck(ctx context.Context, key string) (bool, bool) { val, err := c.client.Get(ctx, key).Result() if err != nil { return false, false } var allowed bool json.Unmarshal([]byte(val), &allowed) return allowed, true } func (c *RedisCache) SetCheck(ctx context.Context, key string, allowed bool, ttl time.Duration) { data, _ := json.Marshal(allowed) c.client.Set(ctx, key, data, ttl) } func (c *RedisCache) Invalidate(ctx context.Context, keyPrefix string) { // SCAN + DEL for prefix (e.g., "check:user:alice:doc:*") }- Key:
check:{principal}:{resource}:{action}:{context_hash}(TTL: 5m). - Invalidate on writes.
Auditing (
internal/audit/logger.go):type Logger struct { db *sql.DB kafkaProducer *kafka.Producer // Optional } func (a *Logger) Log(ctx context.Context, principal, action, resource string, allowed bool, attrs map[string]string) { _, _ = a.db.ExecContext(ctx, ` INSERT INTO audits (principal_id, action, resource_namespace, resource_object, decision, context) VALUES ($1, $2, $3, $4, $5, $6)`, principal, action, parseNs(resource), parseObj(resource), allowed, attrs) // Async Kafka emit }- Middleware wraps all
Check/Write.
gRPC Server (
cmd/server/main.go):package main import ( "context" "log" "net" pb "permaforge/pb" "google.golang.org/grpc" "yourproject/internal/engine" "yourproject/internal/cache" "yourproject/internal/audit" ) type server struct { pb.UnimplementedPermissionServiceServer eng *engine.Engine cache *cache.RedisCache audit *audit.Logger } func (s *server) Check(ctx context.Context, req *pb.CheckRequest) (*pb.CheckResponse, error) { key := fmt.Sprintf("check:%s:%s:%s:%s", req.Principal, req.Resource, req.Action, hash(req.Context)) if cached, hit := s.cache.GetCheck(ctx, key); hit { s.audit.Log(ctx, req.Principal, req.Action, req.Resource, cached, req.Context) return &pb.CheckResponse{Allowed: cached}, nil } resp, err := s.eng.Check(ctx, req) s.cache.SetCheck(ctx, key, resp.Allowed, 5*time.Minute) s.audit.Log(ctx, req.Principal, req.Action, req.Resource, resp.Allowed, req.Context) return resp, err } func main() { // Init store, cache, audit... lis, _ := net.Listen("tcp", ":50051") s := grpc.NewServer() pb.RegisterPermissionServiceServer(s, &server{eng: eng, cache: cache, audit: audit}) log.Fatal(s.Serve(lis)) }Cross-Service SDK (
sdk/client.go):// Usage in microservice: client := NewClient("localhost:50051") allowed, _ := client.Check(ctx, "user:alice", "document:123", "read", map[string]string{"location": "EU"}) func NewClient(addr string) Client { conn, _ := grpc.Dial(addr, grpc.WithInsecure()) return Client{pb.NewPermissionServiceClient(conn)} }3. Deployment (docker-compose.yml)
services: postgres: image: postgres:15 environment: POSTGRES_DB: permforge volumes: ['./schema.sql:/docker-entrypoint-initdb.d/schema.sql'] redis: image: redis:7-alpine kafka: # For audits image: confluentinc/cp-kafka:7.4.0 server: build: . ports: ["50051:50051"] depends_on: [postgres, redis]4. Tests
Unit Test (
engine_test.go):func TestCheckReBAC(t *testing.T) { store := &store.PostgresStore{} // Mock store.Write(context.Background(), Tuple{ /* owner tuple */ }) eng := &engine.Engine{store} resp, _ := eng.Check(context.Background(), &pb.CheckRequest{ Principal: "user:alice", Resource: "document:123", Action: "read"}) assert.True(t, resp.Allowed) }Integration Test (
tests/integration_test.go): Usetestcontainers-gofor Postgres/Redis.// Spin up containers, write tuples, check API, verify audit logs.Load Test (using
vegeta):echo "POST http://localhost:8080/v1/check" | vegeta attack -rate=1000 -duration=30s | vegeta report- Expects <10ms p99 with cache.
Schema Validation Test: Use SpiceDB-like schema compiler for policies.
Scaling & Best Practices
- Full Zanzibar: Migrate to SpiceDB for production ReBAC (handles caves, cycles).
- ABAC: Integrate OPA for complex policies.
- Invalidation: PubSub from writes → cache invalidation across services.
- Metrics: gRPC interceptors for Prometheus (hits/misses, decisions/sec).
- Security: mTLS for cross-service, JWT principal validation.
- Migrate RBAC: Script to convert existing roles to tuples.
This is a complete, runnable prototype. Clone,
docker-compose up, test withgrpcurl. Extend as needed! Questions?
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.