从零到一：用 OpenAI Codex CLI 实战开发一个微服务网关

npm install -g @openai/codex

codex --version

brew install --cask codex

codex login

mkdir gateway && cd gateway
go mod init github.com/yourname/gateway

codex

请阅读当前项目，告诉我这是一个什么项目，目录结构如何，以及还缺少什么。

请实现一个 HTTP 网关的核心路由转发功能。要求：
1. 使用 Gin 框架
2. 从配置文件读取路由规则（格式：路径前缀 -> 后端服务地址）
3. 支持路径通配符，如 /api/v1/* -> http://user-service:8080
4. 转发时保留原始请求的 Header 和 Body
5. 后端返回的响应原样返回给客户端
6. 超时时间设为 30 秒

// main.go
package main

import (
    "bytes"
    "io"
    "net/http"
    "net/http/httputil"
    "net/url"
    "time"
    "github.com/gin-gonic/gin"
    "gopkg.in/yaml.v3"
    "os"
)

type RouteConfig struct {
    Routes []Route `yaml:"routes"`
}

type Route struct {
    Prefix string `yaml:"prefix"`
    Target string `yaml:"target"`
}

var routes map[string]*httputil.ReverseProxy

func loadConfig(path string) (*RouteConfig, error) {
    data, err := os.ReadFile(path)
    if err != nil {
        return nil, err
    }
    var config RouteConfig
    if err := yaml.Unmarshal(data, &config); err != nil {
        return nil, err
    }
    return &config, nil
}

func initProxies(config *RouteConfig) {
    routes = make(map[string]*httputil.ReverseProxy)
    for _, route := range config.Routes {
        targetURL, _ := url.Parse(route.Target)
        proxy := httputil.NewSingleHostReverseProxy(targetURL)
        proxy.Transport = &http.Transport{
            MaxIdleConns:        100,
            IdleConnTimeout:     90 * time.Second,
            TLSHandshakeTimeout: 10 * time.Second,
        }
        routes[route.Prefix] = proxy
    }
}

func main() {
    r := gin.Default()
    
    config, err := loadConfig("config.yaml")
    if err != nil {
        panic(err)
    }
    initProxies(config)
    
    // 路由转发中间件
    r.Any("/*path", func(c *gin.Context) {
        path := c.Request.URL.Path
        for prefix, proxy := range routes {
            if len(path) >= len(prefix) && path[:len(prefix)] == prefix {
                proxy.ServeHTTP(c.Writer, c.Request)
                return
            }
        }
        c.JSON(http.StatusNotFound, gin.H{"error": "no route matched"})
    })
    
    r.Run(":8080")
}

routes:
  - prefix: /api/users
    target: http://user-service:8080
  - prefix: /api/orders
    target: http://order-service:8080
  - prefix: /api/payments
    target: http://payment-service:8080

请运行 go build，如果有编译错误请自动修复。

在现有网关基础上增加限流功能。要求：
1. 基于令牌桶算法，每个路由独立限流
2. 限流配置写在 config.yaml 中，格式：每个路由的 QPS 上限
3. 被限流的请求返回 429 Too Many Requests
4. 使用 Redis 做分布式限流（假设 Redis 地址为 localhost:6379）
5. 限流逻辑作为 Gin 中间件，在路由转发之前执行

// ratelimit.go
package main

import (
    "context"
    "fmt"
    "time"
    "github.com/gin-gonic/gin"
    "github.com/redis/go-redis/v9"
)

type RateLimitConfig struct {
    Limits map[string]int `yaml:"limits"`
}

var rdb *redis.Client

func initRedis() {
    rdb = redis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })
}

func RateLimitMiddleware(limits map[string]int) gin.HandlerFunc {
    return func(c *gin.Context) {
        path := c.Request.URL.Path
        for prefix, qps := range limits {
            if len(path) >= len(prefix) && path[:len(prefix)] == prefix {
                key := fmt.Sprintf("ratelimit:%s", prefix)
                ctx := context.Background()
                
                // 令牌桶算法：使用 Redis 的 INCR + 过期时间
                count, err := rdb.Incr(ctx, key).Result()
                if err != nil {
                    c.JSON(500, gin.H{"error": "rate limit error"})
                    c.Abort()
                    return
                }
                if count == 1 {
                    rdb.Expire(ctx, key, time.Second)
                }
                if int(count) > qps {
                    c.JSON(429, gin.H{"error": "too many requests"})
                    c.Abort()
                    return
                }
                c.Next()
                return
            }
        }
        c.Next()
    }
}

在网关中增加健康检查功能。要求：
1. 每个后端服务定期（每 10 秒）做一次健康探测（GET /health）
2. 连续失败 3 次的服务标记为不健康，不再转发请求
3. 连续成功 3 次后恢复
4. 提供一个管理接口 GET /admin/health 查看所有服务状态

请参考项目现有代码风格，为核心的路由转发和限流功能生成单元测试。要求：
1. 使用 Go 标准 testing 包
2. 覆盖正常转发、路由未匹配、限流触发等场景
3. 测试可独立运行，不依赖外部 Redis（使用 mock）

codex review main.go

请审查当前 diff，找出可能导致并发问题或资源泄漏的代码。

请执行以下验证步骤：
1. go test ./... 确保所有测试通过
2. go build -o gateway 编译生产二进制
3. 启动服务，用 curl 测试路由转发和限流是否正常工作

# 在 CI 中自动代码审查
codex exec "请审查本次 PR 的代码变更，重点关注安全漏洞和性能问题" --no-interactive

# 自动生成测试
codex exec "请为 src/ 目录下所有新增的函数生成单元测试" --no-interactive

- name: AI Code Review
  run: |
    npm install -g @openai/codex
    codex login --api-key ${{ secrets.OPENAI_API_KEY }}
    codex exec "请审查本次 PR 的代码，输出审查报告" --no-interactive

codex
请阅读 @main.go @config.yaml 解释请求流转的完整路径

/status