본문으로 건너뛰기

Go에서의 gRPC 인증

gRPC 서비스에서는 모든 호출이 /library.v1.BookService/DeleteBook과 같은 전체 메서드 이름을 지정합니다. 이는 메서드 수준 권한 부여를 단순하게 만듭니다: 어떤 역할이 어떤 메서드를 호출할 수 있는지 결정하고, 핸들러가 실행되기 전에 서버 인터셉터에서 이를 확인하면 됩니다. 이 튜토리얼에서는 Go와 Casbin을 사용하여 unary 및 streaming 호출 모두에 대해 이를 구현합니다.

1. 서비스 정의​

예제는 작은 도서관 서비스입니다. 이를 proto/library/v1/library.proto로 저장하세요:

proto/library/v1/library.proto
syntax = "proto3";

package library.v1;

option go_package = "example.com/library/gen/library/v1;libraryv1";

service BookService {
rpc GetBook(GetBookRequest) returns (Book);
rpc CreateBook(CreateBookRequest) returns (Book);
rpc DeleteBook(DeleteBookRequest) returns (DeleteBookResponse);
}

message Book {
string id = 1;
string title = 2;
}

message GetBookRequest {
string id = 1;
}

message CreateBookRequest {
string title = 1;
}

message DeleteBookRequest {
string id = 1;
}

message DeleteBookResponse {}

protoc(또는 buf generate)을 사용하여 Go 코드를 생성하세요:

go mod init example.com/library
go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest

protoc -Iproto --go_out=. --go_opt=module=example.com/library --go-grpc_out=. --go-grpc_opt=module=example.com/library proto/library/v1/library.proto

go get github.com/casbin/casbin/v3 google.golang.org/grpc

2. 모델 작성​

이를 model.conf로 저장하세요:

[request_definition]
r = sub, method

[policy_definition]
p = sub, method

[role_definition]
g = _, _

[policy_effect]
e = some(where (p.eft == allow))

[matchers]
m = g(r.sub, p.sub) && keyMatch(r.method, p.method)
  • r = sub, method: 각 요청은 호출자와 전체 gRPC 메서드 이름으로 구성됩니다.
  • g = _, _: 호출자는 역할에 할당될 수 있으며, 역할은 다른 역할에 할당될 수 있습니다.
  • keyMatch를 사용하면 규칙이 *로 끝날 수 있으므로 한 줄로 서비스의 모든 메서드를 커버할 수 있습니다.

3. 정책 작성​

이를 policy.csv로 저장하세요:

p, reader, /library.v1.BookService/GetBook
p, librarian, /library.v1.BookService/CreateBook
p, admin, /library.v1.BookService/*

g, librarian, reader
g, admin, librarian

g, alice, admin
g, bob, librarian
g, carol, reader

reader는 GetBook을 호출할 수 있고, librarian은 CreateBook도 호출할 수 있으며, admin은 나중에 추가된 메서드를 포함하여 BookService의 모든 메서드를 호출할 수 있습니다. 역할 간의 g 줄은 계층 구조를 구축하므로 각 역할은 해당 수준에서 새로운 항목만 나열합니다.

4. 인터셉터 작성​

server/authz.go
package main

import (
"context"

"github.com/casbin/casbin/v3"
"google.golang.org/grpc"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/metadata"
"google.golang.org/grpc/status"
)

// authorize asks Casbin whether the caller may invoke fullMethod, such as /library.v1.BookService/DeleteBook.
func authorize(ctx context.Context, e *casbin.Enforcer, fullMethod string) error {
// Replace this with the identity from your authentication layer,
// such as a verified JWT in the "authorization" metadata or the client's mTLS certificate.
md, _ := metadata.FromIncomingContext(ctx)
users := md.Get("x-user")
if len(users) == 0 {
return status.Error(codes.Unauthenticated, "missing user")
}

allowed, err := e.Enforce(users[0], fullMethod)
if err != nil {
return status.Error(codes.Internal, err.Error())
}
if !allowed {
return status.Errorf(codes.PermissionDenied, "%s may not call %s", users[0], fullMethod)
}
return nil
}

func UnaryAuthz(e *casbin.Enforcer) grpc.UnaryServerInterceptor {
return func(ctx context.Context, req any, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (any, error) {
if err := authorize(ctx, e, info.FullMethod); err != nil {
return nil, err
}
return handler(ctx, req)
}
}

func StreamAuthz(e *casbin.Enforcer) grpc.StreamServerInterceptor {
return func(srv any, ss grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error {
if err := authorize(ss.Context(), e, info.FullMethod); err != nil {
return err
}
return handler(srv, ss)
}
}

인증되지 않은 호출자에게는 Unauthenticated이 반환되고, 인증되었지만 권한이 없는 호출자에게는 PermissionDenied가 반환됩니다. 이는 gRPC 클라이언트와 게이트웨이가 기대하는 동작입니다.

노트

x-user 메타데이터는 예제를 간결하게 유지하기 위해 사용됩니다. Casbin은 권한 부여만 처리합니다. 실제 서비스에서는 authorization 메타데이터에서 토큰을 검증하거나, mTLS를 사용하는 경우 peer.FromContext를 통해 클라이언트 인증서에서 신원 정보를 가져오세요. 인증 인터셉터가 이미 이를 수행하는 경우, 권한 부여 인터셉터 앞에 체이닝하세요.

5. 서버에 등록​

server/main.go
package main

import (
"context"
"log"
"net"

"github.com/casbin/casbin/v3"
"google.golang.org/grpc"

libraryv1 "example.com/library/gen/library/v1"
)

type bookService struct {
libraryv1.UnimplementedBookServiceServer
}

func (bookService) GetBook(ctx context.Context, req *libraryv1.GetBookRequest) (*libraryv1.Book, error) {
return &libraryv1.Book{Id: req.GetId(), Title: "The Go Programming Language"}, nil
}

func (bookService) CreateBook(ctx context.Context, req *libraryv1.CreateBookRequest) (*libraryv1.Book, error) {
return &libraryv1.Book{Id: "2", Title: req.GetTitle()}, nil
}

func (bookService) DeleteBook(ctx context.Context, req *libraryv1.DeleteBookRequest) (*libraryv1.DeleteBookResponse, error) {
return &libraryv1.DeleteBookResponse{}, nil
}

func main() {
e, err := casbin.NewEnforcer("model.conf", "policy.csv")
if err != nil {
log.Fatal(err)
}

s := grpc.NewServer(
grpc.ChainUnaryInterceptor(UnaryAuthz(e)),
grpc.ChainStreamInterceptor(StreamAuthz(e)),
)
libraryv1.RegisterBookServiceServer(s, bookService{})

lis, err := net.Listen("tcp", ":50051")
if err != nil {
log.Fatal(err)
}
log.Fatal(s.Serve(lis))
}

grpc.ChainUnaryInterceptor와 grpc.ChainStreamInterceptor는 여러 인터셉터를 허용하므로 로깅, 메트릭 및 인증을 권한 부여 검사 옆에 추가할 수 있습니다.

6. 테스트​

서버를 시작하세요:

go run ./server

이 클라이언트는 네 가지 다른 사용자로 모든 메서드를 호출합니다:

client/main.go
package main

import (
"context"
"fmt"
"log"

"google.golang.org/grpc"
"google.golang.org/grpc/credentials/insecure"
"google.golang.org/grpc/metadata"
"google.golang.org/grpc/status"

libraryv1 "example.com/library/gen/library/v1"
)

func main() {
conn, err := grpc.NewClient("localhost:50051", grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil {
log.Fatal(err)
}
defer conn.Close()
client := libraryv1.NewBookServiceClient(conn)

for _, user := range []string{"alice", "bob", "carol", "dave"} {
ctx := metadata.AppendToOutgoingContext(context.Background(), "x-user", user)

_, getErr := client.GetBook(ctx, &libraryv1.GetBookRequest{Id: "1"})
_, createErr := client.CreateBook(ctx, &libraryv1.CreateBookRequest{Title: "New book"})
_, deleteErr := client.DeleteBook(ctx, &libraryv1.DeleteBookRequest{Id: "1"})

fmt.Printf("%-6s GetBook=%-16v CreateBook=%-16v DeleteBook=%v\n", user,
status.Code(getErr), status.Code(createErr), status.Code(deleteErr))
}
}
go run ./client
alice GetBook=OK CreateBook=OK DeleteBook=OK
bob GetBook=OK CreateBook=OK DeleteBook=PermissionDenied
carol GetBook=OK CreateBook=PermissionDenied DeleteBook=PermissionDenied
dave GetBook=PermissionDenied CreateBook=PermissionDenied DeleteBook=PermissionDenied

grpcurl을 사용할 경우, 헤더로 사용자 정보를 전달하세요: grpcurl -plaintext -H "x-user: bob" ....

심화 학습​

  • 공개 메서드. 헬스 체크와 서버 리플렉션은 일반적으로 사용자가 필요하지 않습니다. 이러한 경우 authorize 함수의 상단에서 미리 반환하세요. 예를 들어 if strings.HasPrefix(fullMethod, "/grpc.health.v1.Health/") { return nil }처럼 사용할 수 있습니다.
  • 레코드별 규칙. 인터셉터는 핸들러가 실행되기 전에 메서드 이름을 확인합니다. "사서는 자신의 지점 책만 삭제할 수 있다"와 같이 레코드에 의존하는 규칙은 레코드를 로드한 후 핸들러 내부에 두어야 합니다. ABAC 튜토리얼을 참조하세요.
  • 다중 테넌트 서비스. 테넌트 정보를 메타데이터에서 세 번째 인자로 전달하고 RBAC with domains를 사용하세요.
  • 정책을 데이터베이스에 저장. policy.csv를 adapter로 대체하고, 여러 복제본이 동일한 서비스를 제공하는 경우 watcher를 추가하세요.
  • HTTP API. Go에서의 REST 엔드포인트의 경우 RBAC in Go with Gin을 참조하세요.

Comments are powered by giscus and GitHub Discussions. They load from giscus.app and GitHub only after you click the button below.