Gin Docker部署Gin应用

Docker 是 Gin 应用部署的标准方式，提供一致的运行环境和便捷的部署流程。

Dockerfile 基础

单阶段构建

# Dockerfile
FROM golang:1.21-alpine

WORKDIR /app

# 安装依赖
RUN apk add --no-cache git

# 复制源码
COPY . .

# 下载依赖
RUN go mod download

# 构建
RUN go build -o gin-api .

# 暴露端口
EXPOSE 8080

# 运行
CMD ["./gin-api"]

多阶段构建（推荐）

# Dockerfile
# 第一阶段：构建
FROM golang:1.21-alpine AS builder

WORKDIR /build

# 安装构建依赖
RUN apk add --no-cache git

# 复制依赖文件
COPY go.mod go.sum ./
RUN go mod download

# 复制源码
COPY . .

# 构建（静态链接）
RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-s -w" -o gin-api .

# 第二阶段：运行
FROM alpine:3.19

WORKDIR /app

# 安装运行依赖
RUN apk add --no-cache ca-certificates tzdata

# 从构建阶段复制二进制文件
COPY --from=builder /build/gin-api .

# 复制配置文件
COPY --from=builder /build/config ./config

# 设置时区
ENV TZ=Asia/Shanghai

# 非root用户
RUN adduser -D -g '' appuser
USER appuser

# 暴露端口
EXPOSE 8080

# 健康检查
HEALTHCHECK --interval=30s --timeout=3s \
    CMD wget -q --spider http://localhost:8080/api/health || exit 1

# 运行
CMD ["./gin-api"]

Docker Compose

基础配置

# docker-compose.yml
version: '3.8'

services:
  api:
    build: .
    container_name: gin-api
    ports:
      - "8080:8080"
    environment:
      - APP_ENV=production
      - DB_HOST=db
      - DB_PORT=3306
      - DB_USER=gin_user
      - DB_PASSWORD=${DB_PASSWORD}
      - DB_NAME=gin_db
      - REDIS_HOST=redis
      - REDIS_PORT=6379
      - REDIS_PASSWORD=${REDIS_PASSWORD}
    depends_on:
      - db
      - redis
    networks:
      - app-network
    restart: unless-stopped

  db:
    image: mysql:8
    container_name: gin-db
    environment:
      - MYSQL_ROOT_PASSWORD=${DB_PASSWORD}
      - MYSQL_DATABASE=gin_db
      - MYSQL_USER=gin_user
      - MYSQL_PASSWORD=${DB_PASSWORD}
    volumes:
      - db-data:/var/lib/mysql
    networks:
      - app-network

  redis:
    image: redis:7-alpine
    container_name: gin-redis
    command: redis-server --requirepass ${REDIS_PASSWORD}
    volumes:
      - redis-data:/data
    networks:
      - app-network

networks:
  app-network:
    driver: bridge

volumes:
  db-data:
  redis-data:

环境变量文件

# .env
APP_ENV=production
DB_PASSWORD=secure_password_here
REDIS_PASSWORD=redis_password_here

Dockerfile 优化

构建缓存优化

# 利用构建缓存，先复制依赖文件
FROM golang:1.21-alpine AS builder

WORKDIR /build

# 先复制 go.mod 和 go.sum
COPY go.mod go.sum ./
RUN go mod download

# 再复制源码（源码变更不影响依赖下载缓存）
COPY . .
RUN CGO_ENABLED=0 go build -o gin-api .

镜像大小优化

# 使用 alpine 基础镜像
FROM alpine:3.19

# 只复制必要文件
COPY --from=builder /build/gin-api /app/
COPY config/*.yaml /app/config/

# 清理缓存
RUN rm -rf /var/cache/apk/*

# 最终镜像大小约 20MB

构建参数

# Dockerfile
ARG APP_VERSION=1.0.0
ARG GO_VERSION=1.21

FROM golang:${GO_VERSION}-alpine AS builder

ARG APP_VERSION
RUN go build -ldflags="-X main.version=${APP_VERSION}" -o gin-api .

# 构建时指定版本
docker build --build-arg APP_VERSION=2.0.0 -t gin-api:2.0.0 .

生产环境配置

健康检查

HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
    CMD wget -q --spider http://localhost:8080/api/health || exit 1

// 健康检查接口
func HealthHandler(c *gin.Context) {
    c.JSON(200, gin.H{
        "status": "healthy",
        "time":   time.Now().Format(time.RFC3339),
    })
}

func main() {
    r := gin.Default()
    r.GET("/api/health", HealthHandler)
    r.Run(":8080")
}

资源限制

# docker-compose.yml
services:
  api:
    build: .
    deploy:
      resources:
        limits:
          cpus: '1.0'
          memory: 512M
        reservations:
          cpus: '0.5'
          memory: 256M

日志配置

services:
  api:
    logging:
      driver: json-file
      options:
        max-size: "10m"
        max-file: "3"

Kubernetes 部署

Deployment 配置

# k8s-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: gin-api
spec:
  replicas: 3
  selector:
    matchLabels:
      app: gin-api
  template:
    metadata:
      labels:
        app: gin-api
    spec:
      containers:
      - name: gin-api
        image: gin-api:latest
        ports:
        - containerPort: 8080
        env:
        - name: APP_ENV
          value: production
        - name: DB_PASSWORD
          valueFrom:
            secretKeyRef:
              name: gin-secrets
              key: db-password
        resources:
          limits:
            memory: "512Mi"
            cpu: "1"
        livenessProbe:
          httpGet:
            path: /api/health
            port: 8080
          initialDelaySeconds: 10
          periodSeconds: 30
        readinessProbe:
          httpGet:
            path: /api/health
            port: 8080
          initialDelaySeconds: 5
          periodSeconds: 10

Service 配置

# k8s-service.yaml
apiVersion: v1
kind: Service
metadata:
  name: gin-api-service
spec:
  selector:
    app: gin-api
  ports:
  - port: 80
    targetPort: 8080
  type: LoadBalancer

Docker 常用命令

# 构建镜像
docker build -t gin-api:latest .

# 运行容器
docker run -d -p 8080:8080 --name gin-api gin-api:latest

# 查看日志
docker logs gin-api -f

# 进入容器
docker exec -it gin-api sh

# Compose 启动
docker-compose up -d

# Compose 停止
docker-compose down

# Compose 重建
docker-compose up -d --build

# 推送镜像
docker tag gin-api:latest registry.example.com/gin-api:latest
docker push registry.example.com/gin-api:latest

Dockerfile 最佳实践

注意：生产环境必须配置健康检查和资源限制。

要点总结

1. 多阶段构建：减小镜像大小，分离构建和运行环境
2. Docker Compose：一键部署完整应用栈
3. 健康检查：配置 HEALTHCHECK 和健康接口
4. 资源限制：设置 CPU 和内存限制
5. 环境变量：敏感信息使用环境变量或 Secret
6. 镜像优化：使用 alpine、静态编译、清理缓存