Java 应用 DevOps 全流程（CICD）闭环 - k8s版

🚀 一、目标：形成 DevOps 闭环

从代码提交到系统上线自动完成以下步骤：

  1. 代码构建（Maven/Gradle 打包 Jar 或 War）
  2. 制作镜像（Dockerfile 构建）
  3. 推送镜像（推送至镜像仓库，如 Harbor、阿里云、DockerHub）
  4. 部署容器（运行于 Docker 或 K8s）
  5. 自动触发流水线（Jenkins/GitLab CI）
  6. 自动回滚/监控/日志（闭环管理）

🏗️ 二、项目打包阶段

以 Spring Boot 工程为例，假设项目结构如下：

my-app/
 ├── src/
 ├── pom.xml
 └── Dockerfile

使用 Maven 打包

mvn clean package -DskipTests

打包后生成：

target/my-app-1.0.0.jar

🐳 三、制作 Docker 镜像

1️⃣ Dockerfile 示例

FROM openjdk:17-jdk-slim
WORKDIR /app
COPY target/my-app-1.0.0.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java","-jar","app.jar"]

2️⃣ 构建镜像

docker build -t my-app:1.0.0 .

3️⃣ 测试镜像

docker run -d -p 8080:8080 my-app:1.0.0

🏢 四、镜像仓库（推送）

例如推送到阿里云镜像仓库：

docker tag my-app:1.0.0 registry.cn-hangzhou.aliyuncs.com/myrepo/my-app:1.0.0
docker login registry.cn-hangzhou.aliyuncs.com
docker push registry.cn-hangzhou.aliyuncs.com/myrepo/my-app:1.0.0

⚙️ 五、容器部署阶段

方案 1：使用 Docker Compose

docker-compose.yml

version: '3'
services:
  my-app:
    image: registry.cn-hangzhou.aliyuncs.com/myrepo/my-app:1.0.0
    container_name: my-app
    ports:
      - "8080:8080"
    restart: always

docker-compose up -d

方案 2：使用 Kubernetes

deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 2
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: my-app
        image: registry.cn-hangzhou.aliyuncs.com/myrepo/my-app:1.0.0
        ports:
        - containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
  name: my-app-service
spec:
  type: NodePort
  selector:
    app: my-app
  ports:
  - port: 8080
    targetPort: 8080
    nodePort: 30080

部署：

kubectl apply -f deployment.yaml

🔄 六、Jenkins 流水线自动化

在 Jenkinsfile 中定义从构建到部署的自动化脚本。

Jenkinsfile 示例

pipeline {
    agent any
    environment {
        IMAGE_NAME = "registry.cn-hangzhou.aliyuncs.com/myrepo/my-app"
        VERSION = "1.0.${BUILD_NUMBER}"
    }
    stages {
        stage('Checkout') {
            steps {
                git 'https://github.com/yourname/my-app.git'
            }
        }
        stage('Build') {
            steps {
                sh 'mvn clean package -DskipTests'
            }
        }
        stage('Build Image') {
            steps {
                sh "docker build -t ${IMAGE_NAME}:${VERSION} ."
            }
        }
        stage('Push Image') {
            steps {
                withCredentials([usernamePassword(credentialsId: 'aliyun_docker', usernameVariable: 'USERNAME', passwordVariable: 'PASSWORD')]) {
                    sh "docker login -u ${USERNAME} -p ${PASSWORD} registry.cn-hangzhou.aliyuncs.com"
                    sh "docker push ${IMAGE_NAME}:${VERSION}"
                }
            }
        }
        stage('Deploy') {
            steps {
                sh "kubectl set image deployment/my-app my-app=${IMAGE_NAME}:${VERSION} -n default"
            }
        }
    }
    post {
        success {
            echo "✅ 部署成功: ${IMAGE_NAME}:${VERSION}"
        }
        failure {
            echo "❌ 部署失败，请检查日志。"
        }
    }
}

📈 七、闭环管理（监控 + 日志 + 回滚）

  1. 监控：使用 Prometheus + Grafana 监控容器状态、CPU、内存、接口响应等。

  2. 日志：用 ELK（Elasticsearch + Logstash + Kibana）收集容器日志。

  3. 回滚：K8s 版本控制可快速执行：

    kubectl rollout undo deployment/my-app

🔁 八、整体流程总结

阶段 工具 动作
构建 Maven 编译、打包 Jar
镜像 Docker 构建应用镜像
仓库 Harbor/阿里云 推送镜像
部署 Docker Compose/K8s 启动容器
自动化 Jenkins 实现持续集成与部署
闭环 Prometheus/ELK 监控、日志、回滚
posted @ 2025-11-06 16:29  槑孒  阅读(5)  评论(0)    收藏  举报