Golang应用在Kubernetes中滚动升级示例

main.go

package main

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

const appVersion = "v1.0.0" // 应用版本号，升级时会改为v1.0.1

// handler 处理普通请求
func handler(w http.ResponseWriter, r *http.Request) {
    log.Printf("Received request from %s on path %s. Version: %s", r.RemoteAddr, r.URL.Path, appVersion)
    time.Sleep(1 * time.Second) // 模拟一些工作负载
    fmt.Fprintf(w, "Hello from Golang App! Version: %s\n", appVersion)
}

// healthzHandler 用于健康检查
func healthzHandler(w http.ResponseWriter, r *http.Request) {
    w.WriteHeader(http.StatusOK)
    fmt.Fprintf(w, "OK\n")
}

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/", handler)
    mux.HandleFunc("/healthz", healthzHandler) // 暴露健康检查接口

    port := os.Getenv("PORT")
    if port == "" {
        port = "8080"
    }

    server := &http.Server{
        Addr:    ":" + port,
        Handler: mux,
    }

    // 创建一个通道，用于监听操作系统信号
    quit := make(chan os.Signal, 1)
    // 监听 SIGINT (Ctrl+C) 和 SIGTERM (Kubernetes发送的终止信号)
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)

    // 在一个goroutine中启动HTTP服务器
    go func() {
        log.Printf("Starting server version %s on :%s", appVersion, port)
        if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
            log.Fatalf("Server failed to start: %v", err)
        }
    }()

    // 阻塞主goroutine，直到接收到退出信号
    <-quit
    log.Println("Shutting down server...")

    // 创建一个带超时的上下文，用于控制服务器优雅停机的时间
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) // 10秒超时
    defer cancel()

    // 优雅停机
    if err := server.Shutdown(ctx); err != nil {
        log.Fatalf("Server shutdown failed: %v", err)
    }

    log.Println("Server gracefully stopped.")
}

Dockerfile

# 使用多阶段构建，减小最终镜像大小
FROM golang:1.22-alpine AS builder

WORKDIR /app

COPY go.mod go.sum ./
RUN go mod download # 下载依赖

COPY . .

# 编译Go应用，禁用CGO，交叉编译为Linux可执行文件
RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o main .

# 第二阶段：构建最终的运行镜像
FROM alpine:latest

WORKDIR /root/

# 从构建阶段复制编译好的可执行文件
COPY --from=builder /app/main .

EXPOSE 8080 # 暴露应用端口

CMD ["./main"] # 启动应用

go-app.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: go-app-deployment
  labels:
    app: go-app
spec:
  replicas: 3 # 期望的Pod副本数量
  selector:
    matchLabels:
      app: go-app
  strategy:
    type: RollingUpdate # 声明使用滚动更新策略
    rollingUpdate:
      maxSurge: 25% # 允许在升级过程中，新Pod的数量可以比期望多25% (1个)
      maxUnavailable: 1 # 允许在升级过程中，最多有1个Pod不可用
  template:
    metadata:
      labels:
        app: go-app
    spec:
      containers:
      - name: go-app
        image: your-docker-repo/go-app:v1.0.0 # 替换为你的Docker镜像地址
        ports:
        - containerPort: 8080
        # Readiness Probe: 决定Pod是否准备好接收流量
        readinessProbe:
          httpGet:
            path: /healthz
            port: 8080
          initialDelaySeconds: 5 # 容器启动后等待5秒开始探测
          periodSeconds: 5     # 每5秒探测一次
          failureThreshold: 3  # 连续3次失败则认为不就绪
        # Liveness Probe: 决定Pod是否存活，如果失败则重启Pod
        livenessProbe:
          httpGet:
            path: /healthz
            port: 8080
          initialDelaySeconds: 15 # 容器启动后等待15秒开始探测
          periodSeconds: 10     # 每10秒探测一次
          failureThreshold: 3   # 连续3次失败则认为不健康
        env:
        - name: PORT
          value: "8080"
      # terminationGracePeriodSeconds: 30 # 默认是30秒，显式指定以增强可读性。
                                        # 告诉K8s在强制终止Pod之前，给应用多少时间来优雅停机。
---
apiVersion: v1
kind: Service
metadata:
  name: go-app-service
  labels:
    app: go-app
spec:
  selector:
    app: go-app
  ports:
    - protocol: TCP
      port: 80 # Service暴露的端口
      targetPort: 8080 # Pod内部容器监听的端口
  type: LoadBalancer # 或者 ClusterIP，根据需求选择

RollingUpdate

kubectl get pods -w

kubectl describe deployment go-app-deployment

maxSurge

maxUnavailable