Kubernetes + Jenkins + GitLab 自动部署 Java 应用完整方案-优快云博客

本文链接：https://blog.youkuaiyun.com/csdn_tom_168/article/details/148479664

Kubernetes + Jenkins + GitLab 自动部署 Java 应用完整方案

本方案实现从 GitLab 代码提交 → Jenkins 自动构建 → Kubernetes 部署 Java 应用的全流程自动化，适用于企业级 DevOps 流水线。

一、系统架构设计

GitLab (代码仓库) 
  ↓ 代码提交触发
Jenkins (CI/CD 服务器) 
  ↓ 构建镜像 & 运行测试
Docker Registry (镜像仓库) 
  ↓ 存储构建的镜像
Kubernetes (容器集群) 
  ↓ 自动部署 Java 应用

二、环境准备

1. 前提条件

已部署 Kubernetes 集群（如 EKS/AKS/TKE 或自建集群）
已安装 Jenkins（物理机/VM/K8s Pod）
已配置 GitLab 代码仓库（包含 Java 项目）
已部署 Docker Registry（如 Harbor/Nexus 或 Docker Hub）

2. 关键组件安装

(1) Jenkins 安装

# 使用 Helm 安装 Jenkins（K8s 环境）
helm repo add jenkinsci https://charts.jenkins.io
helm install jenkins jenkinsci/jenkins --namespace jenkins --create-namespace

(2) Jenkins 插件安装

进入 Jenkins Web 界面 → Manage Jenkins → Manage Plugins，安装以下插件：

Kubernetes（动态构建节点）
GitLab Integration（GitLab 集成）
Docker Pipeline（Docker 构建）
Pipeline（流水线支持）
Kubernetes Continuous Deploy Plugin（K8s 部署）

(3) GitLab Webhook 配置

进入 GitLab 项目 → Settings → Webhooks。
添加 Webhook URL：http://<jenkins-server>/project/<your-job>。
触发事件选择：Push events（代码推送时触发）。

三、Jenkins 流水线配置

1. 创建 Jenkins Pipeline 项目

进入 Jenkins → New Item → 输入名称（如 java-app-deploy）→ 选择 Pipeline → 确定。
在 Pipeline 选项卡中：
- Definition：选择 Pipeline script from SCM。
- SCM：选择 Git。
- Repository URL：填写 GitLab 仓库地址（如 https://gitlab.com/your-repo/java-app.git）。
- Branch Specifier：填写分支（如 */main）。
- Script Path：填写 Jenkinsfile 路径（如 Jenkinsfile）。

2. 编写 Jenkinsfile（关键流水线脚本）

在 GitLab 仓库根目录创建 Jenkinsfile，内容如下：

pipeline {
    agent {
        kubernetes {
            yaml """
apiVersion: v1
kind: Pod
metadata:
  labels:
    app: jenkins-agent
spec:
  containers:
  - name: maven
    image: maven:3.8.6-openjdk-17
    command: ["cat"]
    tty: true
  - name: docker
    image: docker:24.0.5
    command: ["cat"]
    tty: true
    volumeMounts:
    - name: docker-sock
      mountPath: /var/run/docker.sock
  volumes:
  - name: docker-sock
    hostPath:
      path: /var/run/docker.sock
"""
        }
    }

    stages {
        stage('Checkout') {
            steps {
                git branch: '*/main', url: 'https://gitlab.com/your-repo/java-app.git'
            }
        }

        stage('Build & Test') {
            steps {
                container('maven') {
                    sh 'mvn clean package'
                }
            }
        }

        stage('Build Docker Image') {
            steps {
                container('docker') {
                    script {
                        def imageName = "your-dockerhub-username/java-app:${env.BUILD_NUMBER}"
                        sh "docker build -t ${imageName} ."
                        sh "docker push ${imageName}"
                    }
                }
            }
        }

        stage('Deploy to Kubernetes') {
            steps {
                container('docker') {
                    script {
                        def imageName = "your-dockerhub-username/java-app:${env.BUILD_NUMBER}"
                        sh """
                            kubectl set image deployment/java-app java-app=${imageName} \
                            --namespace=your-namespace
                        """
                    }
                }
            }
        }
    }

    post {
        success {
            echo 'Deployment succeeded!'
        }
        failure {
            echo 'Deployment failed!'
        }
    }
}

3. 关键配置说明

配置项	说明
动态构建节点	使用 Kubernetes Plugin 动态创建 Pod（包含 Maven 和 Docker 容器）。
代码检出	`git` 步骤从 GitLab 拉取代码。
构建与测试	使用 Maven 构建 Java 应用并运行测试。
Docker 构建与推送	使用 Docker 构建镜像并推送到 Docker Hub（或私有仓库）。
Kubernetes 部署	使用 `kubectl set image` 更新 Kubernetes Deployment 的镜像版本。

四、Kubernetes 部署配置

1. 创建 Kubernetes Deployment

在 Kubernetes 集群中创建 deployment.yaml：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: java-app
  namespace: your-namespace
spec:
  replicas: 3
  selector:
    matchLabels:
      app: java-app
  template:
    metadata:
      labels:
        app: java-app
    spec:
      containers:
      - name: java-app
        image: your-dockerhub-username/java-app:latest  # 初始镜像（会被 Jenkins 更新）
        ports:
        - containerPort: 8080
        env:
        - name: SPRING_PROFILES_ACTIVE
          value: "prod"  # 可根据环境调整

2. 创建 Kubernetes Service

apiVersion: v1
kind: Service
metadata:
  name: java-app-service
  namespace: your-namespace
spec:
  selector:
    app: java-app
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8080
  type: LoadBalancer  # 或 ClusterIP/NodePort

3. 应用配置

kubectl apply -f deployment.yaml -n your-namespace
kubectl apply -f service.yaml -n your-namespace

五、自动化触发与验证

1. 触发 Jenkins 流水线

在 GitLab 中推送代码到 main 分支，Jenkins 会自动触发流水线。
或手动点击 Jenkins 任务 → Build Now。

2. 验证部署

# 查看 Pod 状态
kubectl get pods -n your-namespace

# 查看 Deployment 版本
kubectl describe deployment java-app -n your-namespace

# 访问应用（通过 Service 的 External IP 或 NodePort）
kubectl get svc java-app-service -n your-namespace

六、常见问题与解决方案

1. Jenkins 无法连接到 Kubernetes

检查点：
- Jenkins 的 Kubernetes Plugin 配置是否正确（Kubernetes URL 和 Credentials）。
- Jenkins Master 或 Agent 是否有访问 Kubernetes 的权限（RBAC）。
解决方案：
- 测试 kubectl 是否能正常访问集群：
```
kubectl get nodes
```

2. Docker 构建失败

检查点：
- Jenkins Pod 是否挂载了 /var/run/docker.sock（动态构建节点配置）。
- Docker Hub 或私有仓库的认证是否正确（可在 Jenkins 中配置 Docker Credentials）。
解决方案：
- 检查 Jenkins 的 Docker 容器日志：
```
kubectl logs <jenkins-agent-pod-name> -n jenkins
```

3. Kubernetes 部署未更新

检查点：
- Jenkins 的 kubectl set image 命令是否正确执行。
- Kubernetes Deployment 的 imagePullPolicy 是否为 Always（确保拉取最新镜像）。

解决方案：

修改 deployment.yaml：

containers:
- name: java-app
  image: your-dockerhub-username/java-app:latest
  imagePullPolicy: Always  # 强制拉取最新镜像

重新运行 Jenkins 流水线。

七、最佳实践

使用 Helm 或 Kustomize
- 替代直接 kubectl set image，使用 Helm 或 Kustomize 管理 Kubernetes 配置。
多环境支持
- 为 dev/stage/prod 配置不同的 Kubernetes Namespace 和镜像标签。
安全最佳实践
- 使用 Jenkins Credentials 存储敏感信息（如 Docker Hub 密码、K8s Token）。
- 限制 Jenkins Agent 的资源使用（CPU/Memory）。
监控与告警
- 使用 Prometheus + Grafana 监控 Jenkins 和 Kubernetes 的运行状态。

八、总结

步骤	操作
1. 环境准备	安装 Jenkins、K8s、GitLab，配置 Webhook
2. Jenkins 配置	安装插件，创建 Pipeline 项目，编写 Jenkinsfile
3. Kubernetes 配置	创建 Deployment 和 Service
4. 自动化触发	GitLab 推送代码 → Jenkins 构建 → K8s 部署
5. 验证与优化	检查 Pod 状态，优化流水线