4. 网关核心组件设计：路由、中间件、认证、授权、审计日志

权限审计网关的核心价值在于将分散在各微服务中的通用横切关注点（Cross-Cutting Concerns）统一收敛到网关层。本章详细拆解网关的五大核心组件：路由、中间件、认证、授权与审计日志，并给出基于 Go 语言的具体实现方案。

4.1 组件全景与职责边界

五个组件在请求生命周期中按固定顺序执行，形成一条完整的处理链。下表明确了每个组件的核心职责与产出物：

4.2 路由组件：动态匹配与负载均衡

路由是网关的入口。我们采用 前缀树（Trie） 作为路由匹配核心，支持路径参数（:id）和通配符（*）。路由表从配置中心动态加载，支持热更新。

// Route 定义路由规则
type Route struct {
    ID          string            `json:"id"`
    Method      string            `json:"method"`
    Path        string            `json:"path"`        // 如 /api/v1/users/:id
    Upstream    string            `json:"upstream"`    // 如 http://user-svc:8080
    Weight      int               `json:"weight"`      // 负载均衡权重
    Middlewares []string          `json:"middlewares"` // 中间件名称列表
    AuthEnabled bool              `json:"auth_enabled"`
    Metadata    map[string]string `json:"metadata"`
}

// Router 接口定义
type Router interface {
    Match(method, path string) (*Route, map[string]string, error)
    UpdateRoutes(routes []Route) error
}

4.3 中间件链：洋葱模型与上下文传递

中间件采用经典的 洋葱模型（Onion Model），请求从外层向内层传递，响应从内层向外层返回。每个中间件可以读取、修改请求上下文，或直接中断链路。

// Handler 网关处理函数签名
type Handler func(ctx *Context) error

// Middleware 中间件定义
type Middleware func(next Handler) Handler

// Context 请求上下文，贯穿整个链路
type Context struct {
    Request    *http.Request
    Response   http.ResponseWriter
    Route      *Route
    UserClaims *Claims       // 认证后注入
    Authz      *AuthzResult  // 授权后注入
    Audit      *AuditRecord  // 审计数据
    Vars       map[string]string // 路径参数
    Errors     []error
}

// Chain 构建中间件链
func Chain(middlewares ...Middleware) Middleware {
    return func(next Handler) Handler {
        for i := len(middlewares) - 1; i >= 0; i-- {
            next = middlewares[i](next)
        }
        return next
    }
}

4.4 认证组件：JWT 无状态认证

我们选择 JWT（JSON Web Token） 作为主要认证方案，支持 RS256 非对称签名。网关只验证 Token 合法性，不维护 Session 状态，天然适合水平扩展。

// Claims JWT 载荷结构
type Claims struct {
    Subject  string   `json:"sub"`
    Issuer   string   `json:"iss"`
    Expiry   int64    `json:"exp"`
    Roles    []string `json:"roles"`
    TenantID string   `json:"tenant_id,omitempty"`
    jwt.RegisteredClaims
}

// Authenticate 认证中间件
func Authenticate(publicKey *rsa.PublicKey) Middleware {
    return func(next Handler) Handler {
        return func(ctx *Context) error {
            tokenStr := extractToken(ctx.Request)
            if tokenStr == "" {
                return ctx.Abort(401, "missing authorization token")
            }
            claims := &Claims{}
            token, err := jwt.ParseWithClaims(tokenStr, claims, func(t *jwt.Token) (interface{}, error) {
                return publicKey, nil
            })
            if err != nil || !token.Valid {
                return ctx.Abort(401, "invalid or expired token")
            }
            ctx.UserClaims = claims
            return next(ctx)
        }
    }
}

4.5 授权组件：RBAC 与策略引擎

授权采用 基于角色的访问控制（RBAC） 模型，结合策略引擎支持细粒度权限判断。网关从 JWT 中提取角色，与路由配置的权限要求进行匹配。

// AuthzPolicy 授权策略
type AuthzPolicy struct {
    RouteID string   `json:"route_id"`
    Method  string   `json:"method"`
    Path    string   `json:"path"`
    Roles   []string `json:"roles"`   // 允许访问的角色
    Effect  string   `json:"effect"`  // "allow" 或 "deny"
}

// Authorize 授权中间件
func Authorize(policies []AuthzPolicy) Middleware {
    return func(next Handler) Handler {
        return func(ctx *Context) error {
            if ctx.UserClaims == nil {
                return ctx.Abort(401, "authentication required")
            }
            policy := matchPolicy(policies, ctx.Route.ID, ctx.Request.Method)
            if policy == nil {
                return next(ctx) // 无策略默认放行
            }
            if !hasRole(ctx.UserClaims.Roles, policy.Roles) {
                return ctx.Abort(403, "insufficient permissions")
            }
            ctx.Authz = &AuthzResult{Allowed: true, Policy: policy}
            return next(ctx)
        }
    }
}

4.6 审计日志组件：结构化记录与异步写入

审计日志是安全合规的基石。我们记录每个请求的关键元数据，采用 异步批量写入 策略，避免阻塞网关主流程。日志输出到标准输出（stdout）和可配置的远端存储（如 Elasticsearch、S3）。

// AuditRecord 审计日志结构
type AuditRecord struct {
    Timestamp   time.Time `json:"timestamp"`
    RequestID   string    `json:"request_id"`
    Method      string    `json:"method"`
    Path        string    `json:"path"`
    StatusCode  int       `json:"status_code"`
    Latency     int64     `json:"latency_ms"`
    UserID      string    `json:"user_id,omitempty"`
    TenantID    string    `json:"tenant_id,omitempty"`
    Roles       []string  `json:"roles,omitempty"`
    AuthzResult string    `json:"authz_result"` // "allow" / "deny"
    ClientIP    string    `json:"client_ip"`
    UserAgent   string    `json:"user_agent"`
    Error       string    `json:"error,omitempty"`
}

// AuditMiddleware 审计日志中间件（最外层）
func AuditMiddleware(logger *AuditLogger) Middleware {
    return func(next Handler) Handler {
        return func(ctx *Context) error {
            start := time.Now()
            err := next(ctx)
            latency := time.Since(start).Milliseconds()

            record := &AuditRecord{
                Timestamp:  start,
                RequestID:  ctx.Request.Header.Get("X-Request-ID"),
                Method:     ctx.Request.Method,
                Path:       ctx.Request.URL.Path,
                StatusCode: ctx.Response.StatusCode(),
                Latency:    latency,
                ClientIP:   extractClientIP(ctx.Request),
                UserAgent:  ctx.Request.UserAgent(),
            }
            if ctx.UserClaims != nil {
                record.UserID = ctx.UserClaims.Subject
                record.TenantID = ctx.UserClaims.TenantID
                record.Roles = ctx.UserClaims.Roles
            }
            if ctx.Authz != nil {
                record.AuthzResult = "allow"
            } else if err != nil {
                record.AuthzResult = "deny"
                record.Error = err.Error()
            }
            logger.AsyncWrite(record) // 异步写入
            return err
        }
    }
}

4.7 组件集成与启动示例

最后，将五个组件组装到网关主流程中。以下代码展示了如何构建中间件链并启动 HTTP 服务：

func main() {
    // 1. 初始化路由表
    router := NewTrieRouter()
    router.UpdateRoutes(loadRoutesFromConfig())

    // 2. 加载 RSA 公钥用于 JWT 验证
    publicKey := loadPublicKey("keys/public.pem")

    // 3. 加载授权策略
    policies := loadPoliciesFromConfig()

    // 4. 初始化审计日志器（异步写入）
    auditLogger := NewAuditLogger(os.Stdout, 1000) // 缓冲区 1000 条

    // 5. 构建中间件链（注意顺序：审计 → 认证 → 授权）
    handler := Chain(
        AuditMiddleware(auditLogger),   // 最外层
        Authenticate(publicKey),        // 认证
        Authorize(policies),            // 授权
    )(func(ctx *Context) error {
        // 最终处理：转发到后端服务
        return proxyToUpstream(ctx)
    })

    // 6. 启动 HTTP 网关
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        route, vars, err := router.Match(r.Method, r.URL.Path)
        if err != nil {
            w.WriteHeader(http.StatusNotFound)
            return
        }
        ctx := &Context{
            Request:  r,
            Response: w,
            Route:    route,
            Vars:     vars,
        }
        if err := handler(ctx); err != nil {
            // 统一错误处理
            http.Error(w, err.Error(), ctx.Response.StatusCode())
        }
    })
    log.Fatal(http.ListenAndServe(":8080", nil))
}