Jenkins自动化构建与CI/CD流水线实战

本文详解Jenkins的安装配置、Pipeline编写、自动化构建部署的完整实践。

前言

持续集成/持续部署（CI/CD）是现代软件开发的标配：

• 自动化构建：代码提交后自动编译打包
• 自动化测试：每次构建自动运行测试
• 自动化部署：测试通过后自动发布

Jenkins是最流行的开源CI/CD工具：

• 插件生态丰富（1800+插件）
• 支持各种语言和框架
• Pipeline as Code

今天来搭建一套完整的Jenkins CI/CD环境。

---

一、Jenkins部署

1.1 Docker部署（推荐）

# docker-compose.yml
version: '3.8'

services:
  jenkins:
    image: jenkins/jenkins:lts
    container_name: jenkins
    privileged: true
    user: root
    ports:
      - "8080:8080"
      - "50000:50000"
    volumes:
      - ./jenkins_home:/var/jenkins_home
      - /var/run/docker.sock:/var/run/docker.sock
      - /usr/bin/docker:/usr/bin/docker
    environment:
      - TZ=Asia/Shanghai
    restart: unless-stopped

# 创建目录并启动
mkdir jenkins_home
docker compose up -d

# 获取初始密码
docker exec jenkins cat /var/jenkins_home/secrets/initialAdminPassword

1.2 初始化配置

1. 访问 http://服务器IP:8080
2. 输入初始密码
3. 安装推荐插件（或自定义选择）
4. 创建管理员账号
5. 配置Jenkins URL

1.3 必装插件

插件	用途
Pipeline	流水线支持
Git	Git集成
Docker Pipeline	Docker构建支持
Blue Ocean	现代化UI
Credentials Binding	凭证管理
SSH Agent	SSH部署

安装路径：
Manage Jenkins → Plugins → Available plugins

---

二、第一个Pipeline

2.1 创建Pipeline项目

1. Dashboard → New Item
2. 输入名称，选择"Pipeline"
3. 点击OK

2.2 Hello World Pipeline

pipeline {
    agent any
    
    stages {
        stage('Hello') {
            steps {
                echo 'Hello, Jenkins Pipeline!'
            }
        }
        
        stage('Build') {
            steps {
                echo 'Building...'
                sh 'echo "Build number: ${BUILD_NUMBER}"'
            }
        }
        
        stage('Test') {
            steps {
                echo 'Testing...'
            }
        }
        
        stage('Deploy') {
            steps {
                echo 'Deploying...'
            }
        }
    }
    
    post {
        always {
            echo 'Pipeline finished!'
        }
        success {
            echo 'Success!'
        }
        failure {
            echo 'Failed!'
        }
    }
}

2.3 运行Pipeline

1. 点击"Build Now"
2. 查看"Console Output"
3. 或使用Blue Ocean查看可视化流程

---

三、实战：Java项目CI/CD

3.1 项目结构

my-project/
├── src/
├── pom.xml
├── Dockerfile
└── Jenkinsfile

3.2 Jenkinsfile

pipeline {
    agent any
    
    environment {
        DOCKER_REGISTRY = 'registry.example.com'
        IMAGE_NAME = 'my-app'
        DEPLOY_SERVER = '192.168.1.100'
    }
    
    tools {
        maven 'Maven-3.8'
        jdk 'JDK-11'
    }
    
    stages {
        stage('Checkout') {
            steps {
                checkout scm
                echo "Branch: ${env.BRANCH_NAME}"
                echo "Commit: ${env.GIT_COMMIT}"
            }
        }
        
        stage('Build') {
            steps {
                sh 'mvn clean compile -DskipTests'
            }
        }
        
        stage('Test') {
            steps {
                sh 'mvn test'
            }
            post {
                always {
                    junit '**/target/surefire-reports/*.xml'
                }
            }
        }
        
        stage('Package') {
            steps {
                sh 'mvn package -DskipTests'
                archiveArtifacts artifacts: 'target/*.jar', fingerprint: true
            }
        }
        
        stage('Docker Build') {
            steps {
                script {
                    def imageTag = "${DOCKER_REGISTRY}/${IMAGE_NAME}:${BUILD_NUMBER}"
                    sh "docker build -t ${imageTag} ."
                    sh "docker push ${imageTag}"
                }
            }
        }
        
        stage('Deploy') {
            when {
                branch 'main'
            }
            steps {
                script {
                    def imageTag = "${DOCKER_REGISTRY}/${IMAGE_NAME}:${BUILD_NUMBER}"
                    sshagent(['deploy-server-key']) {
                        sh """
                            ssh -o StrictHostKeyChecking=no user@${DEPLOY_SERVER} '
                                docker pull ${imageTag}
                                docker stop my-app || true
                                docker rm my-app || true
                                docker run -d --name my-app -p 8080:8080 ${imageTag}
                            '
                        """
                    }
                }
            }
        }
    }
    
    post {
        success {
            echo 'Pipeline succeeded!'
            // 发送通知
        }
        failure {
            echo 'Pipeline failed!'
            // 发送告警
        }
    }
}

3.3 Dockerfile

FROM openjdk:11-jre-slim

WORKDIR /app

COPY target/*.jar app.jar

EXPOSE 8080

ENTRYPOINT ["java", "-jar", "app.jar"]

3.4 配置Git仓库

1. 创建Pipeline项目
2. Pipeline → Definition: "Pipeline script from SCM"
3. SCM: Git
4. Repository URL: 填写Git地址
5. Credentials: 添加Git凭证
6. Branch: */main
7. Script Path: Jenkinsfile

---

四、凭证管理

4.1 添加凭证

Manage Jenkins → Credentials → System → Global credentials → Add Credentials

4.2 凭证类型

类型	用途
Username with password	Git账号、Docker Registry
SSH Username with private key	服务器部署
Secret text	Token、API Key
Secret file	配置文件

4.3 在Pipeline中使用

pipeline {
    agent any
    
    stages {
        stage('Deploy') {
            steps {
                // 方式1：SSH凭证
                sshagent(['my-ssh-key']) {
                    sh 'ssh user@server "command"'
                }
                
                // 方式2：用户名密码
                withCredentials([usernamePassword(
                    credentialsId: 'docker-registry',
                    usernameVariable: 'DOCKER_USER',
                    passwordVariable: 'DOCKER_PASS'
                )]) {
                    sh 'docker login -u $DOCKER_USER -p $DOCKER_PASS'
                }
                
                // 方式3：Secret文本
                withCredentials([string(
                    credentialsId: 'api-token',
                    variable: 'API_TOKEN'
                )]) {
                    sh 'curl -H "Authorization: $API_TOKEN" ...'
                }
            }
        }
    }
}

---

五、多分支Pipeline

5.1 创建多分支Pipeline

1. New Item → Multibranch Pipeline
2. 配置Git仓库
3. Jenkins自动扫描所有分支
4. 每个分支独立构建

5.2 分支策略

pipeline {
    agent any
    
    stages {
        stage('Build') {
            steps {
                sh 'mvn package'
            }
        }
        
        stage('Deploy to Dev') {
            when {
                branch 'develop'
            }
            steps {
                echo 'Deploying to dev environment...'
            }
        }
        
        stage('Deploy to Staging') {
            when {
                branch 'release/*'
            }
            steps {
                echo 'Deploying to staging environment...'
            }
        }
        
        stage('Deploy to Production') {
            when {
                branch 'main'
            }
            steps {
                input message: '确认部署到生产环境？'
                echo 'Deploying to production...'
            }
        }
    }
}

---

六、触发器配置

6.1 常用触发器

pipeline {
    agent any
    
    triggers {
        // 定时构建（每天凌晨2点）
        cron('0 2 * * *')
        
        // 轮询SCM（每5分钟检查一次）
        pollSCM('H/5 * * * *')
        
        // GitLab/GitHub Webhook触发
        // 需要在仓库配置Webhook
    }
    
    stages {
        // ...
    }
}

6.2 Webhook配置

GitLab:

Settings → Webhooks → Add webhook
URL: http://jenkins-server:8080/project/项目名
Trigger: Push events

GitHub:

Settings → Webhooks → Add webhook
Payload URL: http://jenkins-server:8080/github-webhook/
Content type: application/json

---

七、跨网络部署

7.1 场景

常见情况：
- Jenkins在公司内网
- 生产服务器在云上或分部机房
- 网络不通，无法SSH部署

7.2 组网方案

使用组网软件（如星空组网）打通Jenkins和部署服务器：

┌─────────────────────────────────────────────────────────┐
│                    组网虚拟局域网                         │
│                                                          │
│  ┌──────────────────┐      ┌──────────────────┐         │
│  │   公司内网        │      │   云服务器/分部   │         │
│  │                  │      │                  │         │
│  │  Jenkins         │      │  生产服务器       │         │
│  │  10.10.0.1       │─────→│  10.10.0.2       │         │
│  │                  │  SSH │                  │         │
│  └──────────────────┘      └──────────────────┘         │
│                                                          │
└─────────────────────────────────────────────────────────┘

Jenkinsfile配置：

environment {
    // 使用组网IP
    DEPLOY_SERVER = '10.10.0.2'
}

stage('Deploy') {
    steps {
        sshagent(['deploy-key']) {
            sh """
                ssh user@${DEPLOY_SERVER} '
                    docker pull my-app:latest
                    docker-compose up -d
                '
            """
        }
    }
}

优势：

• 不需要公网暴露Jenkins
• 不需要服务器开放SSH到公网
• 加密传输，安全可靠
• 配置简单，一次设置

---

八、Blue Ocean

8.1 安装Blue Ocean

Manage Jenkins → Plugins → 搜索"Blue Ocean" → Install

8.2 使用Blue Ocean

访问：http://jenkins:8080/blue

特点：
- 现代化可视化界面
- Pipeline编辑器
- 分支和PR视图
- 更好的日志展示

---

九、常见问题

9.1 构建卡住

// 设置超时
options {
    timeout(time: 30, unit: 'MINUTES')
}

9.2 磁盘空间不足

// 保留最近10次构建
options {
    buildDiscarder(logRotator(numToKeepStr: '10'))
}

9.3 并行构建

stage('Parallel Tests') {
    parallel {
        stage('Unit Tests') {
            steps {
                sh 'mvn test -Dtest=*Unit*'
            }
        }
        stage('Integration Tests') {
            steps {
                sh 'mvn test -Dtest=*Integration*'
            }
        }
    }
}

---

十、总结

Jenkins CI/CD要点：

1. Docker部署：最简单的部署方式
2. Pipeline as Code：Jenkinsfile版本控制
3. 凭证管理：安全存储敏感信息
4. 多分支Pipeline：自动化分支构建
5. Webhook触发：代码提交自动构建
6. 跨网络部署：组网打通构建和部署环境

最佳实践：

☑ Jenkinsfile放在代码仓库
☑ 使用声明式Pipeline
☑ 合理设置构建保留策略
☑ 配置构建通知（邮件/钉钉/企微）
☑ 定期清理工作空间

---

参考资料

1. Jenkins官方文档：https://www.jenkins.io/doc/
2. Jenkins Pipeline语法：https://www.jenkins.io/doc/book/pipeline/syntax/
3. Jenkins插件中心：https://plugins.jenkins.io/

---

💡 建议：从简单的Pipeline开始，逐步添加测试、部署等阶段。先跑通流程，再优化细节。