Goゼロトラストネットワーク：BeyondCorpマイクロサービスセキュリティアーキテクチャ実践2026

はじめに：なぜあなたのマイクロサービスセキュリティアーキテクチャはもう時代遅れなのか

2026年になりました。もしマイクロサービスセキュリティが「内部ネットワークは信頼、外部は不信」という従来の境界モデルに依存しているなら、システムは鍵のないドアと同じです——攻撃者が境界を突破すれば、内部ネットワークで横移動し放題です。GoogleのBeyondCorp論文はとっくに証明しています：ネットワークの位置は信頼とイコールではない。

ゼロトラストの核心原則はシンプルです：デフォルトで決して信頼せず、常に継続的に検証する。マイクロサービスアーキテクチャでは、すべてのサービス呼び出しとデータアクセスが、リクエスト元が内部か外部かに関わらず、認証と認可を経る必要があります。

Go言語は、優れた並行性モデル、豊富な暗号ライブラリエコシステム、クラウドネイティブなDNAにより、ゼロトラストアーキテクチャの実装に最適な選択です。本記事では、Goで5つのゼロトラストコアパターンをゼロから構築し、mTLSからSPIFFE/SPIREまでの完全なチェーンをカバーします。

コア概念一覧

概念	説明	Goエコシステムツール
ゼロトラストネットワーク	どのネットワーク位置も信頼せず、すべてのリクエストを継続的に検証	-
BeyondCorp	Googleが提唱する境界のないセキュリティモデル	-
mTLS	相互TLS認証、クライアントとサーバーが双方の証明書を提示	crypto/tls, cert-manager
SPIFFE	サービスの統一アイデンティティフレームワーク標準	go-spiffe, SPIRE
サービスメッシュゼロトラスト	サイドカープロキシによるゼロトラスト通信の実現	Istio, Linkerd
継続的検証	すべてのリクエストでアイデンティティと権限をチェック	Casbin, OPA
ゼロトラストAPIゲートウェイ	ゲートウェイ層でゼロトラストポリシーを一元実施	Traefik, Kong

5つのペインポイント：従来のマイクロサービスセキュリティが耐えられない理由

ペインポイント1：境界信頼モデルの崩壊。Kubernetesクラスタの内部ネットワークは安全な孤島ではありません。Pod間通信はデフォルトで暗号化されておらず、1つのPodが侵害されると、攻撃者はすべてのサービスに横移動できます。

ペインポイント2：証明書管理の悪夢。100以上のマイクロサービスでmTLS証明書を手動管理することは完全に不可能です。証明書のローテーション、失効、配布は時限爆弾です。

ペインポイント3：アイデンティティ体系の欠如。サービス間呼び出しに統一されたアイデンティティ識別子がありません。IPアドレスは信頼できず（Pod再作成でIP変更）、Service Accountは粒度が粗すぎます。

ペインポイント4：静的認可は動的脅威に対応できない。「一度認可すれば永久に有効」というモデルは、認証情報漏洩や権限昇格などの動的セキュリティイベントに対応できません。

ペインポイント5：観測可能性のブラックホール。サービス間呼び出しに暗号化通信の監査ログがなく、セキュリティインシデント発生時に追跡と遡及ができません。

パターン1：mTLS相互認証

mTLS（Mutual TLS）はゼロトラストの基盤であり、クライアントとサーバーの双方が証明書を提示してアイデンティティを検証します。

// 実行環境: Go 1.22+, 証明書管理は cert-manager v1.15+
package main

import (
	"crypto/tls"
	"crypto/x509"
	"fmt"
	"log"
	"net/http"
	"os"
	"time"
)

// MTLSConfig mTLS設定
type MTLSConfig struct {
	CertFile   string
	KeyFile    string
	CAFile     string
	ServerName string
}

// NewMTLSServer mTLS HTTPサーバーを作成
func NewMTLSServer(config MTLSConfig, handler http.Handler) (*http.Server, error) {
	// サーバー証明書の読み込み
	cert, err := tls.LoadX509KeyPair(config.CertFile, config.KeyFile)
	if err != nil {
		return nil, fmt.Errorf("サーバー証明書の読み込み失敗: %w", err)
	}

	// クライアント検証用CA証明書の読み込み
	caCert, err := os.ReadFile(config.CAFile)
	if err != nil {
		return nil, fmt.Errorf("CA証明書の読み込み失敗: %w", err)
	}

	clientCAs := x509.NewCertPool()
	if !clientCAs.AppendCertsFromPEM(caCert) {
		return nil, fmt.Errorf("CA証明書の解析失敗")
	}

	tlsConfig := &tls.Config{
		Certificates: []tls.Certificate{cert},
		ClientAuth:   tls.RequireAndVerifyClientCert, // クライアント証明書を必須に
		ClientCAs:    clientCAs,
		MinVersion:   tls.VersionTLS13, // TLS 1.3のみ許可
		ServerName:   config.ServerName,
		CurvePreferences: []tls.CurveID{
			tls.X25519,
			tls.CurveP256,
		},
	}

	return &http.Server{
		Addr:         ":8443",
		Handler:      handler,
		TLSConfig:    tlsConfig,
		ReadTimeout:  15 * time.Second,
		WriteTimeout: 15 * time.Second,
		IdleTimeout:  60 * time.Second,
	}, nil
}

// NewMTLSClient mTLS HTTPクライアントを作成
func NewMTLSClient(config MTLSConfig) (*http.Client, error) {
	cert, err := tls.LoadX509KeyPair(config.CertFile, config.KeyFile)
	if err != nil {
		return nil, fmt.Errorf("クライアント証明書の読み込み失敗: %w", err)
	}

	caCert, err := os.ReadFile(config.CAFile)
	if err != nil {
		return nil, fmt.Errorf("CA証明書の読み込み失敗: %w", err)
	}

	rootCAs := x509.NewCertPool()
	if !rootCAs.AppendCertsFromPEM(caCert) {
		return nil, fmt.Errorf("CA証明書の解析失敗")
	}

	transport := &http.Transport{
		TLSClientConfig: &tls.Config{
			Certificates:   []tls.Certificate{cert},
			RootCAs:        rootCAs,
			MinVersion:     tls.VersionTLS13,
			ServerName:     config.ServerName,
		},
		MaxIdleConns:        100,
		MaxIdleConnsPerHost: 20,
		IdleConnTimeout:     90 * time.Second,
	}

	return &http.Client{
		Transport: transport,
		Timeout:   30 * time.Second,
	}, nil
}

func main() {
	config := MTLSConfig{
		CertFile:   "certs/server.crt",
		KeyFile:    "certs/server.key",
		CAFile:     "certs/ca.crt",
		ServerName: "order-service.internal",
	}

	mux := http.NewServeMux()
	mux.HandleFunc("/api/v1/orders", func(w http.ResponseWriter, r *http.Request) {
		// クライアント証明書からアイデンティティ情報を抽出
		if len(r.TLS.PeerCertificates) > 0 {
			clientID := r.TLS.PeerCertificates[0].Subject.CommonName
			log.Printf("クライアントからのリクエスト: %s", clientID)
		}
		w.WriteHeader(http.StatusOK)
		w.Write([]byte(`{"status": "ok", "message": "mTLS検証成功"}`))
	})

	server, err := NewMTLSServer(config, mux)
	if err != nil {
		log.Fatalf("mTLSサーバーの作成失敗: %v", err)
	}

	log.Println("mTLSサーバーが :8443 で起動")
	if err := server.ListenAndServeTLS("", ""); err != nil {
		log.Fatalf("サーバー起動失敗: %v", err)
	}
}

パターン2：SPIFFE/SPIREアイデンティティフレームワーク

SPIFFE（Secure Production Identity Framework for Everyone）はサービスに統一アイデンティティ識別子を提供します。SPIREはSPIFFEのプロダクション実装です。

// 実行環境: Go 1.22+, github.com/spiffe/go-spiffe/v2 v2.3.0
package main

import (
	"context"
	"fmt"
	"log"
	"net/http"
	"time"

	"github.com/spiffe/go-spiffe/v2/spiffeid"
	"github.com/spiffe/go-spiffe/v2/spiffetls/tlsconfig"
	"github.com/spiffe/go-spiffe/v2/workloadapi"
)

// SPIFFEIdentity SPIFFEアイデンティティを表す
type SPIFFEIdentity struct {
	TrustDomain string
	Namespace   string
	ServiceName string
}

// String SPIFFE ID文字列を返す
func (id SPIFFEIdentity) String() string {
	return fmt.Sprintf("spiffe://%s/ns/%s/svc/%s",
		id.TrustDomain, id.Namespace, id.ServiceName)
}

// ParseSPIFFEID SPIFFE IDを解析
func ParseSPIFFEID(spiffeID string) (*SPIFFEIdentity, error) {
	id, err := spiffeid.FromString(spiffeID)
	if err != nil {
		return nil, fmt.Errorf("無効なSPIFFE ID: %w", err)
	}

	segments := id.Path()
	var identity SPIFFEIdentity
	identity.TrustDomain = id.TrustDomain().String()
	fmt.Sscanf(segments, "/ns/%s/svc/%s", &identity.Namespace, &identity.ServiceName)
	return &identity, nil
}

// NewSPIFFEServer SPIFFEアイデンティティベースのTLSサーバーを作成
func NewSPIFFEServer(ctx context.Context, socketPath string, allowedIDs []spiffeid.ID) (*http.Server, error) {
	source, err := workloadapi.NewX509Source(ctx,
		workloadapi.WithClientOptions(
			workloadapi.WithAddr(socketPath),
		),
	)
	if err != nil {
		return nil, fmt.Errorf("Workload APIへの接続失敗: %w", err)
	}

	authorizer := tlsconfig.AuthorizeAnyOf(
		func() []tlsconfig.Authorizer {
			auths := make([]tlsconfig.Authorizer, len(allowedIDs))
			for i, id := range allowedIDs {
				auths[i] = tlsconfig.AuthorizeID(id)
			}
			return auths
		}()...,
	)

	tlsConfig := tlsconfig.MTLSServerConfig(source, source, authorizer)

	mux := http.NewServeMux()
	mux.HandleFunc("/api/v1/secure-data", func(w http.ResponseWriter, r *http.Request) {
		if len(r.TLS.PeerCertificates) > 0 {
			for _, cert := range r.TLS.PeerCertificates {
				for _, uri := range cert.URIs {
					if uri.Scheme == "spiffe" {
						log.Printf("認可アクセス: SPIFFE ID=%s, パス=%s", uri.String(), r.URL.Path)
					}
				}
			}
		}
		w.WriteHeader(http.StatusOK)
		w.Write([]byte(`{"data": "機密データ", "access": "granted"}`))
	})

	return &http.Server{
		Addr:         ":8443",
		Handler:      mux,
		TLSConfig:    tlsConfig,
		ReadTimeout:  15 * time.Second,
		WriteTimeout: 15 * time.Second,
	}, nil
}

// NewSPIFFEClient SPIFFEアイデンティティベースのTLSクライアントを作成
func NewSPIFFEClient(ctx context.Context, socketPath string, serverID spiffeid.ID) (*http.Client, error) {
	source, err := workloadapi.NewX509Source(ctx,
		workloadapi.WithClientOptions(
			workloadapi.WithAddr(socketPath),
		),
	)
	if err != nil {
		return nil, fmt.Errorf("Workload APIへの接続失敗: %w", err)
	}

	tlsConfig := tlsconfig.MTLSClientConfig(source, source, tlsconfig.AuthorizeID(serverID))
	transport := &http.Transport{
		TLSClientConfig: tlsConfig,
	}

	return &http.Client{
		Transport: transport,
		Timeout:   30 * time.Second,
	}, nil
}

func main() {
	ctx := context.Background()
	socketPath := "unix:///run/spire/sockets/agent.sock"

	allowedIDs := []spiffeid.ID{
		spiffeid.Must("example.org", "/ns/production/svc/user-service"),
		spiffeid.Must("example.org", "/ns/production/svc/order-service"),
	}

	server, err := NewSPIFFEServer(ctx, socketPath, allowedIDs)
	if err != nil {
		log.Fatalf("SPIFFEサーバーの作成失敗: %v", err)
	}

	log.Println("SPIFFEアイデンティティサーバーが :8443 で起動")
	if err := server.ListenAndServeTLS("", ""); err != nil {
		log.Fatalf("サーバー起動失敗: %v", err)
	}
}

パターン3：サービスメッシュゼロトラスト

サービスメッシュでサイドカープロキシを通じてゼロトラスト通信を実現し、ビジネスコードの変更は不要です。

// 実行環境: Go 1.22+, Istio 1.22+, サービスメッシュモード
package main

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"time"
)

// ServiceMeshConfig サービスメッシュ設定
type ServiceMeshConfig struct {
	ServiceName    string
	Namespace      string
	MeshName       string
	TrustDomain    string
	PolicyEnabled  bool
}

// GeneratePeerAuthPolicy Istio PeerAuthenticationポリシーを生成（mTLS STRICTモード）
func GeneratePeerAuthPolicy(config ServiceMeshConfig) string {
	policy := map[string]interface{}{
		"apiVersion": "security.istio.io/v1beta1",
		"kind":       "PeerAuthentication",
		"metadata": map[string]interface{}{
			"name":      fmt.Sprintf("%s-mtls-strict", config.ServiceName),
			"namespace": config.Namespace,
		},
		"spec": map[string]interface{}{
			"selector": map[string]interface{}{
				"matchLabels": map[string]string{
					"app": config.ServiceName,
				},
			},
			"mtls": map[string]interface{}{
				"mode": "STRICT",
			},
		},
	}

	data, _ := json.MarshalIndent(policy, "", "  ")
	return string(data)
}

// GenerateAuthorizationPolicy Istio AuthorizationPolicyを生成
func GenerateAuthorizationPolicy(config ServiceMeshConfig, allowedServices []string) string {
	var fromRules []map[string]interface{}
	for _, svc := range allowedServices {
		fromRules = append(fromRules, map[string]interface{}{
			"source": map[string]interface{}{
				"principals": []string{
					fmt.Sprintf("cluster.local/ns/%s/sa/%s", config.Namespace, svc),
				},
			},
		})
	}

	policy := map[string]interface{}{
		"apiVersion": "security.istio.io/v1beta1",
		"kind":       "AuthorizationPolicy",
		"metadata": map[string]interface{}{
			"name":      fmt.Sprintf("%s-zero-trust", config.ServiceName),
			"namespace": config.Namespace,
		},
		"spec": map[string]interface{}{
			"selector": map[string]interface{}{
				"matchLabels": map[string]string{
					"app": config.ServiceName,
				},
			},
			"action": "ALLOW",
			"rules": []map[string]interface{}{
				{
					"from": fromRules,
					"to": []map[string]interface{}{
						{
							"operation": map[string]interface{}{
								"methods": []string{"GET", "POST"},
								"paths":   []string{"/api/v1/*"},
							},
						},
					},
					"when": []map[string]interface{}{
						{
							"key":    "request.headers[x-token-expiry]",
							"values": []string{"*"},
						},
					},
				},
			},
		},
	}

	data, _ := json.MarshalIndent(policy, "", "  ")
	return string(data)
}

// MeshService ゼロトラストアノテーション付きマイクロサービス
type MeshService struct {
	config ServiceMeshConfig
	client *http.Client
}

func NewMeshService(config ServiceMeshConfig) *MeshService {
	return &MeshService{
		config: config,
		client: &http.Client{
			Timeout: 30 * time.Second,
		},
	}
}

// CallService サービスメッシュ経由で他のサービスを呼び出し
func (s *MeshService) CallService(ctx context.Context, targetService, path string) (*http.Response, error) {
	url := fmt.Sprintf("http://%s.%s.svc.cluster.local%s",
		targetService, s.config.Namespace, path)

	req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
	if err != nil {
		return nil, fmt.Errorf("リクエスト作成失敗: %w", err)
	}

	req.Header.Set("X-Source-Service", s.config.ServiceName)
	req.Header.Set("X-Source-Namespace", s.config.Namespace)

	return s.client.Do(req)
}

func main() {
	config := ServiceMeshConfig{
		ServiceName:   "order-service",
		Namespace:     "production",
		MeshName:      "istio-mesh",
		TrustDomain:   "cluster.local",
		PolicyEnabled: true,
	}

	fmt.Println("=== PeerAuthentication (mTLS STRICT) ===")
	fmt.Println(GeneratePeerAuthPolicy(config))

	fmt.Println("\n=== AuthorizationPolicy (ゼロトラストアクセス制御) ===")
	fmt.Println(GenerateAuthorizationPolicy(config, []string{"user-service", "payment-service"}))

	service := NewMeshService(config)
	mux := http.NewServeMux()
	mux.HandleFunc("/api/v1/orders", func(w http.ResponseWriter, r *http.Request) {
		sourceService := r.Header.Get("X-Source-Service")
		log.Printf("%s からのリクエストを受信", sourceService)
		w.WriteHeader(http.StatusOK)
		json.NewEncoder(w).Encode(map[string]string{
			"status":  "ok",
			"service": config.ServiceName,
		})
	})

	log.Fatal(http.ListenAndServe(":8080", mux))
}

パターン4：継続的検証ミドルウェア

ゼロトラストでは、ネットワーク境界で一度だけ検証するのではなく、すべてのリクエストを検証する必要があります。

// 実行環境: Go 1.22+, github.com/casbin/casbin/v2 v2.103.0
package main

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"strings"
	"time"

	"github.com/casbin/casbin/v2"
	"github.com/casbin/casbin/v2/model"
	"github.com/casbin/casbin/v2/persist"
	fileadapter "github.com/casbin/casbin/v2/persist/file-adapter"
)

// Identity リクエストのアイデンティティ情報
type Identity struct {
	ServiceID   string
	TrustDomain string
	Namespace   string
	Role        string
	TokenExpiry time.Time
}

// VerificationResult 検証結果
type VerificationResult struct {
	Allowed    bool
	Identity   *Identity
	DeniedCode string
	DeniedMsg  string
}

// ContinuousVerificationMiddleware 継続的検証ミドルウェア
type ContinuousVerificationMiddleware struct {
	enforcer  *casbin.Enforcer
	jwtSecret string
	cache     *VerificationCache
}

// VerificationCache 検証結果キャッシュ（短TTL）
type VerificationCache struct {
	items map[string]*VerificationResult
	ttl   time.Duration
}

func NewVerificationCache(ttl time.Duration) *VerificationCache {
	return &VerificationCache{
		items: make(map[string]*VerificationResult),
		ttl:   ttl,
	}
}

// NewContinuousVerificationMiddleware 継続的検証ミドルウェアを作成
func NewContinuousVerificationMiddleware(modelPath, policyPath string) (*ContinuousVerificationMiddleware, error) {
	m, err := model.NewModelFromString(`
[request_definition]
r = sub, dom, obj, act

[policy_definition]
p = sub, dom, obj, act

[role_definition]
g = _, _, _

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

[matchers]
m = g(r.sub, p.sub, r.dom) && r.dom == p.dom && r.obj == p.obj && r.act == p.act
`)
	if err != nil {
		return nil, fmt.Errorf("Casbinモデルの作成失敗: %w", err)
	}

	var adapter persist.Adapter
	if policyPath != "" {
		adapter = fileadapter.NewAdapter(policyPath)
	}

	enforcer, err := casbin.NewEnforcer(m, adapter)
	if err != nil {
		return nil, fmt.Errorf("Casbinエンフォーサーの作成失敗: %w", err)
	}

	return &ContinuousVerificationMiddleware{
		enforcer: enforcer,
		cache:    NewVerificationCache(30 * time.Second),
	}, nil
}

// Verify 各リクエストを継続的に検証
func (m *ContinuousVerificationMiddleware) Verify(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		ctx := r.Context()

		// レイヤ1：アイデンティティの抽出
		identity, err := m.extractIdentity(r)
		if err != nil {
			m.denyAccess(w, "IDENTITY_MISSING", "リクエストアイデンティティを抽出できません")
			return
		}

		// レイヤ2：トークン有効期限の検証
		if time.Now().After(identity.TokenExpiry) {
			m.denyAccess(w, "TOKEN_EXPIRED", "アクセストークンが期限切れです")
			return
		}

		// レイヤ3：資格情報の失効状態チェック
		if m.isCredentialRevoked(ctx, identity.ServiceID) {
			m.denyAccess(w, "CREDENTIAL_REVOKED", "資格情報が失効しています")
			return
		}

		// レイヤ4：RBACポリシーチェック
		resource := r.URL.Path
		action := r.Method
		allowed, err := m.enforcer.Enforce(identity.ServiceID, identity.Namespace, resource, action)
		if err != nil {
			m.denyAccess(w, "POLICY_ERROR", "ポリシーチェックに失敗しました")
			return
		}
		if !allowed {
			m.denyAccess(w, "ACCESS_DENIED", "このリソースへのアクセスが拒否されました")
			return
		}

		// レイヤ5：デバイス/環境トラスト評価
		if !m.evaluateTrustLevel(r) {
			m.denyAccess(w, "LOW_TRUST", "トラストレベルが不足しています")
			return
		}

		ctx = context.WithValue(ctx, "identity", identity)
		next.ServeHTTP(w, r.WithContext(ctx))
	})
}

func (m *ContinuousVerificationMiddleware) extractIdentity(r *http.Request) (*Identity, error) {
	authHeader := r.Header.Get("Authorization")
	if authHeader == "" {
		return nil, fmt.Errorf("Authorizationヘッダーがありません")
	}

	token := strings.TrimPrefix(authHeader, "Bearer ")
	if token == authHeader {
		return nil, fmt.Errorf("無効なAuthorization形式")
	}

	identity := &Identity{
		ServiceID:   r.Header.Get("X-Service-Id"),
		TrustDomain: r.Header.Get("X-Trust-Domain"),
		Namespace:   r.Header.Get("X-Namespace"),
		Role:        r.Header.Get("X-Role"),
		TokenExpiry: time.Now().Add(1 * time.Hour),
	}

	if identity.ServiceID == "" {
		return nil, fmt.Errorf("サービスアイデンティティがありません")
	}

	return identity, nil
}

func (m *ContinuousVerificationMiddleware) isCredentialRevoked(ctx context.Context, serviceID string) bool {
	return false
}

func (m *ContinuousVerificationMiddleware) evaluateTrustLevel(r *http.Request) bool {
	return true
}

func (m *ContinuousVerificationMiddleware) denyAccess(w http.ResponseWriter, code, msg string) {
	w.WriteHeader(http.StatusForbidden)
	json.NewEncoder(w).Encode(map[string]string{
		"error":   code,
		"message": msg,
	})
}

func main() {
	middleware, err := NewContinuousVerificationMiddleware("", "policy.csv")
	if err != nil {
		log.Fatalf("検証ミドルウェアの作成失敗: %v", err)
	}

	middleware.enforcer.AddPolicy("user-service", "production", "/api/v1/users", "GET")
	middleware.enforcer.AddPolicy("order-service", "production", "/api/v1/orders", "GET")
	middleware.enforcer.AddPolicy("order-service", "production", "/api/v1/orders", "POST")

	mux := http.NewServeMux()
	mux.HandleFunc("/api/v1/orders", func(w http.ResponseWriter, r *http.Request) {
		identity, _ := r.Context().Value("identity").(*Identity)
		log.Printf("認可アクセス: service=%s, namespace=%s", identity.ServiceID, identity.Namespace)
		w.WriteHeader(http.StatusOK)
		json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
	})

	handler := middleware.Verify(mux)
	log.Fatal(http.ListenAndServe(":8080", handler))
}

パターン5：ゼロトラストAPIゲートウェイ

APIゲートウェイはゼロトラストアーキテクチャの統一エントリポイントであり、認証、認可、暗号化、監査ポリシーを一元実施します。

// 実行環境: Go 1.22+, ゼロトラストAPIゲートウェイ実装
package main

import (
	"context"
	"crypto/tls"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"net/http/httputil"
	"net/url"
	"strings"
	"sync"
	"time"
)

// ZeroTrustGateway ゼロトラストAPIゲートウェイ
type ZeroTrustGateway struct {
	routes       map[string]*RouteConfig
	rateLimiters map[string]*RateLimiter
	auditLogger  *AuditLogger
	mu           sync.RWMutex
}

// RouteConfig ルート設定
type RouteConfig struct {
	Path           string
	BackendURL     string
	RequiredScopes []string
	AllowedMethods []string
	MTLSRequired   bool
	RateLimit      int
	Timeout        time.Duration
}

// RateLimiter レート制限器
type RateLimiter struct {
	tokens     int
	maxTokens  int
	rate       time.Duration
	lastRefill time.Time
	mu         sync.Mutex
}

// AuditLogger 監査ログ記録器
type AuditLogger struct {
	entries []AuditEntry
	mu      sync.Mutex
}

// AuditEntry 監査ログエントリ
type AuditEntry struct {
	Timestamp  time.Time `json:"timestamp"`
	SourceID   string    `json:"source_id"`
	Method     string    `json:"method"`
	Path       string    `json:"path"`
	StatusCode int       `json:"status_code"`
	Duration   string    `json:"duration"`
	Decision   string    `json:"decision"`
	Reason     string    `json:"reason"`
}

func NewZeroTrustGateway() *ZeroTrustGateway {
	return &ZeroTrustGateway{
		routes:       make(map[string]*RouteConfig),
		rateLimiters: make(map[string]*RateLimiter),
		auditLogger:  &AuditLogger{},
	}
}

func (g *ZeroTrustGateway) AddRoute(config *RouteConfig) {
	g.mu.Lock()
	defer g.mu.Unlock()
	g.routes[config.Path] = config
	g.rateLimiters[config.Path] = &RateLimiter{
		tokens:     config.RateLimit,
		maxTokens:  config.RateLimit,
		rate:       time.Second,
		lastRefill: time.Now(),
	}
}

func (g *ZeroTrustGateway) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	startTime := time.Now()

	// ステップ1：TLS終端とmTLS検証
	if r.TLS == nil {
		g.auditLog(r, startTime, 403, "DENY", "非TLSリクエスト")
		http.Error(w, "TLS required", http.StatusForbidden)
		return
	}

	// ステップ2：リクエストアイデンティティの抽出
	sourceID := g.extractIdentity(r)
	if sourceID == "" {
		g.auditLog(r, startTime, 401, "DENY", "アイデンティティ不明")
		http.Error(w, "Unauthorized", http.StatusUnauthorized)
		return
	}

	// ステップ3：ルートマッチング
	g.mu.RLock()
	route, exists := g.routes[r.URL.Path]
	g.mu.RUnlock()

	if !exists {
		g.auditLog(r, startTime, 404, "DENY", "ルートが存在しません")
		http.Error(w, "Not Found", http.StatusNotFound)
		return
	}

	// ステップ4：HTTPメソッドチェック
	methodAllowed := false
	for _, m := range route.AllowedMethods {
		if m == r.Method {
			methodAllowed = true
			break
		}
	}
	if !methodAllowed {
		g.auditLog(r, startTime, 405, "DENY", "メソッドが許可されていません")
		http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
		return
	}

	// ステップ5：レート制限
	limiter := g.rateLimiters[route.Path]
	if !limiter.Allow() {
		g.auditLog(r, startTime, 429, "DENY", "レート制限超過")
		http.Error(w, "Too Many Requests", http.StatusTooManyRequests)
		return
	}

	// ステップ6：スコープチェック
	if !g.checkScopes(r, route.RequiredScopes) {
		g.auditLog(r, startTime, 403, "DENY", "権限不足")
		http.Error(w, "Forbidden", http.StatusForbidden)
		return
	}

	// ステップ7：バックエンドへのリバースプロキシ
	backendURL, _ := url.Parse(route.BackendURL)
	proxy := httputil.NewSingleHostReverseProxy(backendURL)

	originalDirector := proxy.Director
	proxy.Director = func(req *http.Request) {
		originalDirector(req)
		req.Header.Set("X-Source-Id", sourceID)
		req.Header.Set("X-Forwarded-Proto", "https")
		req.Header.Set("X-Gateway-Timestamp", time.Now().Format(time.RFC3339))
	}

	proxy.ServeHTTP(w, r)
	g.auditLog(r, startTime, 200, "ALLOW", "リクエスト通過")
}

func (g *ZeroTrustGateway) extractIdentity(r *http.Request) string {
	if r.TLS != nil && len(r.TLS.PeerCertificates) > 0 {
		return r.TLS.PeerCertificates[0].Subject.CommonName
	}
	return r.Header.Get("X-Service-Id")
}

func (g *ZeroTrustGateway) checkScopes(r *http.Request, required []string) bool {
	if len(required) == 0 {
		return true
	}
	tokenScopes := strings.Split(r.Header.Get("X-Token-Scopes"), ",")
	scopeMap := make(map[string]bool)
	for _, s := range tokenScopes {
		scopeMap[strings.TrimSpace(s)] = true
	}
	for _, req := range required {
		if !scopeMap[req] {
			return false
		}
	}
	return true
}

func (g *ZeroTrustGateway) auditLog(r *http.Request, startTime time.Time, statusCode int, decision, reason string) {
	entry := AuditEntry{
		Timestamp:  time.Now(),
		SourceID:   r.Header.Get("X-Service-Id"),
		Method:     r.Method,
		Path:       r.URL.Path,
		StatusCode: statusCode,
		Duration:   time.Since(startTime).String(),
		Decision:   decision,
		Reason:     reason,
	}
	g.auditLogger.mu.Lock()
	g.auditLogger.entries = append(g.auditLogger.entries, entry)
	g.auditLogger.mu.Unlock()

	log.Printf("[AUDIT] %s %s %s -> %d (%s) %s",
		entry.SourceID, entry.Method, entry.Path,
		entry.StatusCode, entry.Decision, entry.Reason)
}

func (rl *RateLimiter) Allow() bool {
	rl.mu.Lock()
	defer rl.mu.Unlock()

	now := time.Now()
	elapsed := now.Sub(rl.lastRefill)
	tokensToAdd := int(elapsed / rl.rate)

	if tokensToAdd > 0 {
		rl.tokens += tokensToAdd
		if rl.tokens > rl.maxTokens {
			rl.tokens = rl.maxTokens
		}
		rl.lastRefill = now
	}

	if rl.tokens > 0 {
		rl.tokens--
		return true
	}
	return false
}

func main() {
	gateway := NewZeroTrustGateway()

	gateway.AddRoute(&RouteConfig{
		Path:           "/api/v1/users",
		BackendURL:     "http://user-service:8080",
		RequiredScopes: []string{"users:read"},
		AllowedMethods: []string{"GET"},
		MTLSRequired:   true,
		RateLimit:      100,
		Timeout:        30 * time.Second,
	})

	gateway.AddRoute(&RouteConfig{
		Path:           "/api/v1/orders",
		BackendURL:     "http://order-service:8080",
		RequiredScopes: []string{"orders:read", "orders:write"},
		AllowedMethods: []string{"GET", "POST"},
		MTLSRequired:   true,
		RateLimit:      200,
		Timeout:        30 * time.Second,
	})

	tlsConfig := &tls.Config{
		MinVersion: tls.VersionTLS13,
		CurvePreferences: []tls.CurveID{
			tls.X25519,
			tls.CurveP256,
		},
	}

	server := &http.Server{
		Addr:         ":8443",
		Handler:      gateway,
		TLSConfig:    tlsConfig,
		ReadTimeout:  15 * time.Second,
		WriteTimeout: 15 * time.Second,
	}

	log.Println("ゼロトラストAPIゲートウェイが :8443 で起動")
	log.Fatal(server.ListenAndServeTLS("certs/gateway.crt", "certs/gateway.key"))
}

落とし穴ガイド：5つの本番レベルの罠

罠1：mTLS証明書ローテーションによるサービス中断。証明書の有効期限が切れた瞬間にすべてのサービス呼び出しが失敗します。解決策：cert-managerで自動ローテーション、証明書有効期間7日、ローテーション提前量24時間、グレースフルホットリロードの実装。

罠2：SPIRE Agentの利用不可によるサービス起動失敗。SPIRE AgentがクラッシュするとWorkload APIからSVIDを取得できません。解決策：ローカルSVIDキャッシュ、フォールバック戦略の実装、AgentのHAデプロイ（最低3レプリカ）。

罠3：サービスメッシュポリシーが厳しすぎて正当なトラフィックが拒否される。PeerAuthentication STRICTモードはヘルスチェックを含むすべての非mTLSトラフィックを拒否します。解決策：kube-systemネームスペースにPERMISSIVEモードを設定、ポートレベルのきめ細かい制御を使用。

罠4：継続的検証ミドルウェアのパフォーマンスボトルネック。すべてのリクエストでポリシーエンジンを照会するとP99レイテンシが急増します。解決策：短TTLローカルキャッシュ（30秒）、非同期監査ログ、ポリシーのデシジョンツリーへの事前コンパイル。

罠5：ゲートウェイの単一障害点。APIゲートウェイがダウンするとすべてのサービスに到達できなくなります。解決策：ゲートウェイのマルチレプリカデプロイ、レディネスプローブによるバックエンド接続性チェック、カスケード障害防止のサーキットブレーカーパターン。

エラートラブルシューティング早見表

エラーメッセージ	原因	解決策
tls: handshake failure	クライアントが証明書を提供していないか、証明書が無効	クライアント証明書の設定と有効期限を確認
certificate signed by unknown authority	CA証明書の不一致	クライアントとサーバーが同じCAの証明書を使用しているか確認
spiffe: workload API unavailable	SPIRE Agentが実行されていないか、ソケットパスが間違っている	SPIRE Agentの状態とソケットパスを確認
SVID not found for SPIFFE ID	サービスがSPIREに登録されていない	Registration EntryとSelectorの設定を確認
PeerAuthentication: connection refused	STRICTモードが非mTLSトラフィックを拒否	デバッグのためにPERMISSIVEモードに切り替え、その後STRICTに戻す
AuthorizationPolicy: RBAC: denied	リクエスト主体が許可リストにない	ServiceAccountとprincipalsの設定を確認
casbin: policy enforcement error	Casbinポリシーファイルのフォーマットエラー	modelとpolicyの構文を検証
rate limit exceeded	リクエスト頻度が制限を超過	RateLimit設定を調整するか、異常トラフィックを確認
context deadline exceeded	バックエンドサービスの応答タイムアウト	バックエンドサービスの健全性とネットワーク接続性を確認
x509: certificate has expired	証明書が期限切れ	cert-managerが正常に証明書をローテーションしているか確認

高度な最適化：5つの本番レベルのヒント

ヒント1：証明書のホットリロード。tls.Config.GetCertificateで証明書を動的にロードし、ファイル監視と組み合わせてダウンタイムなしの証明書ローテーションを実現。

ヒント2：SPIREフェデレーショントラスト。マルチクラスター環境で、SPIRE Federationを通じてクラスター間の信頼関係を確立し、クラスター間mTLS通信を実現。

ヒント3：アダプティブレート制限。バックエンドサービスの応答時間とエラーレートに基づいて、ゲートウェイのレート制限閾値を動的に調整。

ヒント4：ゼロトラストの観測可能性。mTLSハンドシェイクフェーズでTraceIDを注入し、アイデンティティ検証、認可決定、バックエンド呼び出しを完全なトレースチェーンとして連結。

ヒント5：ポリシー・アズ・コード。ゼロトラストポリシー（PeerAuthentication、AuthorizationPolicy）をGitリポジトリに保存し、GitOpsでクラスタに自動同期、ポリシーの監査とロールバックを実現。

比較分析

次元	従来の境界セキュリティ	ゼロトラストセキュリティ
信頼モデル	内部は信頼、外部は不信	デフォルトで決して信頼しない
認証方式	ネットワーク境界で一度だけ	リクエストごとに継続的に検証
暗号化範囲	外部トラフィックのみ	すべてのトラフィックを暗号化（mTLS）
アイデンティティ	IPアドレス	SPIFFE ID / Service Identity
認可粒度	ネットワークセグメントレベル	サービス + API + メソッドレベル
証明書管理	手動	自動発行とローテーション
横移動リスク	高い（境界突破後）	低い（各ホップで検証が必要）
観測可能性	限定的	フルチェーン監査
実装複雑度	低い	高い
適用シナリオ	従来のモノリスアプリ	クラウドネイティブマイクロサービス

まとめ

Goゼロトラストネットワークアーキテクチャの5つのコアパターンは、完全なマイクロサービスセキュリティ体系を構成します：mTLSは通信暗号化と相互認証を提供し、SPIFFE/SPIREは統一アイデンティティ体系を確立し、サービスメッシュは透過的なゼロトラスト通信を実現し、継続的検証ミドルウェアはすべてのリクエストが認可されることを保証し、ゼロトラストAPIゲートウェイはセキュリティポリシーを一元実施します。

ゼロトラストは一朝一夕には実現できません。mTLSから始め、段階的にSPIFFEアイデンティティと継続的検証を導入し、最終的に完全なゼロトラストアーキテクチャを実現することをお勧めします。覚えておいてください：ゼロトラストの本質は信頼しないことではなく、技術的手段で信頼を検証可能、監査可能、取り消し可能にすることです。

オンラインツールおすすめ

• /ja/json/format — JSONフォーマッター、mTLS証明書とSPIFFEポリシー設定の確認に
• /ja/dev/curl-to-code — cURL→コード変換、mTLSクライアント呼び出しコードの素早い生成に
• /ja/encode/hash — ハッシュ計算ツール、証明書フィンガープリントとトークン署名の検証に
• /ja/text/diff — テキスト差分ツール、ゼロトラストポリシー設定のバージョン間比較に