Jenkins基础教程（192）Jenkins自动化部署和持续交付之回滚更改：代码已回滚，今晚不用加班了！

原创于 2025-11-26 08:21:56 发布 · 110 阅读

5 ·

CC 4.0 BY-SA版权

文章标签：

#jenkins #自动化 #servlet

Jenkins基础教程专栏收录该内容

199 篇文章

订阅专栏

那个深更半夜因为部署出错而被紧急呼叫的工程师，现在终于能睡个安稳觉了。

01 CI/CD与回滚机制，不只是部署那么简单

还记得那个经典段子吗？“它在我的电脑上能运行”——每个开发人员最无奈的辩解。CI/CD的出现，正是为了终结这种无奈。

持续集成就像是乐高工厂的质检员，每次有新的乐高积木就立即检查是否符合标准。而持续交付则是把这些通过检查的积木打包好，随时准备运往商场。

但即使有严格的质检和包装，劣质产品仍有可能流入市场。这就是为什么我们需要回滚机制——它就像是产品的“召回系统”，发现问题立即撤回。

现代软件开发中，回滚已不再是可有可无的选项。一项调查显示，引入自动化回滚的团队平均每月减少4.2小时的宕机时间，这对于一个拥有百万用户的产品来说，意味着避免了巨额损失。

为什么回滚如此重要？想象一下，你上线了一个新功能，结果导致整个系统崩溃。没有回滚机制，你只能眼睁睁看着用户流失，而技术人员则忙着修复问题。有回滚机制，只需一键，系统就能回到正常状态。

持续交付的核心不仅仅是把新代码部署上去，还要能够安全地撤退。就像军事行动中，聪明的将军总会留有撤退的路线。

02 Jenkins基础搭建，从零开始装备自动化武器

在我们大展拳脚之前，得先把Jenkins这个利器安装好。别担心，这比安装一个大型游戏简单多了。

安装Jenkins主要有三种方式：

传统安装方法：就像安装普通软件一样简单。在Linux系统上，只需几个命令：

sudo apt-get update
sudo apt-get install jenkins

然后启动Jenkins服务：systemctl start jenkins，访问http://localhost:8080，就能看到Jenkins的界面了。

容器化部署：如果你熟悉Docker，那更简单了：

docker run -d --name jenkins -p 8080:8080 jenkins/jenkins:lts

一个命令，Jenkins就在容器里跑起来了。

Java直接运行：Jenkins本身就是Java应用，你也可以直接下载WAR文件并用Java运行：java -jar jenkins.war。

完成安装后，首次访问Jenkins会要求初始设置，这里推荐安装建议的插件集，它们涵盖了最常用的功能。

关键插件安装：为了实现完整的CI/CD和回滚功能，需要一些重要插件：

Git Plugin：用于从Git仓库拉取代码
Pipeline：用于定义构建流程
Email Extension Plugin：用于发送构建通知
Build With Parameters Plugin：支持参数化构建

安装完Jenkins，就像有了一个忠诚的机器人助手，但它还需要我们给它明确的指令才能工作。接下来就是教它如何执行任务的时候了。

03 Jenkins流水线核心，打造不休息的构建工厂

Jenkins流水线就像是工厂的生产线，明确规定了从原材料到成品的每一个步骤。这条生产线有两个表达方式：声明式和脚本式。

声明式流水线更直观易懂，适合新手：

pipeline {
    agent any
    stages {
        stage('Checkout') {
            steps {
                git url: 'https://github.com/your-repository.git', branch: 'main'
            }
        }
        stage('Build') {
            steps {
                echo 'Building...'
                sh 'mvn clean install'
            }
        }
        stage('Test') {
            steps {
                echo 'Testing...'
                sh 'mvn test'
            }
        }
        stage('Deploy') {
            steps {
                echo 'Deploying...'
                sh 'scp target/*.jar user@production-server:/path/to/deploy'
            }
        }
    }
}

这个流水线清晰定义了四个阶段：拉取代码、构建、测试和部署。

脚本式流水线基于Groovy语法，提供更灵活的编程能力，可以实现复杂的逻辑判断和循环操作。

阶段是流水线的核心组成部分，常见的阶段包括：

代码检出：从版本控制系统获取最新代码
编译构建：将源代码转换为可执行文件
自动化测试：运行单元测试、集成测试等
代码分析：检查代码质量
构建镜像：创建Docker镜像
部署：将应用部署到目标环境

把Jenkins流水线搭建好，就像是组建了一条自动化生产线，但这还不够，我们还需要为这条生产线装上安全防护装置，确保当产品不合格时能快速撤下。

04 回滚机制设计，给部署上一份保险

回滚是CI/CD流程中的安全网，没有它，走钢丝就会变得极其危险。设计回滚机制时，我们需要考虑多种策略。

参数化构建是实现灵活回滚的关键。通过在Jenkins中配置参数，我们可以让构建过程更具交互性。

比如，添加一个选择参数，让用户决定是执行部署还是回滚：

parameters {
    choice(
        name: 'ACTION',
        choices: ['DEPLOY', 'ROLLBACK'],
        description: '选择要执行的操作'
    )
}

版本管理是回滚的基础。每次部署时，都应该将当前版本备份，以便在需要时恢复。一个简单的备份脚本示例：

#!/bin/bash
backFileName=`date +%Y%m%d%H%M%S`".tar.gz"
# 压缩当前运行程序
cd ${programPath} && tar -zcPf ${backPath}/${backFileName} *

这个脚本将当前运行的程序按时间戳压缩备份。

健康检查是判断是否需要回滚的关键。部署后自动进行健康检查，如果检查不通过，立即触发回滚：

# 心跳检测
curl $healthCheckUrl
if [ $? -ne 0 ]; then
    echo "部署失败，执行回滚"
    # 执行回滚脚本
    ./Production.Rollback.sh ${backPath}
fi

这段脚本会在部署后检查应用健康状态，如果失败则自动回滚。

回滚脚本是回滚操作的执行者。一个基本的回滚脚本需要完成以下任务：

找到最近的成功备份
停止当前应用
恢复备份
重新启动应用

#!/bin/bash
echo "开始回滚..."
# 找到最新的备份文件
lastFile=`cd ${backPath} && ls -t | head -n1 | awk '{print $0}'`
# 解压备份文件
tar zxvf ${backPath}/${lastFile} -C ${programPath}
echo "回滚完成！"

这个脚本会找到最新的备份并恢复它。

除了基本回滚策略，还有两种高级部署策略能进一步降低风险：

蓝绿部署就像是拥有两套完全相同的环境：蓝色（当前生产环境）和绿色（新版本环境）。平时只有蓝色环境服务用户，部署新版本时先部署到绿色环境，测试通过后，将流量从蓝色切换到绿色。

金丝雀发布则更加谨慎，它不像蓝绿部署那样全有或全无，而是逐步将用户流量引导到新版本。比如先让10%的用户访问新版本，如果没有问题，再逐步增加比例。

这就像矿工下井前先放一只金丝雀探测有毒气体，因此得名。

05 完整实战示例，手把手搭建自动化部署回滚系统

理论说了这么多，是时候动手实践了。让我们一步步搭建一个完整的自动化部署与回滚系统。

项目结构：假设我们有一个简单的Java Web应用，项目结构如下：

my-app/
  ├── src/                    # 源代码
  ├── Jenkinsfile            # Jenkins流水线定义
  ├── deploy/                # 部署脚本
  │   ├── deploy.sh
  │   └── rollback.sh
  ├── backups/               # 备份目录
  └── pom.xml               # Maven配置文件

Jenkinsfile配置：在项目根目录创建Jenkinsfile，定义完整的CI/CD流程：

pipeline {
    agent any
    parameters {
        choice(
            name: 'ACTION',
            choices: ['DEPLOY', 'ROLLBACK'],
            description: '选择要执行的操作'
        )
    }
    environment {
        // 定义环境变量
        BACKUP_PATH = '/opt/app/backups'
        APP_PATH = '/opt/app/current'
        HEALTH_CHECK_URL = 'http://your-app.com/health'
    }
    stages {
        stage('Checkout') {
            steps {
                git url: 'https://github.com/your-repo.git', branch: 'main'
            }
        }
        stage('Build') {
            steps {
                sh 'mvn clean package -DskipTests'
            }
        }
        stage('Test') {
            steps {
                sh 'mvn test'
            }
        }
        stage('Backup Current Version') {
            when {
                expression { params.ACTION == 'DEPLOY' }
            }
            steps {
                script {
                    // 如果备份目录不存在则创建
                    sh "mkdir -p ${env:BACKUP_PATH}"
                    // 备份当前版本
                    sh """
                        if [ -d "${env:APP_PATH}" ]; then
                            cd ${env:APP_PATH}
                            tar -zcPf ${env:BACKUP_PATH}/backup-`date +%Y%m%d%H%M%S`.tar.gz .
                        fi
                    """
                }
            }
        }
        stage('Deploy') {
            when {
                expression { params.ACTION == 'DEPLOY' }
            }
            steps {
                sh """
                    # 停止当前应用
                    systemctl stop your-app-service || true
                    # 部署新版本
                    mkdir -p ${env:APP_PATH}
                    cp target/*.war ${env:APP_PATH}
                    # 启动应用
                    systemctl start your-app-service
                    # 等待应用启动
                    sleep 30
                """
            }
        }
        stage('Health Check') {
            when {
                expression { params.ACTION == 'DEPLOY' }
            }
            steps {
                script {
                    // 健康检查
                    def healthy = sh(
                        script: "curl -f ${env:HEALTH_CHECK_URL} || echo 'false'",
                        returnStdout: true
                    ).trim()
                    
                    if (healthy == 'false') {
                        // 健康检查失败，执行回滚
                        echo "健康检查失败，开始自动回滚"
                        sh "cd deploy && ./rollback.sh ${env:BACKUP_PATH} ${env:APP_PATH}"
                        error "部署失败，已执行自动回滚"
                    } else {
                        echo "健康检查通过，部署成功"
                    }
                }
            }
        }
        stage('Rollback') {
            when {
                expression { params.ACTION == 'ROLLBACK' }
            }
            steps {
                sh "cd deploy && ./rollback.sh ${env:BACKUP_PATH} ${env:APP_PATH}"
            }
        }
    }
    post {
        always {
            echo "构建完成：${currentBuild.result}"
            // 发送构建通知
            emailext (
                subject: "构建通知: ${env:JOB_NAME} - ${currentBuild.result}",
                body: """
                项目: ${env:JOB_NAME}
                构建编号: ${env:BUILD_NUMBER}
                构建结果: ${currentBuild.result}
                构建地址: ${env:BUILD_URL}
                """,
                to: 'dev-team@example.com'
            )
        }
    }
}

部署脚本：在deploy/deploy.sh中定义部署逻辑：

#!/bin/bash
set -e  # 遇到错误立即退出

echo "开始部署..."
APP_PATH=$1
BACKUP_PATH=$2

# 备份当前版本
if [ -d "$APP_PATH" ]; then
    echo "备份当前版本..."
    cd $APP_PATH
    tar -zcPf $BACKUP_PATH/backup-`date +%Y%m%d%H%M%S`.tar.gz .
fi

echo "部署完成！"

回滚脚本：在deploy/rollback.sh中定义回滚逻辑：

#!/bin/bash
set -e

echo "开始回滚..."
BACKUP_PATH=$1
APP_PATH=$2

# 找到最新的备份文件
if [ ! -d "$BACKUP_PATH" ]; then
    echo "错误：备份目录不存在"
    exit 1
fi

latest_backup=$(ls -t $BACKUP_PATH | head -n1)

if [ -z "$latest_backup" ]; then
    echo "错误：没有找到备份文件"
    exit 1
fi

echo "回滚到备份: $latest_backup"

# 停止应用
systemctl stop your-app-service || true

# 清空当前应用目录
rm -rf $APP_PATH/*

# 恢复备份
tar -zxPf "$BACKUP_PATH/$latest_backup" -C $APP_PATH

# 启动应用
systemctl start your-app-service

echo "回滚完成！"

配置Jenkins任务：