AI 에이전트 Zero Trust 파이프라인: SPIFFE/SPIRE + Cedar 실전 구축

┌─────────────────────────────────────────────────────┐
│                   SPIRE Server                       │
│  - 트러스트 번들(Root CA) 관리                        │
│  - 등록된 워크로드 항목 저장                           │
│  - SVID 서명 및 발급                                  │
└──────────────────────┬──────────────────────────────┘
                       │ mTLS
┌──────────────────────▼──────────────────────────────┐
│              SPIRE Agent (DaemonSet)                 │
│  - 노드 어테스테이션 (k8s_sat / AWS IID / GCP GCE)   │
│  - 워크로드 어테스테이션 (PID, k8s Service Account)   │
│  - Workload API (Unix socket) 제공                   │
└──────────────────────┬──────────────────────────────┘
                       │ Unix Socket
         ┌─────────────▼─────────────┐
         │      AI 에이전트 프로세스   │
         │  SVID 수령 및 자동 갱신     │
         └───────────────────────────┘

# X.509-SVID 발급 확인
spire-agent api fetch x509 \
  -socketPath /run/spire/sockets/agent.sock
 
# 출력 예시:
# SPIFFE ID: spiffe://prod.example.com/ns/ai-agents/sa/orchestrator
# 유효기간: 5분 (TTL 설정에 따라)
# Subject Alternative Name URI: spiffe://prod.example.com/ns/ai-agents/sa/orchestrator

// Cedar 정책의 기본 구조
permit (
  principal is WorkloadIdentity,    // 누가
  action == Action::"invoke_model", // 무엇을
  resource == ModelEndpoint::"gpt-v2" // 어디에
)
when {
  principal.spiffe_id == "spiffe://prod.example.com/ns/ai-agents/sa/orchestrator"
};

AI 에이전트 프로세스 기동
       ↓
SPIRE Agent: 워크로드 어테스테이션
 (kubelet API → Pod 서비스어카운트·네임스페이스 검증)
       ↓
SPIRE Server: X.509-SVID 또는 JWT-SVID 발급
       ↓
에이전트가 SVID를 제시하며 서비스 호출
       ↓
Policy Decision Point (PDP)
 JWT-SVID 검증(JWKS/트러스트 번들) → SPIFFE ID 추출 → Cedar 정책 평가
       ↓
접근 허용 or 거부 (기본: deny-all) + 결정 로깅

// schema.json
{
  "": {
    "entityTypes": {
      "WorkloadIdentity": {
        "shape": {
          "type": "Record",
          "attributes": {
            "spiffe_id": { "type": "String", "required": true }
          }
        }
      },
      "ModelEndpoint": {},
      "DataStore": {
        "shape": {
          "type": "Record",
          "attributes": {
            "classification": { "type": "String", "required": true }
          }
        }
      },
      "Environment": {}
    },
    "actions": {
      "invoke_model": {
        "appliesTo": {
          "principalTypes": ["WorkloadIdentity"],
          "resourceTypes": ["ModelEndpoint"]
        }
      },
      "write_data": {
        "appliesTo": {
          "principalTypes": ["WorkloadIdentity"],
          "resourceTypes": ["DataStore"]
        }
      },
      "read_data": {
        "appliesTo": {
          "principalTypes": ["WorkloadIdentity"],
          "resourceTypes": ["DataStore"]
        }
      }
    }
  }
}

# AI 오케스트레이터 에이전트 등록
spire-server entry create \
  -spiffeID spiffe://prod.example.com/ns/ai-agents/sa/orchestrator \
  -parentID spiffe://prod.example.com/k8s-workload-registrar/node \
  -selector k8s:ns:ai-agents \
  -selector k8s:sa:orchestrator-sa \
  -ttl 300   # SVID 유효기간 5분 설정
 
# 모델 서빙 서버 등록
spire-server entry create \
  -spiffeID spiffe://prod.example.com/ns/inference/sa/vllm-server \
  -parentID spiffe://prod.example.com/k8s-workload-registrar/node \
  -selector k8s:ns:inference \
  -selector k8s:sa:vllm-sa \
  -ttl 300

# /etc/spiffe-helper/helper.conf
agent_address         = "/run/spire/sockets/agent.sock"
cmd                   = "echo"
cmd_args              = "svid-rotated"
cert_dir              = "/run/secrets/svid"
svid_file_name        = "svid.pem"
svid_key_file_name    = "key.pem"
svid_bundle_file_name = "bundle.pem"
renew_signal          = "SIGUSR1"

# k8s deployment 일부 — sidecar 패턴
containers:
  - name: ai-orchestrator
    image: my-agent:latest
    volumeMounts:
      - name: spiffe-workload-api
        mountPath: /run/spire/sockets
        readOnly: true
      - name: svid-volume
        mountPath: /run/secrets/svid
 
  - name: spiffe-helper
    image: ghcr.io/spiffe/spiffe-helper:latest
    args: ["-config", "/etc/spiffe-helper/helper.conf"]
    volumeMounts:
      - name: spiffe-workload-api
        mountPath: /run/spire/sockets
      - name: svid-volume
        mountPath: /run/secrets/svid
      - name: helper-config
        mountPath: /etc/spiffe-helper
 
volumes:
  - name: spiffe-workload-api
    hostPath:
      path: /run/spire/sockets
      type: Directory
  - name: svid-volume
    emptyDir:
      medium: Memory  # 메모리 내 저장으로 디스크 노출 최소화
  - name: helper-config
    configMap:
      name: spiffe-helper-config

// policies/ai-agent-policy.cedar
 
// 오케스트레이터만 모델 추론 호출 허용
permit (
  principal is WorkloadIdentity,
  action == Action::"invoke_model",
  resource == ModelEndpoint::"gpt-inference-v2"
)
when {
  principal.spiffe_id == "spiffe://prod.example.com/ns/ai-agents/sa/orchestrator"
};
 
// PII 데이터 스토어에 대한 쓰기 작업 전면 금지
forbid (
  principal,
  action == Action::"write_data",
  resource is DataStore
)
when { resource.classification == "PII" };
 
// 분석 에이전트는 비PII 데이터만 읽기 허용
permit (
  principal is WorkloadIdentity,
  action == Action::"read_data",
  resource is DataStore
)
when {
  principal.spiffe_id == "spiffe://prod.example.com/ns/ai-agents/sa/analytics"
  && resource.classification != "PII"
};

# 스키마 파일을 기준으로 정책 검증
cedar validate \
  --schema schema.json \
  --policies policies/
 
# 특정 요청 시뮬레이션 — 정책 평가 결과 확인
cedar authorize \
  --policies policies/ \
  --schema schema.json \
  --principal 'WorkloadIdentity::"spiffe://prod.example.com/ns/ai-agents/sa/orchestrator"' \
  --action 'Action::"invoke_model"' \
  --resource 'ModelEndpoint::"gpt-inference-v2"' \
  --context '{}'
# 출력: ALLOW

# JWT-SVID 요청 및 토큰 추출
JWT_TOKEN=$(spire-agent api fetch jwt \
  -socketPath /run/spire/sockets/agent.sock \
  -audience vault.prod.internal \
  | jq -r '.svids[0].token')
 
# JWT-SVID로 Vault 인증 → 단기 AWS 자격증명 획득
vault write auth/jwt/login \
  role="ci-deploy-role" \
  jwt="${JWT_TOKEN}"
 
# Vault가 반환한 단기 자격증명으로 AWS 배포 수행
# (자격증명 TTL: 15분, 파이프라인 완료 후 자동 만료)

// CI/CD 배포 권한 정책
 
// staging 환경: gitlab CI 파이프라인 전체 허용
// str:: 확장 함수로 SPIFFE ID 경로 패턴 매칭
permit (
  principal is WorkloadIdentity,
  action == Action::"deploy",
  resource == Environment::"staging"
)
when {
  str::startsWith(principal.spiffe_id, "spiffe://prod.example.com/ci/gitlab/")
  && str::endsWith(principal.spiffe_id, "/deploy")
};
 
// production 배포: main 브랜치 파이프라인만 허용
permit (
  principal is WorkloadIdentity,
  action == Action::"deploy",
  resource == Environment::"production"
)
when {
  principal.spiffe_id == "spiffe://prod.example.com/ci/gitlab/main/deploy"
  && context.approval_count >= 2
};

에이전트 A (오케스트레이터)
  SVID: spiffe://prod/ns/agents/sa/orchestrator
  권한: invoke_model, read_data, delegate
       ↓ 위임 토큰 요청 (SPIRE에 스코프 명시)
SPIRE Server
  → 에이전트 B용 제한 토큰 발급
  → 스코프: read_data만 허용, TTL: 2분
       ↓ 제한 토큰 전달
에이전트 B (분석 워커)
  위임 토큰으로만 동작
  invoke_model 호출 시도 → Cedar가 거부
  (에이전트 A가 탈취되어도 에이전트 B 권한은 최소화)

// pdp/authorize.go
package pdp
 
import (
    "context"
    "os"
 
    cedar "github.com/cedar-policy/cedar-go"
    "github.com/spiffe/go-spiffe/v2/svid/jwtsvid"
    "github.com/spiffe/go-spiffe/v2/workloadapi"
)
 
type AuthRequest struct {
    RawJWT   string // Authorization 헤더의 JWT-SVID
    Action   string // Cedar Action 이름
    Resource string // Cedar Resource ID
}
 
func Authorize(ctx context.Context, req AuthRequest) (bool, error) {
    // 1. Workload API에서 트러스트 번들(JWKS) 획득 → JWT-SVID 서명 검증
    client, _ := workloadapi.New(ctx)
    defer client.Close()
    bundles, _ := client.FetchJWTBundles(ctx)
 
    svid, err := jwtsvid.ParseAndValidate(
        req.RawJWT, bundles, []string{"pdp.prod.internal"},
    )
    if err != nil {
        return false, err // 검증 실패 → 즉시 거부
    }
 
    // 2. Cedar 정책 로드
    policyBytes, _ := os.ReadFile("policies/ai-agent-policy.cedar")
    ps, _ := cedar.NewPolicySet("policy.cedar", policyBytes)
 
    // 3. 검증된 SPIFFE ID를 Cedar 엔티티 속성으로 주입
    principalUID := cedar.NewEntityUID("WorkloadIdentity", svid.ID.String())
    entities := cedar.EntityMap{
        principalUID: {
            UID: principalUID,
            Attributes: cedar.NewRecord(cedar.RecordMap{
                "spiffe_id": cedar.String(svid.ID.String()),
            }),
        },
    }
 
    // 4. Cedar 정책 평가 → 결정 반환
    decision, _ := ps.IsAuthorized(entities, cedar.Request{
        Principal: principalUID,
        Action:    cedar.NewEntityUID("Action", req.Action),
        Resource:  cedar.NewEntityUID("ModelEndpoint", req.Resource),
    })
    return decision == cedar.Allow, nil
}