CentOS Stream持续集成环境搭建详解一步到位从环境准备到自动化测试全流程指导提升软件交付速度与质量

威震华夏关云长

引言

持续集成（Continuous Integration，CI）是现代软件开发流程中的关键实践，它通过频繁地将代码集成到共享仓库中，并自动进行构建和测试，帮助团队及早发现并解决问题，从而提高软件交付的速度和质量。CentOS Stream作为RHEL（Red Hat Enterprise Linux）的上游开发平台，具有稳定性强、社区支持活跃、生命周期长等优势，是搭建持续集成环境的理想选择。

本文将详细介绍如何在CentOS Stream上搭建完整的持续集成环境，从环境准备到自动化测试的全流程，帮助开发团队提升软件交付速度与质量。

环境准备

系统要求

在开始搭建持续集成环境之前，我们需要确保满足以下基本系统要求：

• CPU：至少2核心，推荐4核心或以上
• 内存：至少4GB，推荐8GB或以上
• 硬盘：至少40GB可用空间，推荐100GB或以上
• 网络：稳定的互联网连接，用于下载软件包和依赖

安装CentOS Stream

1.

2. 下载CentOS Stream ISO镜像文件：
3. 访问CentOS Stream官方网站（https://centos.org/download/）下载最新的ISO镜像文件。

复制代码

2. 创建启动介质：
使用工具如Rufus（Windows）或dd命令（Linux）将ISO镜像写入USB驱动器。
3. 安装CentOS Stream：将启动介质插入服务器并启动在启动菜单中选择”Install CentOS Stream”按照安装向导完成安装过程，包括分区设置、网络配置、用户创建等
4. 将启动介质插入服务器并启动
5. 在启动菜单中选择”Install CentOS Stream”
6. 按照安装向导完成安装过程，包括分区设置、网络配置、用户创建等

下载CentOS Stream ISO镜像文件：
访问CentOS Stream官方网站（https://centos.org/download/）下载最新的ISO镜像文件。

创建启动介质：
使用工具如Rufus（Windows）或dd命令（Linux）将ISO镜像写入USB驱动器。

安装CentOS Stream：

• 将启动介质插入服务器并启动
• 在启动菜单中选择”Install CentOS Stream”
• 按照安装向导完成安装过程，包括分区设置、网络配置、用户创建等

基本系统配置

安装完成后，需要进行一些基本配置：

1. 更新系统：

2. sudo dnf update -y

复制代码

1. 安装常用工具：

2. sudo dnf install -y wget curl vim git

复制代码

1. 配置防火墙：

2. sudo systemctl enable --now firewalld
3. sudo firewall-cmd --permanent --add-service=ssh
4. sudo firewall-cmd --reload

复制代码

1. 配置SELinux（可选，根据安全需求）：

2. sudo setenforce 0  # 临时设置为宽松模式
3. sudo vi /etc/selinux/config  # 编辑配置文件永久设置

复制代码

基础工具安装

Java环境安装

Jenkins是基于Java的持续集成工具，因此需要先安装Java环境：

2. # 安装OpenJDK 11
3. sudo dnf install -y java-11-openjdk java-11-openjdk-devel
5. # 验证Java安装
6. java -version

复制代码

Git安装

Git是版本控制系统，用于代码管理：

2. # 安装Git
3. sudo dnf install -y git
5. # 配置Git
6. git config --global user.name "Your Name"
7. git config --global user.email "your.email@example.com"
9. # 验证Git安装
10. git --version

复制代码

Docker安装

Docker用于创建隔离的构建环境：

2. # 安装Docker
3. sudo dnf config-manager --add-repo=https://download.docker.com/linux/centos/docker-ce.repo
4. sudo dnf install -y docker-ce docker-ce-cli containerd.io
6. # 启动Docker服务
7. sudo systemctl enable --now docker
9. # 将当前用户添加到docker组
10. sudo usermod -aG docker $USER
12. # 重新登录以应用组更改
13. # 验证Docker安装
14. docker --version

复制代码

持续集成服务器搭建

Jenkins安装与配置

1. 添加Jenkins仓库：

2. sudo wget -O /etc/yum.repos.d/jenkins.repo https://pkg.jenkins.io/redhat-stable/jenkins.repo
3. sudo rpm --import https://pkg.jenkins.io/redhat-stable/jenkins.io.key

复制代码

1. 安装Jenkins：

2. sudo dnf install -y jenkins

复制代码

1. 启动Jenkins服务：

2. sudo systemctl enable --now jenkins

复制代码

1. 配置防火墙允许Jenkins访问：

2. sudo firewall-cmd --permanent --add-port=8080/tcp
3. sudo firewall-cmd --reload

复制代码

1. 初始设置：访问http://your-server-ip:8080按照提示获取初始管理员密码：sudo cat /var/lib/jenkins/secrets/initialAdminPassword安装推荐的插件创建管理员用户
2. 访问http://your-server-ip:8080
3. 按照提示获取初始管理员密码：sudo cat /var/lib/jenkins/secrets/initialAdminPassword
4. 安装推荐的插件
5. 创建管理员用户

• 访问http://your-server-ip:8080
• 按照提示获取初始管理员密码：sudo cat /var/lib/jenkins/secrets/initialAdminPassword
• 安装推荐的插件
• 创建管理员用户

2. sudo cat /var/lib/jenkins/secrets/initialAdminPassword

复制代码

Jenkins基本配置

1. 全局工具配置：进入”Manage Jenkins” > “Global Tool Configuration”配置JDK、Git、Maven等工具
2. 进入”Manage Jenkins” > “Global Tool Configuration”
3. 配置JDK、Git、Maven等工具
4. 插件管理：安装必要的插件，如：Git PluginPipeline PluginDocker PluginSSH PluginEmail Extension Plugin
5. 安装必要的插件，如：Git PluginPipeline PluginDocker PluginSSH PluginEmail Extension Plugin
6. Git Plugin
7. Pipeline Plugin
8. Docker Plugin
9. SSH Plugin
10. Email Extension Plugin

全局工具配置：

• 进入”Manage Jenkins” > “Global Tool Configuration”
• 配置JDK、Git、Maven等工具

插件管理：

• 安装必要的插件，如：Git PluginPipeline PluginDocker PluginSSH PluginEmail Extension Plugin
• Git Plugin
• Pipeline Plugin
• Docker Plugin
• SSH Plugin
• Email Extension Plugin

• Git Plugin
• Pipeline Plugin
• Docker Plugin
• SSH Plugin
• Email Extension Plugin

版本控制系统集成

Git仓库设置

1. 创建示例项目：

2. mkdir -p ~/projects/sample-ci-app
3. cd ~/projects/sample-ci-app
4. git init

复制代码

1. 创建简单的Java应用：

2. # 创建目录结构
3. mkdir -p src/main/java/com/example
4. mkdir -p src/test/java/com/example
6. # 创建主类
7. cat > src/main/java/com/example/App.java << EOF
8. package com.example;
10. public class App {
11.     public static void main(String[] args) {
12.         System.out.println("Hello, Continuous Integration!");
13.     }
14.    
15.     public int add(int a, int b) {
16.         return a + b;
17.     }
18. }
19. EOF
21. # 创建测试类
22. cat > src/test/java/com/example/AppTest.java << EOF
23. package com.example;
25. import org.junit.Test;
26. import static org.junit.Assert.*;
28. public class AppTest {
29.     @Test
30.     public void testAdd() {
31.         App app = new App();
32.         assertEquals(5, app.add(2, 3));
33.     }
34. }
35. EOF

复制代码

1. 创建Maven构建文件：

2. cat > pom.xml << EOF
3. <?xml version="1.0" encoding="UTF-8"?>
4. <project xmlns="http://maven.apache.org/POM/4.0.0"
5.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
6.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
7.     <modelVersion>4.0.0</modelVersion>
9.     <groupId>com.example</groupId>
10.     <artifactId>sample-ci-app</artifactId>
11.     <version>1.0-SNAPSHOT</version>
13.     <properties>
14.         <maven.compiler.source>11</maven.compiler.source>
15.         <maven.compiler.target>11</maven.compiler.target>
16.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
17.     </properties>
19.     <dependencies>
20.         <dependency>
21.             <groupId>junit</groupId>
22.             <artifactId>junit</artifactId>
23.             <version>4.13.2</version>
24.             <scope>test</scope>
25.         </dependency>
26.     </dependencies>
28.     <build>
29.         <plugins>
30.             <plugin>
31.                 <groupId>org.apache.maven.plugins</groupId>
32.                 <artifactId>maven-surefire-plugin</artifactId>
33.                 <version>3.0.0-M5</version>
34.             </plugin>
35.         </plugins>
36.     </build>
37. </project>
38. EOF

复制代码

1. 提交代码到Git仓库：

2. git add .
3. git commit -m "Initial commit"

复制代码

Jenkins与Git集成

1. 在Jenkins中创建新任务：点击”New Item”输入任务名称，选择”Freestyle project”或”Pipeline”点击”OK”
2. 点击”New Item”
3. 输入任务名称，选择”Freestyle project”或”Pipeline”
4. 点击”OK”
5. 配置源代码管理：选择”Git”输入仓库URL（如file:///home/user/projects/sample-ci-app）选择凭证（如果需要）
6. 选择”Git”
7. 输入仓库URL（如file:///home/user/projects/sample-ci-app）
8. 选择凭证（如果需要）
9. 配置构建触发器：选择”Poll SCM”设置调度规则，如H/5 * * * *（每5分钟检查一次）
10. 选择”Poll SCM”
11. 设置调度规则，如H/5 * * * *（每5分钟检查一次）

在Jenkins中创建新任务：

• 点击”New Item”
• 输入任务名称，选择”Freestyle project”或”Pipeline”
• 点击”OK”

配置源代码管理：

• 选择”Git”
• 输入仓库URL（如file:///home/user/projects/sample-ci-app）
• 选择凭证（如果需要）

配置构建触发器：

• 选择”Poll SCM”
• 设置调度规则，如H/5 * * * *（每5分钟检查一次）

自动化构建

Maven安装与配置

1. 安装Maven：

2. sudo dnf install -y maven

复制代码

1. 验证Maven安装：

2. mvn -version

复制代码

Jenkins构建配置

1. 在Jenkins任务配置中，添加构建步骤：选择”Invoke top-level Maven targets”输入目标：clean package
2. 选择”Invoke top-level Maven targets”
3. 输入目标：clean package
4. 或者，使用Pipeline脚本：

在Jenkins任务配置中，添加构建步骤：

• 选择”Invoke top-level Maven targets”
• 输入目标：clean package

或者，使用Pipeline脚本：

2. pipeline {
3.     agent any
4.    
5.     stages {
6.         stage('Build') {
7.             steps {
8.                 sh 'mvn clean package'
9.             }
10.         }
11.         stage('Test') {
12.             steps {
13.                 sh 'mvn test'
14.             }
15.         }
16.     }
17.    
18.     post {
19.         always {
20.             junit 'target/surefire-reports/*.xml'
21.             archiveArtifacts artifacts: 'target/*.jar', fingerprint: true
22.         }
23.     }
24. }

复制代码

1. 保存配置并运行构建

自动化测试

测试框架选择

Java项目中常用的测试框架包括：

• JUnit：单元测试框架
• TestNG：测试框架，提供更多功能
• Selenium：Web应用测试
• REST Assured：API测试

配置自动化测试

1. 扩展示例项目，添加更多测试：

2. # 创建集成测试目录
3. mkdir -p src/test/java/com/example/integration
5. # 创建集成测试类
6. cat > src/test/java/com/example/integration/AppIntegrationTest.java << EOF
7. package com.example.integration;
9. import com.example.App;
10. import org.junit.Test;
11. import static org.junit.Assert.*;
13. public class AppIntegrationTest {
14.     @Test
15.     public void testAppFunctionality() {
16.         App app = new App();
17.         // 模拟更复杂的测试场景
18.         int result = app.add(5, 10);
19.         assertEquals(15, result);
20.     }
21. }
22. EOF

复制代码

1. 更新Jenkins Pipeline以包含测试阶段：

2. pipeline {
3.     agent any
4.    
5.     stages {
6.         stage('Build') {
7.             steps {
8.                 sh 'mvn clean compile'
9.             }
10.         }
11.         stage('Unit Test') {
12.             steps {
13.                 sh 'mvn test'
14.             }
15.         }
16.         stage('Integration Test') {
17.             steps {
18.                 sh 'mvn verify'
19.             }
20.         }
21.         stage('Static Code Analysis') {
22.             steps {
23.                 // 例如使用SonarQube进行代码分析
24.                 // sh 'mvn sonar:sonar'
25.             }
26.         }
27.     }
28.    
29.     post {
30.         always {
31.             junit 'target/surefire-reports/*.xml'
32.             archiveArtifacts artifacts: 'target/*.jar', fingerprint: true
33.         }
34.         success {
35.             echo 'Build and tests successful!'
36.         }
37.         failure {
38.             echo 'Build or tests failed!'
39.             // 可以添加通知逻辑
40.         }
41.     }
42. }

复制代码

测试报告与可视化

1. 安装Jenkins插件：HTML Publisher PluginJUnit PluginTest Results Analyzer Plugin
2. HTML Publisher Plugin
3. JUnit Plugin
4. Test Results Analyzer Plugin
5. 配置测试报告发布：

安装Jenkins插件：

• HTML Publisher Plugin
• JUnit Plugin
• Test Results Analyzer Plugin

配置测试报告发布：

2. post {
3.     always {
4.         // 发布JUnit测试结果
5.         junit 'target/surefire-reports/*.xml'
6.         
7.         // 发布HTML报告（如果有）
8.         publishHTML([
9.             allowMissing: false,
10.             alwaysLinkToLastBuild: true,
11.             keepAll: true,
12.             reportDir: 'target/site',
13.             reportFiles: 'index.html',
14.             reportName: 'HTML Report'
15.         ])
16.     }
17. }

复制代码

部署自动化

部署策略选择

常见的部署策略包括：

• 蓝绿部署
• 滚动部署
• 金丝雀发布
• 一次性部署

配置自动化部署

1. 添加部署阶段到Pipeline：

2. pipeline {
3.     agent any
4.    
5.     // 使用环境变量管理配置
6.     environment {
7.         DEPLOY_ENV = 'staging'
8.         DEPLOY_HOST = 'staging.example.com'
9.     }
10.    
11.     stages {
12.         // ... 之前的构建和测试阶段 ...
13.         
14.         stage('Deploy to Staging') {
15.             when {
16.                 branch 'main'
17.             }
18.             steps {
19.                 // 使用SSH部署
20.                 sshagent(['staging-server-credentials']) {
21.                     sh '''
22.                         scp target/*.jar user@${DEPLOY_HOST}:/opt/app/
23.                         ssh user@${DEPLOY_HOST} "cd /opt/app && ./deploy.sh"
24.                     '''
25.                 }
26.             }
27.         }
28.         
29.         stage('Deploy to Production') {
30.             when {
31.                 branch 'main'
32.                 // 可以添加手动确认
33.                 input {
34.                     message "Deploy to production?"
35.                     ok "Yes, deploy"
36.                 }
37.             }
38.             steps {
39.                 // 类似地，部署到生产环境
40.                 sshagent(['production-server-credentials']) {
41.                     sh '''
42.                         scp target/*.jar user@prod.example.com:/opt/app/
43.                         ssh user@prod.example.com "cd /opt/app && ./deploy.sh"
44.                     '''
45.                 }
46.             }
47.         }
48.     }
49. }

复制代码

1. 创建部署脚本示例（在目标服务器上）：

2. #!/bin/bash
3. # /opt/app/deploy.sh
5. APP_NAME="sample-ci-app"
6. APP_PID=$(pgrep -f $APP_NAME)
8. # 停止当前运行的应用
9. if [ -n "$APP_PID" ]; then
10.     kill $APP_PID
11.     sleep 5
12. fi
14. # 备份当前版本
15. if [ -f "$APP_NAME-current.jar" ]; then
16.     cp $APP_NAME-current.jar $APP_NAME-backup.jar
17. fi
19. # 部署新版本
20. mv $APP_NAME.jar $APP_NAME-current.jar
22. # 启动应用
23. nohup java -jar $APP_NAME-current.jar > app.log 2>&1 &
25. echo "Application deployed successfully"

复制代码

监控与通知

构建状态监控

1. 安装监控插件：Build Monitor ViewDashboard View
2. Build Monitor View
3. Dashboard View
4. 创建监控视图：在Jenkins主页点击”+“号添加新视图选择”Build Monitor View”或”Dashboard View”选择要监控的项目
5. 在Jenkins主页点击”+“号添加新视图
6. 选择”Build Monitor View”或”Dashboard View”
7. 选择要监控的项目

安装监控插件：

• Build Monitor View
• Dashboard View

创建监控视图：

• 在Jenkins主页点击”+“号添加新视图
• 选择”Build Monitor View”或”Dashboard View”
• 选择要监控的项目

通知机制配置

1. 配置邮件通知：进入”Manage Jenkins” > “Configure System”找到”Extended E-mail Notification”部分配置SMTP服务器和默认收件人
2. 进入”Manage Jenkins” > “Configure System”
3. 找到”Extended E-mail Notification”部分
4. 配置SMTP服务器和默认收件人
5. 在Pipeline中添加通知步骤：

配置邮件通知：

• 进入”Manage Jenkins” > “Configure System”
• 找到”Extended E-mail Notification”部分
• 配置SMTP服务器和默认收件人

在Pipeline中添加通知步骤：

2. pipeline {
3.     // ... 其他配置 ...
4.    
5.     post {
6.         success {
7.             emailext (
8.                 subject: "Build Success: ${env.JOB_NAME} - ${env.BUILD_NUMBER}",
9.                 body: """
10.                     Build successful for ${env.JOB_NAME} - ${env.BUILD_NUMBER}
11.                     
12.                     Build URL: ${env.BUILD_URL}
13.                 """,
14.                 to: "${env.CHANGE_AUTHOR_EMAIL}, dev-team@example.com"
15.             )
16.         }
17.         failure {
18.             emailext (
19.                 subject: "Build Failed: ${env.JOB_NAME} - ${env.BUILD_NUMBER}",
20.                 body: """
21.                     Build failed for ${env.JOB_NAME} - ${env.BUILD_NUMBER}
22.                     
23.                     Build URL: ${env.BUILD_URL}
24.                     
25.                     Check logs for details.
26.                 """,
27.                 to: "${env.CHANGE_AUTHOR_EMAIL}, dev-team@example.com"
28.             )
29.         }
30.         unstable {
31.             emailext (
32.                 subject: "Build Unstable: ${env.JOB_NAME} - ${env.BUILD_NUMBER}",
33.                 body: """
34.                     Build unstable for ${env.JOB_NAME} - ${env.BUILD_NUMBER}
35.                     
36.                     Build URL: ${env.BUILD_URL}
37.                     
38.                     Some tests failed. Check test reports.
39.                 """,
40.                 to: "${env.CHANGE_AUTHOR_EMAIL}, dev-team@example.com"
41.             )
42.         }
43.     }
44. }

复制代码

1. 配置其他通知方式（如Slack）：安装Slack Notification Plugin配置Slack集成在Pipeline中添加Slack通知步骤
2. 安装Slack Notification Plugin
3. 配置Slack集成
4. 在Pipeline中添加Slack通知步骤

• 安装Slack Notification Plugin
• 配置Slack集成
• 在Pipeline中添加Slack通知步骤

最佳实践和优化建议

Pipeline最佳实践

1. 使用共享库：创建公共函数库，避免重复代码在Jenkins中配置共享库
2. 创建公共函数库，避免重复代码
3. 在Jenkins中配置共享库
4. 参数化构建：使用参数控制构建流程示例：
5. 使用参数控制构建流程
6. 示例：

使用共享库：

• 创建公共函数库，避免重复代码
• 在Jenkins中配置共享库

参数化构建：

• 使用参数控制构建流程
• 示例：

2. pipeline {
3.     agent any
4.    
5.     parameters {
6.         choice(name: 'DEPLOY_ENV', choices: ['staging', 'production'], description: 'Select deployment environment')
7.         booleanParam(name: 'RUN_TESTS', defaultValue: true, description: 'Run tests?')
8.     }
9.    
10.     stages {
11.         stage('Build') {
12.             steps {
13.                 sh 'mvn clean package'
14.             }
15.         }
16.         stage('Test') {
17.             when {
18.                 expression { params.RUN_TESTS == true }
19.             }
20.             steps {
21.                 sh 'mvn test'
22.             }
23.         }
24.         stage('Deploy') {
25.             steps {
26.                 script {
27.                     if (params.DEPLOY_ENV == 'staging') {
28.                         // 部署到测试环境
29.                     } else {
30.                         // 部署到生产环境
31.                     }
32.                 }
33.             }
34.         }
35.     }
36. }

复制代码

1. 使用并行执行加速构建：

2. pipeline {
3.     agent any
4.    
5.     stages {
6.         stage('Build') {
7.             steps {
8.                 sh 'mvn clean compile'
9.             }
10.         }
11.         stage('Parallel Tests') {
12.             parallel {
13.                 stage('Unit Tests') {
14.                     steps {
15.                         sh 'mvn test'
16.                     }
17.                 }
18.                 stage('Integration Tests') {
19.                     steps {
20.                         sh 'mvn verify -DskipUnitTests'
21.                     }
22.                 }
23.             }
24.         }
25.     }
26. }

复制代码

性能优化

1. 使用Docker容器隔离构建环境：

2. pipeline {
3.     agent {
4.         docker {
5.             image 'maven:3.8.1-openjdk-11'
6.             args '-v $HOME/.m2:/root/.m2'
7.         }
8.     }
9.    
10.     stages {
11.         stage('Build') {
12.             steps {
13.                 sh 'mvn clean package'
14.             }
15.         }
16.         stage('Test') {
17.             steps {
18.                 sh 'mvn test'
19.             }
20.         }
21.     }
22. }

复制代码

1. 使用构建缓存和依赖管理：

2. pipeline {
3.     agent any
4.    
5.     options {
6.         timeout(time: 30, unit: 'MINUTES')
7.         retry(3)
8.     }
9.    
10.     stages {
11.         stage('Checkout') {
12.             steps {
13.                 checkout scm
14.             }
15.         }
16.         stage('Build') {
17.             steps {
18.                 // 使用Maven缓存
19.                 sh 'mvn -Dmaven.repo.local=$HOME/.m2/repository clean package'
20.             }
21.         }
22.     }
23. }

复制代码

安全性考虑

1. 使用凭证管理敏感信息：

2. pipeline {
3.     agent any
4.    
5.     environment {
6.         // 使用Jenkins凭证
7.         AWS_ACCESS_KEY_ID = credentials('aws-access-key-id')
8.         AWS_SECRET_ACCESS_KEY = credentials('aws-secret-access-key')
9.     }
10.    
11.     stages {
12.         stage('Deploy') {
13.             steps {
14.                 // 使用凭证进行部署
15.                 sh 'aws s3 cp target/*.jar s3://my-bucket/'
16.             }
17.         }
18.     }
19. }

复制代码

1. 限制构建权限：在Jenkins中配置基于角色的访问控制限制谁可以触发构建和修改配置
2. 在Jenkins中配置基于角色的访问控制
3. 限制谁可以触发构建和修改配置

• 在Jenkins中配置基于角色的访问控制
• 限制谁可以触发构建和修改配置

总结

本文详细介绍了在CentOS Stream上搭建持续集成环境的全过程，从环境准备到自动化测试的全流程指导。通过实施这些步骤，开发团队可以显著提升软件交付速度与质量。

关键要点包括：

1. 环境准备：正确安装和配置CentOS Stream系统及必要工具
2. 基础工具安装：包括Java、Git、Docker等关键组件
3. Jenkins配置：作为持续集成服务器的核心组件
4. 版本控制集成：实现代码变更与构建的自动化连接
5. 自动化构建：使用Maven等工具实现代码的自动编译和打包
6. 自动化测试：包括单元测试、集成测试和代码分析
7. 部署自动化：实现从构建到部署的全流程自动化
8. 监控与通知：确保团队及时了解构建和部署状态

通过遵循本文提供的指南和最佳实践，组织可以建立一个高效、可靠的持续集成环境，加速软件交付周期，提高产品质量，并减少集成问题。持续集成是一个持续改进的过程，随着团队需求的变化和技术的发展，不断优化和调整CI流程是保持竞争力的关键。