Golang生产环境实践 - 一个月后的经验总结

Golang生产环境实践 - 一个月后的经验总结 https://tdom.dev/go-in-production

但对我来说，第二点适用于所有语言。

2 回复

cosmos:

第二点

Go语言不强制规定任何项目结构，主要是因为Go被用于各种不同的场景，而不仅仅是Web应用开发。此外，Go是一门过程式语言，因此严格面向对象的项目结构在这里并不能有效工作。

在构建你的应用程序结构时，没有固定的规则或必须遵循的观点。如果你从一开始就正确地遵循Go项目结构，它就已经很好地为你实现了12要素应用的原则。

之后，就由你决定是采用MVC、MVVM，还是任何最适合你需求的结构。

关于标准化的编码规范，可以参考GitHub - golangci/golangci-lint: Fast linters Runner for Go，它提供了代码检查以及许多优秀的代码分析工具（例如用于安全性的gosec）。

学习进展很棒！享受Go编程吧。

更多关于Golang生产环境实践 - 一个月后的经验总结的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


在Golang生产环境部署一个月后，关键经验总结如下：

1. 内存管理优化

生产环境中发现goroutine泄漏问题，通过pprof监控解决：

import _ "net/http/pprof"

func main() {
    go func() {
        log.Println(http.ListenAndServe("localhost:6060", nil))
    }()
    
    // 业务代码
    for {
        select {
        case <-ctx.Done():
            return
        default:
            processTask()
        }
    }
}

2. 错误处理实践

采用结构化错误处理，避免panic传播：

func processOrder(orderID string) error {
    order, err := repo.GetOrder(orderID)
    if err != nil {
        return fmt.Errorf("获取订单失败: %w", err)
    }
    
    if err := validateOrder(order); err != nil {
        return &BusinessError{
            Code:    "INVALID_ORDER",
            Message: "订单验证失败",
            Err:     err,
        }
    }
    
    return nil
}

3. 并发控制

使用sync.Pool和worker池管理并发：

type WorkerPool struct {
    tasks chan Task
    wg    sync.WaitGroup
}

func NewWorkerPool(numWorkers int) *WorkerPool {
    pool := &WorkerPool{
        tasks: make(chan Task, 1000),
    }
    
    for i := 0; i < numWorkers; i++ {
        pool.wg.Add(1)
        go pool.worker()
    }
    
    return pool
}

func (p *WorkerPool) worker() {
    defer p.wg.Done()
    for task := range p.tasks {
        task.Process()
    }
}

4. 配置管理

使用环境变量和配置文件结合：

type Config struct {
    DBHost     string `env:"DB_HOST" yaml:"db_host"`
    DBPort     int    `env:"DB_PORT" yaml:"db_port"`
    MaxWorkers int    `env:"MAX_WORKERS" yaml:"max_workers"`
}

func LoadConfig() (*Config, error) {
    var cfg Config
    
    // 从环境变量加载
    if err := env.Parse(&cfg); err != nil {
        return nil, err
    }
    
    // 从配置文件覆盖
    if data, err := os.ReadFile("config.yaml"); err == nil {
        if err := yaml.Unmarshal(data, &cfg); err != nil {
            return nil, err
        }
    }
    
    return &cfg, nil
}

5. 监控和指标

集成Prometheus指标收集：

import "github.com/prometheus/client_golang/prometheus"

var (
    requestsTotal = prometheus.NewCounterVec(
        prometheus.CounterOpts{
            Name: "http_requests_total",
            Help: "Total HTTP requests",
        },
        []string{"method", "path", "status"},
    )
    
    requestDuration = prometheus.NewHistogramVec(
        prometheus.HistogramOpts{
            Name: "http_request_duration_seconds",
            Help: "HTTP request duration",
        },
        []string{"method", "path"},
    )
)

func init() {
    prometheus.MustRegister(requestsTotal)
    prometheus.MustRegister(requestDuration)
}

6. 优雅关闭

实现graceful shutdown：

func main() {
    ctx, stop := signal.NotifyContext(context.Background(), 
        syscall.SIGINT, syscall.SIGTERM)
    defer stop()
    
    server := &http.Server{
        Addr:    ":8080",
        Handler: router,
    }
    
    go func() {
        if err := server.ListenAndServe(); err != nil && 
           err != http.ErrServerClosed {
            log.Fatalf("服务器启动失败: %v", err)
        }
    }()
    
    <-ctx.Done()
    
    shutdownCtx, cancel := context.WithTimeout(
        context.Background(), 30*time.Second)
    defer cancel()
    
    if err := server.Shutdown(shutdownCtx); err != nil {
        log.Printf("优雅关闭失败: %v", err)
    }
}

这些实践在真实生产环境中验证有效，特别是内存管理和并发控制部分，直接关系到系统稳定性。

回到顶部