Jenkins+K8s实现Go后端服务自动化部署教程

go-demo/
├── main.go       # 核心业务代码
├── go.mod        # Go模块依赖
├── go.sum
└── Dockerfile    # 构建Docker镜像的配置文件

module go-demo
go 1.21  # 建议使用稳定版本，与编译环境一致
require github.com/gin-gonic/gin v1.9.1  # 以Gin框架为例，轻量Web框架

package main

import (
	"github.com/gin-gonic/gin"
	"net/http"
)

func main() {
	// 初始化Gin引擎
	r := gin.Default()
	// 健康检查接口，K8s存活探针可调用
	r.GET("/health", func(c *gin.Context) {
		c.JSON(http.StatusOK, gin.H{
			"status":  "success",
			"message": "service is healthy",
		})
	})
	// 测试接口
	r.GET("/hello", func(c *gin.Context) {
		c.JSON(http.StatusOK, gin.H{
			"msg": "hello, Jenkins+K8s Go demo!",
		})
	})
	// 监听8080端口
	_ = r.Run(":8080")
}

# 第一阶段：编译阶段，使用官方Go镜像作为基础镜像
FROM golang:1.21-alpine AS builder
# 设置工作目录
WORKDIR /app
# 复制go.mod和go.sum，先下载依赖（利用Docker层缓存，避免每次编译都重新下载）
COPY go.mod go.sum ./
RUN go mod download
# 复制所有源码到工作目录
COPY . .
# 编译Go代码：生成Linux环境的64位可执行文件，关闭CGO，减小体积
# CGO_ENABLED=0：关闭CGO，生成静态链接的可执行文件
# GOOS=linux：目标系统为Linux
# GOARCH=amd64：目标架构为amd64
RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o go-demo main.go

# 第二阶段：运行阶段，使用轻量的alpine镜像（比ubuntu小很多，约5MB）
FROM alpine:3.18
# 安装基础依赖（如时区，可选）
RUN apk add --no-cache tzdata
# 设置时区为上海
ENV TZ=Asia/Shanghai
# 创建工作目录
WORKDIR /app
# 从编译阶段复制可执行文件到当前镜像
COPY --from=builder /app/go-demo ./
# 暴露服务端口
EXPOSE 8080
# 启动服务的命令
ENTRYPOINT ["./go-demo"]

# 极致轻量版运行阶段
FROM scratch
WORKDIR /app
COPY --from=builder /app/go-demo ./
EXPOSE 8080
ENTRYPOINT ["./go-demo"]

// 声明式流水线
pipeline {
    // 执行节点：指定Jenkins的执行节点（可使用代理节点，这里使用master）
    agent any
    // 定义环境变量，方便后续修改，统一管理
    environment {
        // Git代码仓库地址
        GIT_REPO = "git@gitlab.xxx.com:dev/go-demo.git"
        // 项目名称
        PROJECT_NAME = "go-demo"
        // Harbor私有镜像仓库地址+项目名
        HARBOR_ADDR = "harbor.xxx.com/go-service"
        // 镜像标签：使用构建号作为标签，确保唯一性，也可使用Git提交ID ${GIT_COMMIT[:8]}
        IMAGE_TAG = "${BUILD_NUMBER}"
        // 完整的镜像名：仓库地址/项目名:标签
        IMAGE_NAME = "${HARBOR_ADDR}/${PROJECT_NAME}:${IMAGE_TAG}"
        // K8s命名空间：服务部署到K8s的哪个命名空间
        K8S_NAMESPACE = "dev"
        // K8s Deployment名称：与后续K8s配置文件中的名称一致
        K8S_DEPLOY_NAME = "go-demo-deploy"
    }
    // 流水线阶段定义
    stages {
        // 阶段1：拉取Go源码
        stage('Pull Code') {
            steps {
                echo "===== 开始拉取${PROJECT_NAME}源码 ====="
                // 拉取Git代码，使用SSH方式（需配置Jenkins的Git SSH密钥）
                git url: "${GIT_REPO}", branch: "main", credentialsId: "git-ssh-key"
            }
        }

        // 阶段2：编译Go代码，生成Linux可执行文件
        stage('Build Go Code') {
            steps {
                echo "===== 开始编译${PROJECT_NAME}Go代码 ====="
                // 进入项目目录，执行Go编译命令，与Dockerfile中的编译参数一致
                sh '''
                    cd ${WORKSPACE}
                    CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o go-demo main.go
                    # 验证编译结果，查看可执行文件是否存在
                    if [ -f "go-demo" ]; then
                        echo "Go代码编译成功，生成可执行文件go-demo"
                    else
                        echo "Go代码编译失败"
                        exit 1
                    fi
                '''
            }
        }

        // 阶段3：构建Docker镜像
        stage('Build Docker Image') {
            steps {
                echo "===== 开始构建Docker镜像：${IMAGE_NAME} ====="
                // 基于项目根目录的Dockerfile构建镜像
                sh "docker build -t ${IMAGE_NAME} ${WORKSPACE}"
                // 验证镜像是否构建成功
                sh "docker images | grep ${PROJECT_NAME}"
            }
        }

        // 阶段4：推送Docker镜像到Harbor
        stage('Push Docker Image') {
            steps {
                echo "===== 开始推送镜像到Harbor：${IMAGE_NAME} ====="
                // 推送镜像到Harbor
                sh "docker push ${IMAGE_NAME}"
                // 推送完成后，可选择删除本地镜像，释放磁盘空间
                sh "docker rmi ${IMAGE_NAME}"
            }
        }

        // 阶段5：更新K8s镜像，实现滚动更新
        stage('Update K8s Deployment') {
            steps {
                echo "===== 开始更新K8s ${K8S_NAMESPACE}命名空间下的${K8S_DEPLOY_NAME} ====="
                // 使用kubectl set image命令更新Deployment的镜像版本，触发滚动更新
                // go-demo-container为Deployment中定义的容器名称
                sh "kubectl set image deployment/${K8S_DEPLOY_NAME} go-demo-container=${IMAGE_NAME} -n ${K8S_NAMESPACE}"
                // 验证更新是否成功，查看Deployment的状态
                sh "kubectl rollout status deployment/${K8S_DEPLOY_NAME} -n ${K8S_NAMESPACE}"
                echo "===== ${K8S_DEPLOY_NAME}更新成功，服务已滚动上线 ====="
            }
        }
    }
    // 流水线后置操作：无论成功还是失败，都执行的步骤
    post {
        success {
            echo "===== 本次${PROJECT_NAME}服务自动化部署流水线执行成功！镜像版本：${IMAGE_TAG} ====="
        }
        failure {
            echo "===== 本次${PROJECT_NAME}服务自动化部署流水线执行失败，请检查日志！ ====="
            // 可添加失败通知：如钉钉、企业微信、邮件通知
        }
    }
}

apiVersion: apps/v1
kind: Deployment
metadata:
  name: go-demo-deploy  # 与Jenkinsfile中的K8S_DEPLOY_NAME一致
  namespace: dev        # 与Jenkinsfile中的K8S_NAMESPACE一致
  labels:
    app: go-demo
spec:
  replicas: 2  # 启动2个Pod副本，实现高可用
  selector:
    matchLabels:
      app: go-demo
  # 滚动更新策略：核心，确保更新时无停机
  strategy:
    rollingUpdate:
      maxSurge: 1        # 滚动更新时最多额外创建1个Pod
      maxUnavailable: 0  # 滚动更新时最少可用Pod数为0，确保服务不中断
    type: RollingUpdate
  template:
    metadata:
      labels:
        app: go-demo
    spec:
      containers:
      - name: go-demo-container  # 与Jenkinsfile中的容器名称一致
        image: harbor.xxx.com/go-service/go-demo:1  # 初始镜像版本，后续由Jenkins更新
        imagePullPolicy: Always  # 每次启动都拉取最新镜像
        ports:
        - containerPort: 8080    # 容器端口，与Go服务的监听端口一致
        # 存活探针：检测Pod是否存活，存活则保留，否则重启Pod
        livenessProbe:
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 5  # 容器启动5秒后开始检测
          periodSeconds: 10       # 每10秒检测一次
          timeoutSeconds: 3       # 检测超时时间3秒
        # 就绪探针：检测Pod是否就绪，就绪则加入Service的负载均衡
        readinessProbe:
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 5
          periodSeconds: 10
          timeoutSeconds: 3
        # 资源限制：限制Pod的CPU和内存使用，避免占用过多集群资源
        resources:
          limits:
            cpu: "0.5"
            memory: "512Mi"
          requests:
            cpu: "0.2"
            memory: "256Mi"

apiVersion: v1
kind: Service
metadata:
  name: go-demo-svc
  namespace: dev
  labels:
    app: go-demo
spec:
  selector:
    app: go-demo  # 与Deployment的Pod标签一致，实现服务发现
  type: NodePort  # 节点端口方式，暴露到K8s节点的端口
  ports:
  - port: 8080     # Service的集群内端口
    targetPort: 8080  # 指向Pod的容器端口
    nodePort: 30080   # 节点端口，范围30000-32767

# 创建命名空间（若未创建）
kubectl create namespace dev
# 创建Deployment
kubectl apply -f go-demo-deploy.yaml -n dev
# 创建Service
kubectl apply -f go-demo-svc.yaml -n dev
# 验证资源创建是否成功
kubectl get deploy,svc,pod -n dev