Jenkins 教程：自动化服务器详解

1. 什么是 Jenkins？

Jenkins 是一个开源的自动化服务器，用于实现持续集成（CI）和持续部署（CD）流程。它由 Java 开发，可以通过插件系统扩展功能，支持构建、测试和部署软件项目。

1.1 核心概念

  • 流水线（Pipeline）：定义整个构建、测试和部署流程的代码。
  • 作业（Job）：Jenkins 中执行的最小工作单元。
  • 构建（Build）：作业的一次执行实例。
  • 插件（Plugin）：扩展 Jenkins 功能的组件。
  • 节点（Node）：执行构建的机器，可以是主节点或从节点。
  • 工作空间（Workspace）：存储构建文件的目录。
  • 触发器（Trigger）：触发构建的事件，如代码提交、定时触发等。
  • ** artifact**：构建生成的产物，如编译后的代码、测试报告等。

1.2 核心特性

  • 可扩展性：通过插件系统支持各种构建工具和技术。
  • 分布式构建：可以在多个节点上分布式执行构建任务。
  • 流水线即代码：使用 Jenkinsfile 定义构建流水线。
  • 丰富的集成：与版本控制系统、构建工具、测试工具等集成。
  • 实时反馈：提供构建状态和测试结果的实时反馈。
  • 安全：支持多种认证和授权机制。
  • 可定制性：可以根据项目需求定制构建流程。

1.3 适用场景

  • 持续集成：代码提交后自动构建和测试。
  • 持续部署：自动将构建产物部署到测试或生产环境。
  • 自动化测试：自动运行单元测试、集成测试等。
  • 构建自动化：自动编译、打包和发布软件。
  • 代码质量检查：集成代码质量分析工具。
  • 多环境部署：在不同环境中一致部署应用。

2. 安装和配置

2.1 系统要求

  • Java：Jenkins 需要 Java 8 或更高版本。
  • 内存：建议至少 2GB RAM。
  • 磁盘空间：建议至少 50GB 磁盘空间。
  • 网络：需要网络连接以下载插件和依赖。

2.2 安装 Jenkins

2.2.1 Linux 安装

在 Ubuntu/Debian 上安装：

# 添加 Jenkins 仓库
wget -q -O - https://pkg.jenkins.io/debian/jenkins.io.key | sudo apt-key add -
sudo sh -c 'echo deb https://pkg.jenkins.io/debian-stable binary/ > /etc/apt/sources.list.d/jenkins.list'

# 更新包索引
sudo apt update

# 安装 Java（如果尚未安装）
sudo apt install openjdk-11-jdk

# 安装 Jenkins
sudo apt install jenkins

# 启动 Jenkins 服务
sudo systemctl start jenkins

# 启用 Jenkins 服务自启动
sudo systemctl enable jenkins

# 查看 Jenkins 服务状态
sudo systemctl status jenkins

在 CentOS/RHEL 上安装：

# 安装 Java（如果尚未安装）
sudo yum install java-11-openjdk-devel

# 添加 Jenkins 仓库
sudo wget -O /etc/yum.repos.d/jenkins.repo https://pkg.jenkins.io/redhat-stable/jenkins.repo
sudo rpm --import https://pkg.jenkins.io/redhat-stable/jenkins.io.key

# 安装 Jenkins
sudo yum install jenkins

# 启动 Jenkins 服务
sudo systemctl start jenkins

# 启用 Jenkins 服务自启动
sudo systemctl enable jenkins

# 查看 Jenkins 服务状态
sudo systemctl status jenkins

2.2.2 Windows 安装

  1. 下载 Jenkins Windows 安装包：https://www.jenkins.io/download/
  2. 运行安装程序，按照提示完成安装。
  3. 安装完成后，Jenkins 会自动启动并在浏览器中打开。

2.2.3 Docker 安装

# 拉取 Jenkins 镜像
docker pull jenkins/jenkins:lts

# 运行 Jenkins 容器
docker run -d --name jenkins -p 8080:8080 -p 50000:50000 -v jenkins_home:/var/jenkins_home jenkins/jenkins:lts

# 查看容器日志
docker logs jenkins

2.3 初始配置

  1. 访问 Jenkins：打开浏览器访问 http://localhost:8080。

  2. 解锁 Jenkins：

    • 查看初始管理员密码：
      • Linux：sudo cat /var/lib/jenkins/secrets/initialAdminPassword
      • Docker：docker exec jenkins cat /var/jenkins_home/secrets/initialAdminPassword
    • 输入密码解锁 Jenkins。

  3. 安装插件：

    • 选择 "Install suggested plugins" 安装推荐插件。
    • 或者选择 "Select plugins to install" 自定义安装插件。

  4. 创建管理员用户：输入用户名、密码、全名和电子邮件地址。

  5. 配置实例：设置 Jenkins URL，默认为 http://localhost:8080。

  6. 完成设置：点击 "Save and Finish" 完成设置。

2.4 验证安装

打开浏览器访问 http://localhost:8080，使用创建的管理员用户登录。

3. 基本使用

3.1 创建第一个作业

  1. 登录 Jenkins：打开浏览器访问 http://localhost:8080，使用管理员用户登录。

  2. 创建作业：

    • 点击左侧菜单中的 "New Item"。
    • 输入作业名称，如 "HelloWorld"。
    • 选择 "Freestyle project"，点击 "OK"。

  3. 配置作业：

    • 在 "General" 部分，输入作业描述。
    • 在 "Build" 部分，点击 "Add build step"，选择 "Execute shell"（Linux）或 "Execute Windows batch command"（Windows）。
    • 在命令框中输入 echo "Hello, Jenkins!"。
    • 点击 "Save" 保存作业配置。

  4. 运行作业：

    • 在作业页面，点击 "Build Now" 运行作业。
    • 在 "Build History" 部分，点击构建编号查看构建详情。
    • 点击 "Console Output" 查看构建输出，应该看到 "Hello, Jenkins!"。

3.2 配置版本控制系统集成

  1. 安装 Git 插件（如果尚未安装）：

    • 点击左侧菜单中的 "Manage Jenkins" > "Manage Plugins"。
    • 在 "Available" 标签页中搜索 "Git Plugin"，勾选后点击 "Install without restart"。

  2. 配置 Git 凭证：

    • 点击左侧菜单中的 "Manage Jenkins" > "Manage Credentials"。
    • 点击 "Jenkins" > "Global credentials" > "Add Credentials"。
    • 选择 "Username with password" 或 "SSH Username with private key"，输入凭证信息，点击 "OK"。

  3. 创建 Git 集成作业：

    • 点击左侧菜单中的 "New Item"。
    • 输入作业名称，如 "GitTest"。
    • 选择 "Freestyle project"，点击 "OK"。
    • 在 "Source Code Management" 部分，选择 "Git"。
    • 输入 Git 仓库 URL，如 https://github.com/username/repository.git。
    • 在 "Credentials" 下拉菜单中选择之前配置的凭证。
    • 在 "Build" 部分，添加构建步骤，如 "Execute shell" 输入 ls -la。
    • 点击 "Save" 保存作业配置。

  4. 运行作业：

    • 点击 "Build Now" 运行作业。
    • 查看构建详情和控制台输出，应该看到仓库中的文件列表。

3.3 配置构建触发器

  1. 定时构建：

    • 编辑作业配置，在 "Build Triggers" 部分，勾选 "Build periodically"。
    • 在日程表中输入 cron 表达式，如 H/15 * * * *（每 15 分钟构建一次）。
    • 点击 "Save" 保存配置。

  2. 代码提交触发：

    • 编辑作业配置，在 "Build Triggers" 部分，勾选 "Poll SCM"。
    • 在日程表中输入 cron 表达式，如 H/5 * * * *（每 5 分钟检查一次代码变更）。
    • 点击 "Save" 保存配置。

  3. 其他作业触发：

    • 编辑作业配置，在 "Build Triggers" 部分，勾选 "Build after other projects are built"。
    • 输入触发本作业的其他作业名称，如 "JobA"。
    • 选择触发条件，如 "Trigger only if build is stable"。
    • 点击 "Save" 保存配置。

3.4 查看构建结果

  1. 构建历史：在作业页面的 "Build History" 部分，可以看到所有构建记录。

  2. 构建详情：点击构建编号查看构建详情，包括构建时间、持续时间、构建状态等。

  3. 控制台输出：点击 "Console Output" 查看构建的详细输出。

  4. 测试报告：如果作业配置了测试，点击 "Test Result" 查看测试报告。

  5. 构建产物：如果作业配置了归档产物，点击 "Last successful artifact" 下载构建产物。

4. 高级功能

4.1 使用 Jenkins Pipeline

Jenkins Pipeline 是 Jenkins 2.0 引入的核心功能，允许使用代码定义整个构建、测试和部署流程。

4.1.1 创建 Pipeline 作业

  1. **点击左侧菜单中的 "New Item"**。
  2. 输入作业名称，如 "PipelineTest"。
  3. **选择 "Pipeline"**，点击 "OK"。
  4. 在 "Pipeline" 部分，选择 "Pipeline script"，输入以下脚本：
pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                echo 'Building...'
                sh 'echo "Build step"'
            }
        }
        stage('Test') {
            steps {
                echo 'Testing...'
                sh 'echo "Test step"'
            }
        }
        stage('Deploy') {
            steps {
                echo 'Deploying...'
                sh 'echo "Deploy step"'
            }
        }
    }
    post {
        always {
            echo 'This will always run'
        }
        success {
            echo 'This will run only if successful'
        }
        failure {
            echo 'This will run only if failed'
        }
    }
}
  1. 点击 "Save" 保存作业配置。
  2. 点击 "Build Now" 运行 Pipeline 作业。
  3. 查看 Pipeline 执行情况，可以看到各个阶段的执行状态。

4.1.2 使用 Jenkinsfile

Jenkinsfile 是存储在版本控制系统中的 Pipeline 脚本文件。

  1. 在项目根目录创建 Jenkinsfile 文件，内容如下：
pipeline {
    agent any
    stages {
        stage('Checkout') {
            steps {
                checkout scm
            }
        }
        stage('Build') {
            steps {
                echo 'Building...'
                sh 'npm install'
                sh 'npm run build'
            }
        }
        stage('Test') {
            steps {
                echo 'Testing...'
                sh 'npm test'
            }
        }
        stage('Deploy') {
            steps {
                echo 'Deploying...'
                sh 'echo "Deploying to production"'
            }
        }
    }
    post {
        success {
            echo 'Build succeeded!'
        }
        failure {
            echo 'Build failed!'
        }
    }
}

  1. 提交 Jenkinsfile 到版本控制系统。

  2. 在 Jenkins 中创建 Pipeline 作业：

    • 点击左侧菜单中的 "New Item"。
    • 输入作业名称，如 "PipelineFromJenkinsfile"。
    • 选择 "Pipeline"，点击 "OK"。
    • 在 "Pipeline" 部分，选择 "Pipeline script from SCM"。
    • 选择 "Git"，输入仓库 URL 和凭证。
    • 在 "Script Path" 中输入 "Jenkinsfile"。
    • 点击 "Save" 保存作业配置。

  3. 点击 "Build Now" 运行 Pipeline 作业，Jenkins 会从版本控制系统中读取 Jenkinsfile 并执行。

4.2 配置分布式构建

分布式构建允许 Jenkins 在多个节点上执行构建任务，提高构建速度。

4.2.1 添加从节点

  1. **点击左侧菜单中的 "Manage Jenkins" > "Manage Nodes and Clouds"**。

  2. **点击 "New Node"**，输入节点名称，选择 "Permanent Agent"，点击 "OK"。

  3. 配置节点：

    • 在 "Remote root directory" 中输入从节点的工作目录，如 "/var/jenkins_slave"。
    • 在 "Labels" 中输入节点标签，如 "linux"。
    • 在 "Launch method" 中选择启动方式，如 "Launch agent via SSH"。
    • 输入从节点的主机名、凭证等信息。
    • 点击 "Save" 保存节点配置。

  4. 启动从节点：

    • 在节点列表中，点击从节点名称，点击 "Launch agent" 启动从节点。
    • 查看节点状态，应该显示为 "Online"。

4.2.2 在 Pipeline 中使用从节点

pipeline {
    agent {
        node {
            label 'linux'
        }
    }
    stages {
        stage('Build') {
            steps {
                echo 'Building on linux node...'
                sh 'echo "Build on linux node"'
            }
        }
    }
}

4.3 配置构建工具集成

4.3.1 Maven 集成

  1. 安装 Maven 插件（如果尚未安装）：

    • 点击左侧菜单中的 "Manage Jenkins" > "Manage Plugins"。
    • 在 "Available" 标签页中搜索 "Maven Integration plugin"，勾选后点击 "Install without restart"。

  2. 配置 Maven：

    • 点击左侧菜单中的 "Manage Jenkins" > "Global Tool Configuration"。
    • 在 "Maven" 部分，点击 "Add Maven"，输入名称，选择 "Install automatically"，点击 "Save"。

  3. 创建 Maven 作业：

    • 点击左侧菜单中的 "New Item"。
    • 输入作业名称，如 "MavenTest"。
    • 选择 "Maven project"，点击 "OK"。
    • 在 "Source Code Management" 部分，配置 Git 仓库。
    • 在 "Build" 部分，输入 Maven 目标，如 "clean install"。
    • 点击 "Save" 保存作业配置。
    • 点击 "Build Now" 运行 Maven 作业。

4.3.2 Gradle 集成

  1. 安装 Gradle 插件（如果尚未安装）：

    • 点击左侧菜单中的 "Manage Jenkins" > "Manage Plugins"。
    • 在 "Available" 标签页中搜索 "Gradle Plugin"，勾选后点击 "Install without restart"。

  2. 配置 Gradle：

    • 点击左侧菜单中的 "Manage Jenkins" > "Global Tool Configuration"。
    • 在 "Gradle" 部分，点击 "Add Gradle"，输入名称，选择 "Install automatically"，点击 "Save"。

  3. 创建 Gradle 作业：

    • 点击左侧菜单中的 "New Item"。
    • 输入作业名称，如 "GradleTest"。
    • 选择 "Freestyle project"，点击 "OK"。
    • 在 "Build" 部分，点击 "Add build step"，选择 "Invoke Gradle script"。
    • 选择配置的 Gradle 安装，输入任务，如 "clean build"。
    • 点击 "Save" 保存作业配置。
    • 点击 "Build Now" 运行 Gradle 作业。

4.4 配置通知

4.4.1 电子邮件通知

  1. 配置 Jenkins 系统邮件设置：

    • 点击左侧菜单中的 "Manage Jenkins" > "Configure System"。
    • 在 "E-mail Notification" 部分，输入 SMTP 服务器、发件人地址等信息。
    • 点击 "Test configuration by sending test e-mail" 测试邮件配置。
    • 点击 "Save" 保存系统配置。

  2. 在作业中配置邮件通知：

    • 编辑作业配置，在 "Post-build Actions" 部分，点击 "Add post-build action"，选择 "E-mail Notification"。
    • 输入收件人邮箱地址，勾选 "Send e-mail for every unstable build"，点击 "Save"。

4.4.2 Slack 通知

  1. 安装 Slack 插件（如果尚未安装）：

    • 点击左侧菜单中的 "Manage Jenkins" > "Manage Plugins"。
    • 在 "Available" 标签页中搜索 "Slack Notification Plugin"，勾选后点击 "Install without restart"。

  2. 配置 Slack 集成：

    • 点击左侧菜单中的 "Manage Jenkins" > "Configure System"。
    • 在 "Slack" 部分，输入 Team Domain、Integration Token Credential 等信息。
    • 点击 "Test Connection" 测试 Slack 配置。
    • 点击 "Save" 保存系统配置。

  3. 在作业中配置 Slack 通知：

    • 编辑作业配置，在 "Post-build Actions" 部分，点击 "Add post-build action"，选择 "Slack Notifications"。
    • 配置通知条件和消息，点击 "Save"。

5. 实用案例

5.1 构建和测试 Node.js 应用

场景：使用 Jenkins 构建和测试 Node.js 应用。

步骤：

  1. 创建 Node.js 项目：
mkdir jenkins-node-app && cd jenkins-node-app
npm init -y
npm install express jest
  1. 创建应用代码：

app.js：

const express = require('express');
const app = express();
const port = 3000;

app.get('/', (req, res) => {
  res.send('Hello World!');
});

app.listen(port, () => {
  console.log(`App listening at http://localhost:${port}`);
});

module.exports = app;

test/app.test.js：

const app = require('../app');
const request = require('supertest');

test('GET / returns Hello World!', async () => {
  const response = await request(app).get('/');
  expect(response.statusCode).toBe(200);
  expect(response.text).toBe('Hello World!');
});
  1. 更新 package.json：
{
  "name": "jenkins-node-app",
  "version": "1.0.0",
  "description": "Node.js app for Jenkins test",
  "main": "app.js",
  "scripts": {
    "start": "node app.js",
    "test": "jest",
    "build": "echo \"Building...\""
  },
  "dependencies": {
    "express": "^4.17.1"
  },
  "devDependencies": {
    "jest": "^27.0.6",
    "supertest": "^6.1.3"
  }
}
  1. 创建 Jenkinsfile：
pipeline {
    agent any
    stages {
        stage('Checkout') {
            steps {
                checkout scm
            }
        }
        stage('Install Dependencies') {
            steps {
                sh 'npm install'
            }
        }
        stage('Test') {
            steps {
                sh 'npm test'
            }
        }
        stage('Build') {
            steps {
                sh 'npm run build'
            }
        }
    }
    post {
        success {
            echo 'Build succeeded!'
        }
        failure {
            echo 'Build failed!'
        }
    }
}
  1. 提交代码到 Git 仓库：
git init
git add .
git commit -m "Initial commit"
git remote add origin https://github.com/yourusername/jenkins-node-app.git
git push -u origin main

  1. 在 Jenkins 中创建 Pipeline 作业：

    • 点击左侧菜单中的 "New Item"。
    • 输入作业名称，如 "Node.js Test"。
    • 选择 "Pipeline"，点击 "OK"。
    • 在 "Pipeline" 部分，选择 "Pipeline script from SCM"。
    • 选择 "Git"，输入仓库 URL 和凭证。
    • 在 "Script Path" 中输入 "Jenkinsfile"。
    • 点击 "Save" 保存作业配置。

  2. 运行作业：

    • 在作业页面，点击 "Build Now" 运行作业。
    • 查看 Pipeline 执行情况，应该看到各个阶段的执行状态。
    • 点击 "Console Output" 查看构建输出，应该看到测试通过的信息。

5.2 部署应用到生产环境

场景：使用 Jenkins 构建应用并部署到生产环境。

步骤：

  1. 创建部署脚本：

deploy.sh：

#!/bin/bash

echo "Deploying application to production..."

# 停止旧应用
if [ -f /tmp/app.pid ]; then
    kill $(cat /tmp/app.pid)
    rm /tmp/app.pid
fi

# 复制应用到部署目录
cp -r . /opt/app

# 启动新应用
cd /opt/app
npm start > /var/log/app.log 2>&1 &
echo $! > /tmp/app.pid

echo "Deployment completed!"
  1. 更新 Jenkinsfile：
pipeline {
    agent any
    stages {
        stage('Checkout') {
            steps {
                checkout scm
            }
        }
        stage('Install Dependencies') {
            steps {
                sh 'npm install'
            }
        }
        stage('Test') {
            steps {
                sh 'npm test'
            }
        }
        stage('Build') {
            steps {
                sh 'npm run build'
            }
        }
        stage('Deploy to Production') {
            steps {
                sh 'chmod +x deploy.sh'
                sh './deploy.sh'
            }
        }
    }
    post {
        success {
            echo 'Deployment succeeded!'
        }
        failure {
            echo 'Deployment failed!'
        }
    }
}
  1. 提交代码到 Git 仓库：
git add deploy.sh Jenkinsfile
git commit -m "Add deployment script"
git push

  1. 在 Jenkins 中运行 Pipeline 作业：

    • 在作业页面，点击 "Build Now" 运行作业。
    • 查看 Pipeline 执行情况，应该看到部署阶段的执行状态。
    • 查看 "Console Output" 查看部署输出，应该看到部署完成的信息。

  2. 验证部署：

    • 打开浏览器访问应用的 URL，应该看到应用正常运行。

6. 代码示例

6.1 基本 Pipeline 示例

Jenkinsfile：

pipeline {
    agent any
    parameters {
        string(name: 'DEPLOY_ENV', defaultValue: 'staging', description: 'Deployment environment')
        booleanParam(name: 'RUN_TESTS', defaultValue: true, description: 'Run tests')
    }
    environment {
        NODE_ENV = "${params.DEPLOY_ENV}"
    }
    stages {
        stage('Checkout') {
            steps {
                checkout scm
            }
        }
        stage('Install') {
            steps {
                sh 'npm install'
            }
        }
        stage('Test') {
            when {
                expression { params.RUN_TESTS }
            }
            steps {
                sh 'npm test'
            }
        }
        stage('Build') {
            steps {
                sh 'npm run build'
            }
        }
        stage('Deploy') {
            steps {
                sh "echo Deploying to ${env.NODE_ENV} environment"
                sh './deploy.sh'
            }
        }
    }
    post {
        always {
            echo 'Build completed'
        }
        success {
            slackSend channel: '#jenkins', message: 'Build succeeded!'
        }
        failure {
            slackSend channel: '#jenkins', message: 'Build failed!'
            mail to: 'admin@example.com', subject: 'Build failed', body: 'The build failed'
        }
    }
}
« 上一篇 Ansible 教程：自动化配置管理工具详解 下一篇 » GitHub Actions 教程
↑