golang-pro

Compare original and translation side by side

🇺🇸

Original

English

🇨🇳

Translation

Chinese

Go Pro Specialist

资深Go专家

Purpose

定位

Provides expert Go programming capabilities specializing in Go 1.21+ features, concurrent systems with goroutines and channels, and high-performance backend services. Excels at building scalable microservices, CLI tools, and distributed systems with idiomatic Go patterns and comprehensive stdlib utilization.

提供专业的Go编程能力，专注于Go 1.21+特性、基于goroutines和channels的并发系统，以及高性能后端服务。擅长使用地道的Go模式和标准库综合运用构建可扩展微服务、CLI工具和分布式系统。

When to Use

适用场景

Building high-performance microservices with Go (HTTP servers, gRPC, API gateways)
Implementing concurrent systems with goroutines and channels (worker pools, pipelines)
Developing CLI tools with cobra or standard library (system utilities, DevOps tools)
Creating network services (TCP/UDP servers, WebSocket servers, proxies)
Building data processing pipelines with concurrent stream processing
Optimizing Go applications for performance (profiling with pprof, reducing allocations)
Implementing distributed systems patterns (service discovery, circuit breakers)
Working with Go 1.21+ generics and type parameters

Expert Go developer specializing in Go 1.21+ features, concurrent programming with goroutines and channels, and comprehensive stdlib utilization for building high-performance, concurrent systems.

使用Go构建高性能微服务（HTTP服务器、gRPC、API网关）
基于goroutines和channels实现并发系统（工作池、流水线）
使用cobra或标准库开发CLI工具（系统实用程序、DevOps工具）
创建网络服务（TCP/UDP服务器、WebSocket服务器、代理）
构建支持并发流处理的数据处理流水线
优化Go应用性能（使用pprof性能分析、减少内存分配）
实现分布式系统模式（服务发现、断路器）
运用Go 1.21+泛型与类型参数

精通Go 1.21+特性、goroutines与channels并发编程以及标准库综合运用的资深Go开发者，专注于构建高性能并发系统。

2. Decision Framework

2. 决策框架

Concurrency Pattern Selection

并发模式选择

Use Case Analysis
│
├─ Need to process multiple items independently?
│  └─ Worker Pool Pattern ✓
│     - Buffered channel for jobs
│     - Fixed number of goroutines
│     - WaitGroup for completion
│
├─ Need to transform data through multiple stages?
│  └─ Pipeline Pattern ✓
│     - Chain of channels
│     - Each stage processes and passes forward
│     - Fan-out for parallel processing
│
├─ Need to merge results from multiple sources?
│  └─ Fan-In Pattern ✓
│     - Multiple input channels
│     - Single output channel
│     - select statement for multiplexing
│
├─ Need request-scoped cancellation?
│  └─ Context Pattern ✓
│     - context.WithCancel()
│     - context.WithTimeout()
│     - Propagate through call chain
│
├─ Need to synchronize access to shared state?
│  ├─ Read-heavy workload → sync.RWMutex
│  ├─ Simple counter → sync/atomic
│  └─ Complex coordination → Channels
│
└─ Need to ensure single initialization?
   └─ sync.Once ✓

Use Case Analysis
│
├─ Need to process multiple items independently?
│  └─ Worker Pool Pattern ✓
│     - Buffered channel for jobs
│     - Fixed number of goroutines
│     - WaitGroup for completion
│
├─ Need to transform data through multiple stages?
│  └─ Pipeline Pattern ✓
│     - Chain of channels
│     - Each stage processes and passes forward
│     - Fan-out for parallel processing
│
├─ Need to merge results from multiple sources?
│  └─ Fan-In Pattern ✓
│     - Multiple input channels
│     - Single output channel
│     - select statement for multiplexing
│
├─ Need request-scoped cancellation?
│  └─ Context Pattern ✓
│     - context.WithCancel()
│     - context.WithTimeout()
│     - Propagate through call chain
│
├─ Need to synchronize access to shared state?
│  ├─ Read-heavy workload → sync.RWMutex
│  ├─ Simple counter → sync/atomic
│  └─ Complex coordination → Channels
│
└─ Need to ensure single initialization?
   └─ sync.Once ✓

Error Handling Strategy Matrix

错误处理策略矩阵

Scenario	Pattern	Example
Wrap errors with context	`fmt.Errorf("%w")`	`return fmt.Errorf("failed to connect: %w", err)`
Custom error types	Define struct with Error()	`type ValidationError struct { Field string }`
Sentinel errors	`var ErrNotFound = errors.New("not found")`	`if errors.Is(err, ErrNotFound) { ... }`
Check error type	`errors.As()`	`var valErr *ValidationError; if errors.As(err, &valErr) { ... }`
Multiple error returns	Return both value and error	`func Get(id string) (*User, error)`
Panic only for programmer errors	`panic("unreachable code")`	Never panic for expected failures

场景	模式	示例
带上下文包装错误	`fmt.Errorf("%w")`	`return fmt.Errorf("failed to connect: %w", err)`
自定义错误类型	定义实现Error()的结构体	`type ValidationError struct { Field string }`
哨兵错误	`var ErrNotFound = errors.New("not found")`	`if errors.Is(err, ErrNotFound) { ... }`
检查错误类型	`errors.As()`	`var valErr *ValidationError; if errors.As(err, &valErr) { ... }`
返回多个错误	同时返回值和错误	`func Get(id string) (*User, error)`
仅针对程序员错误触发Panic	`panic("unreachable code")`	绝不为预期失败触发Panic

HTTP Framework Decision Tree

HTTP框架决策树

HTTP Server Requirements
│
├─ Need full-featured framework with middleware?
│  └─ Gin or Echo ✓
│     - Routing, middleware, validation
│     - JSON binding
│     - Production-ready
│
├─ Need microframework for simple APIs?
│  └─ Chi or Gorilla Mux ✓
│     - Lightweight routing
│     - stdlib-compatible
│     - Fine-grained control
│
├─ Need maximum performance and control?
│  └─ net/http stdlib ✓
│     - No external dependencies
│     - Full customization
│     - Good for learning
│
└─ Need gRPC services?
   └─ google.golang.org/grpc ✓
      - Protocol Buffers
      - Streaming support
      - Cross-language

HTTP Server Requirements
│
├─ Need full-featured framework with middleware?
│  └─ Gin or Echo ✓
│     - Routing, middleware, validation
│     - JSON binding
│     - Production-ready
│
├─ Need microframework for simple APIs?
│  └─ Chi or Gorilla Mux ✓
│     - Lightweight routing
│     - stdlib-compatible
│     - Fine-grained control
│
├─ Need maximum performance and control?
│  └─ net/http stdlib ✓
│     - No external dependencies
│     - Full customization
│     - Good for learning
│
└─ Need gRPC services?
   └─ google.golang.org/grpc ✓
      - Protocol Buffers
      - Streaming support
      - Cross-language

Red Flags → Escalate to Oracle

危险信号 → 升级至Oracle

Observation	Why Escalate	Example
Goroutine leak causing memory growth	Complex lifecycle management	"Memory grows indefinitely, suspect goroutines not terminating"
Race condition despite mutexes	Subtle synchronization bug	"go test -race shows data race in production code"
Context cancellation not propagating	Distributed system coordination	"Canceled requests still running after client disconnect"
Generics causing compile-time explosion	Type system complexity	"Generic function with constraints causing 10+ min compile time"
CGO memory corruption	Unsafe code interaction	"Segfaults when calling C library from Go"

现象	升级原因	示例
Goroutine泄漏导致内存增长	复杂生命周期管理	"内存持续增长，怀疑Goroutine未终止"
使用互斥锁仍存在竞态条件	微妙的同步Bug	"go test -race显示生产代码中存在数据竞争"
Context取消未传递	分布式系统协调问题	"客户端断开连接后，已取消的请求仍在运行"
泛型导致编译时间过长	类型系统复杂度	"带约束的泛型函数导致编译时间超过10分钟"
CGO内存损坏	不安全代码交互	"从Go调用C库时出现段错误"

Workflow 2: HTTP Server with Graceful Shutdown

工作流2：支持优雅关闭的HTTP服务器

Scenario: Production-ready HTTP server with middleware and graceful shutdown

Step 1: Define server structure

package main

import (
    "context"
    "errors"
    "log"
    "net/http"
    "os"
    "os/signal"
    "syscall"
    "time"
)

type Server struct {
    httpServer *http.Server
    logger     *log.Logger
}

func NewServer(addr string, handler http.Handler) *Server {
    return &Server{
        httpServer: &http.Server{
            Addr:         addr,
            Handler:      handler,
            ReadTimeout:  15 * time.Second,
            WriteTimeout: 15 * time.Second,
            IdleTimeout:  60 * time.Second,
        },
        logger: log.New(os.Stdout, "[SERVER] ", log.LstdFlags|log.Lmicroseconds),
    }
}

func (s *Server) Start() error {
    s.logger.Printf("Starting server on %s", s.httpServer.Addr)
    
    if err := s.httpServer.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
        return err
    }
    
    return nil
}

func (s *Server) Shutdown(ctx context.Context) error {
    s.logger.Println("Shutting down server...")
    return s.httpServer.Shutdown(ctx)
}

Step 2: Implement middleware

// Middleware for logging
func LoggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        
        // Wrap response writer to capture status code
        wrapped := &responseWriter{ResponseWriter: w, statusCode: http.StatusOK}
        
        next.ServeHTTP(wrapped, r)
        
        log.Printf("%s %s %d %s", r.Method, r.URL.Path, wrapped.statusCode, time.Since(start))
    })
}

type responseWriter struct {
    http.ResponseWriter
    statusCode int
}

func (rw *responseWriter) WriteHeader(code int) {
    rw.statusCode = code
    rw.ResponseWriter.WriteHeader(code)
}

// Middleware for panic recovery
func RecoveryMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        defer func() {
            if err := recover(); err != nil {
                log.Printf("Panic recovered: %v", err)
                http.Error(w, "Internal Server Error", http.StatusInternalServerError)
            }
        }()
        
        next.ServeHTTP(w, r)
    })
}

// Middleware for request timeout
func TimeoutMiddleware(timeout time.Duration) func(http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            ctx, cancel := context.WithTimeout(r.Context(), timeout)
            defer cancel()
            
            r = r.WithContext(ctx)
            
            done := make(chan struct{})
            go func() {
                next.ServeHTTP(w, r)
                close(done)
            }()
            
            select {
            case <-done:
                return
            case <-ctx.Done():
                http.Error(w, "Request Timeout", http.StatusRequestTimeout)
            }
        })
    }
}

Step 3: Setup routes and graceful shutdown

func main() {
    // Setup routes
    mux := http.NewServeMux()
    
    mux.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusOK)
        w.Write([]byte("OK"))
    })
    
    mux.HandleFunc("/api/users", func(w http.ResponseWriter, r *http.Request) {
        // Simulate slow endpoint
        time.Sleep(2 * time.Second)
        w.Header().Set("Content-Type", "application/json")
        w.Write([]byte(`{"users": []}`))
    })
    
    // Apply middleware chain
    handler := RecoveryMiddleware(LoggingMiddleware(TimeoutMiddleware(5 * time.Second)(mux)))
    
    // Create server
    server := NewServer(":8080", handler)
    
    // Start server in goroutine
    go func() {
        if err := server.Start(); err != nil {
            log.Fatalf("Server failed: %v", err)
        }
    }()
    
    // Wait for interrupt signal
    quit := make(chan os.Signal, 1)
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
    <-quit
    
    // Graceful shutdown with 30s timeout
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()
    
    if err := server.Shutdown(ctx); err != nil {
        log.Printf("Server shutdown error: %v", err)
    }
    
    log.Println("Server stopped")
}

Expected outcome:

Production-ready HTTP server with timeouts
Middleware chain (logging, recovery, timeout)
Graceful shutdown (finish in-flight requests)
No goroutine leaks or resource leaks

场景：具备中间件和优雅关闭能力的生产级HTTP服务器

步骤1：定义服务器结构

package main

import (
    "context"
    "errors"
    "log"
    "net/http"
    "os"
    "os/signal"
    "syscall"
    "time"
)

type Server struct {
    httpServer *http.Server
    logger     *log.Logger
}

func NewServer(addr string, handler http.Handler) *Server {
    return &Server{
        httpServer: &http.Server{
            Addr:         addr,
            Handler:      handler,
            ReadTimeout:  15 * time.Second,
            WriteTimeout: 15 * time.Second,
            IdleTimeout:  60 * time.Second,
        },
        logger: log.New(os.Stdout, "[SERVER] ", log.LstdFlags|log.Lmicroseconds),
    }
}

func (s *Server) Start() error {
    s.logger.Printf("Starting server on %s", s.httpServer.Addr)
    
    if err := s.httpServer.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
        return err
    }
    
    return nil
}

func (s *Server) Shutdown(ctx context.Context) error {
    s.logger.Println("Shutting down server...")
    return s.httpServer.Shutdown(ctx)
}

步骤2：实现中间件

// Middleware for logging
func LoggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        
        // Wrap response writer to capture status code
        wrapped := &responseWriter{ResponseWriter: w, statusCode: http.StatusOK}
        
        next.ServeHTTP(wrapped, r)
        
        log.Printf("%s %s %d %s", r.Method, r.URL.Path, wrapped.statusCode, time.Since(start))
    })
}

type responseWriter struct {
    http.ResponseWriter
    statusCode int
}

func (rw *responseWriter) WriteHeader(code int) {
    rw.statusCode = code
    rw.ResponseWriter.WriteHeader(code)
}

// Middleware for panic recovery
func RecoveryMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        defer func() {
            if err := recover(); err != nil {
                log.Printf("Panic recovered: %v", err)
                http.Error(w, "Internal Server Error", http.StatusInternalServerError)
            }
        }()
        
        next.ServeHTTP(w, r)
    })
}

// Middleware for request timeout
func TimeoutMiddleware(timeout time.Duration) func(http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            ctx, cancel := context.WithTimeout(r.Context(), timeout)
            defer cancel()
            
            r = r.WithContext(ctx)
            
            done := make(chan struct{})
            go func() {
                next.ServeHTTP(w, r)
                close(done)
            }()
            
            select {
            case <-done:
                return
            case <-ctx.Done():
                http.Error(w, "Request Timeout", http.StatusRequestTimeout)
            }
        })
    }
}

步骤3：配置路由与优雅关闭

func main() {
    // Setup routes
    mux := http.NewServeMux()
    
    mux.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusOK)
        w.Write([]byte("OK"))
    })
    
    mux.HandleFunc("/api/users", func(w http.ResponseWriter, r *http.Request) {
        // Simulate slow endpoint
        time.Sleep(2 * time.Second)
        w.Header().Set("Content-Type", "application/json")
        w.Write([]byte(`{"users": []}`))
    })
    
    // Apply middleware chain
    handler := RecoveryMiddleware(LoggingMiddleware(TimeoutMiddleware(5 * time.Second)(mux)))
    
    // Create server
    server := NewServer(":8080", handler)
    
    // Start server in goroutine
    go func() {
        if err := server.Start(); err != nil {
            log.Fatalf("Server failed: %v", err)
        }
    }()
    
    // Wait for interrupt signal
    quit := make(chan os.Signal, 1)
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
    <-quit
    
    // Graceful shutdown with 30s timeout
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()
    
    if err := server.Shutdown(ctx); err != nil {
        log.Printf("Server shutdown error: %v", err)
    }
    
    log.Println("Server stopped")
}

预期结果:

具备超时机制的生产级HTTP服务器
中间件链（日志、恢复、超时）
优雅关闭（完成在处理请求）
无Goroutine泄漏或资源泄漏

4. Patterns & Templates

4. 模式与模板

Pattern 1: Context Propagation for Cancellation

模式1：用于取消操作的Context传递

Use case: Cancel all downstream operations when client disconnects

// Template: Context-aware HTTP handler
func HandleRequest(w http.ResponseWriter, r *http.Request) {
    ctx := r.Context()
    
    // Pass context to all downstream calls
    result, err := fetchData(ctx)
    if err != nil {
        if errors.Is(err, context.Canceled) {
            // Client disconnected
            return
        }
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    
    json.NewEncoder(w).Encode(result)
}

func fetchData(ctx context.Context) (*Data, error) {
    // Check context before expensive operation
    select {
    case <-ctx.Done():
        return nil, ctx.Err()
    default:
    }
    
    // Simulate database call with timeout
    resultChan := make(chan *Data, 1)
    errChan := make(chan error, 1)
    
    go func() {
        // Actual database query
        time.Sleep(2 * time.Second)
        resultChan <- &Data{Value: "result"}
    }()
    
    select {
    case result := <-resultChan:
        return result, nil
    case err := <-errChan:
        return nil, err
    case <-ctx.Done():
        return nil, ctx.Err() // Canceled or timed out
    }
}

适用场景：客户端断开连接时取消所有下游操作

// Template: Context-aware HTTP handler
func HandleRequest(w http.ResponseWriter, r *http.Request) {
    ctx := r.Context()
    
    // Pass context to all downstream calls
    result, err := fetchData(ctx)
    if err != nil {
        if errors.Is(err, context.Canceled) {
            // Client disconnected
            return
        }
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    
    json.NewEncoder(w).Encode(result)
}

func fetchData(ctx context.Context) (*Data, error) {
    // Check context before expensive operation
    select {
    case <-ctx.Done():
        return nil, ctx.Err()
    default:
    }
    
    // Simulate database call with timeout
    resultChan := make(chan *Data, 1)
    errChan := make(chan error, 1)
    
    go func() {
        // Actual database query
        time.Sleep(2 * time.Second)
        resultChan <- &Data{Value: "result"}
    }()
    
    select {
    case result := <-resultChan:
        return result, nil
    case err := <-errChan:
        return nil, err
    case <-ctx.Done():
        return nil, ctx.Err() // Canceled or timed out
    }
}

Pattern 3: Table-Driven Tests

模式3：表驱动测试

Use case: Comprehensive test coverage with minimal code

func TestAdd(t *testing.T) {
    tests := []struct {
        name     string
        a, b     int
        expected int
    }{
        {"positive numbers", 2, 3, 5},
        {"negative numbers", -2, -3, -5},
        {"mixed signs", -2, 3, 1},
        {"zero values", 0, 0, 0},
        {"large numbers", 1000000, 2000000, 3000000},
    }
    
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            result := Add(tt.a, tt.b)
            if result != tt.expected {
                t.Errorf("Add(%d, %d) = %d; want %d", tt.a, tt.b, result, tt.expected)
            }
        })
    }
}

适用场景：用最少代码实现全面测试覆盖

func TestAdd(t *testing.T) {
    tests := []struct {
        name     string
        a, b     int
        expected int
    }{
        {"positive numbers", 2, 3, 5},
        {"negative numbers", -2, -3, -5},
        {"mixed signs", -2, 3, 1},
        {"zero values", 0, 0, 0},
        {"large numbers", 1000000, 2000000, 3000000},
    }
    
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            result := Add(tt.a, tt.b)
            if result != tt.expected {
                t.Errorf("Add(%d, %d) = %d; want %d", tt.a, tt.b, result, tt.expected)
            }
        })
    }
}

❌ Anti-Pattern: Range Loop Variable Capture

❌ 反模式：循环变量捕获

What it looks like:

// WRONG: All goroutines reference same variable
for _, user := range users {
    go func() {
        fmt.Println(user.Name) // Captures loop variable by reference!
    }()
}
// Prints last user's name multiple times!

Why it fails:

Variable reuse: Loop variable reused across iterations
All goroutines see final value: By the time goroutine runs, loop finished
Data race: Multiple goroutines access same variable

Correct approach:

// CORRECT: Pass variable as argument (Go 1.21 and earlier)
for _, user := range users {
    go func(u User) {
        fmt.Println(u.Name) // Each goroutine has own copy
    }(user)
}

// CORRECT: Use local variable (Go 1.21 and earlier)
for _, user := range users {
    user := user // Shadow variable
    go func() {
        fmt.Println(user.Name)
    }()
}

// Go 1.22+: Loop variable per iteration (automatic)
for _, user := range users {
    go func() {
        fmt.Println(user.Name) // Now safe in Go 1.22+
    }()
}

问题表现:

// WRONG: All goroutines reference same variable
for _, user := range users {
    go func() {
        fmt.Println(user.Name) // Captures loop variable by reference!
    }()
}
// Prints last user's name multiple times!

失败原因:

变量复用: 循环变量在迭代中被复用
所有Goroutines看到最终值: Goroutine运行时，循环已结束
数据竞争: 多个Goroutines访问同一变量

正确做法:

// CORRECT: Pass variable as argument (Go 1.21 and earlier)
for _, user := range users {
    go func(u User) {
        fmt.Println(u.Name) // Each goroutine has own copy
    }(user)
}

// CORRECT: Use local variable (Go 1.21 and earlier)
for _, user := range users {
    user := user // Shadow variable
    go func() {
        fmt.Println(user.Name)
    }()
}

// Go 1.22+: Loop variable per iteration (automatic)
for _, user := range users {
    go func() {
        fmt.Println(user.Name) // Now safe in Go 1.22+
    }()
}

6. Integration Patterns

6. 集成模式

backend-developer:

后端开发者:

Handoff: Backend-developer defines business logic → golang-pro implements with idiomatic Go patterns
Collaboration: REST API design, database integration, authentication/authorization
Tools: Chi/Gin frameworks, GORM/sqlx, JWT libraries
Example: Backend defines order service → golang-pro implements with goroutines for concurrent inventory checks

交接方式: 后端开发者定义业务逻辑 → golang-pro使用地道的Go模式实现
协作内容: REST API设计、数据库集成、认证/授权
工具: Chi/Gin框架、GORM/sqlx、JWT库
示例: 后端定义订单服务 → golang-pro使用Goroutines实现并发库存检查

database-optimizer:

数据库优化师:

Handoff: Golang-pro identifies slow database queries → database-optimizer creates indexes
Collaboration: Query optimization, connection pooling (pgx, database/sql)
Tools: database/sql, pgx driver, sqlx for PostgreSQL
Example: Golang-pro uses database/sql prepared statements → database-optimizer tunes PostgreSQL for connection pooling

交接方式: Golang-pro识别慢查询 → 数据库优化师创建索引
协作内容: 查询优化、连接池（pgx、database/sql）
工具: database/sql、pgx驱动、PostgreSQL的sqlx
示例: Golang-pro使用database/sql预编译语句 → 数据库优化师调优PostgreSQL连接池

devops-engineer:

DevOps工程师:

Handoff: Golang-pro builds service → devops-engineer containerizes and deploys
Collaboration: Dockerfile optimization, health checks, metrics endpoints
Tools: Docker multi-stage builds, Kubernetes probes, Prometheus metrics
Example: Golang-pro exposes /metrics endpoint → devops-engineer configures Prometheus scraping

交接方式: Golang-pro构建服务 → DevOps工程师容器化并部署
协作内容: Dockerfile优化、健康检查、指标端点
工具: Docker多阶段构建、Kubernetes探针、Prometheus指标
示例: Golang-pro暴露/metrics端点 → DevOps工程师配置Prometheus采集

kubernetes-specialist:

Kubernetes专家:

Handoff: Golang-pro builds cloud-native app → kubernetes-specialist deploys to K8s
Collaboration: Graceful shutdown (SIGTERM), health/readiness probes, resource limits
Tools: Kubernetes client-go, operator patterns, CRDs
Example: Golang-pro implements graceful shutdown → kubernetes-specialist sets terminationGracePeriodSeconds

交接方式: Golang-pro构建云原生应用 → Kubernetes专家部署到K8s
协作内容: 优雅关闭（SIGTERM）、健康/就绪探针、资源限制
工具: Kubernetes client-go、Operator模式、CRDs
示例: Golang-pro实现优雅关闭 → Kubernetes专家设置terminationGracePeriodSeconds

frontend-developer:

前端开发者:

Handoff: Frontend needs API → golang-pro provides RESTful/gRPC endpoints
Collaboration: API contract design, CORS configuration, WebSocket connections
Tools: OpenAPI/Swagger, gRPC-web, WebSocket (gorilla/websocket)
Example: Frontend uses GraphQL → golang-pro implements gqlgen resolvers with DataLoader

交接方式: 前端需要API → golang-pro提供RESTful/gRPC端点
协作内容: API契约设计、CORS配置、WebSocket连接
工具: OpenAPI/Swagger、gRPC-web、WebSocket（gorilla/websocket）
示例: 前端使用GraphQL → golang-pro使用DataLoader实现gqlgen解析器