CentOS Stream与CI/CD流水线完美融合 打造高效自动化开发环境从代码提交到部署全流程解析

威震华夏关云长

1. 引言

在当今快速发展的软件开发领域，自动化已经成为提高效率、减少错误和加速产品上市的关键因素。持续集成/持续部署（CI/CD）流水线作为自动化的核心，正在被越来越多的开发团队所采用。与此同时，CentOS Stream作为RHEL的上游开发版本，为开发人员提供了一个稳定且前沿的平台。本文将详细解析如何将CentOS Stream与CI/CD流水线完美融合，打造一个高效的自动化开发环境，实现从代码提交到部署的全流程自动化。

2. CentOS Stream概述

2.1 什么是CentOS Stream

CentOS Stream是CentOS项目的一个版本，它是Red Hat Enterprise Linux (RHEL)的上游开发版本。与传统的CentOS不同，CentOS Stream不是RHEL的下游复制品，而是RHEL的未来版本的中转站。这意味着CentOS Stream的更新和补丁会比RHEL提前出现，使开发人员能够更早地接触到新功能和改进。

2.2 CentOS Stream的优势

1. 前沿技术：CentOS Stream提供了比传统CentOS更前沿的技术和功能，使开发人员能够提前适应和测试这些新特性。
2. 稳定性：尽管CentOS Stream包含较新的功能，但它仍然保持了CentOS的稳定性，适合生产环境使用。
3. RHEL兼容性：由于CentOS Stream是RHEL的上游，它与RHEL高度兼容，使得从开发到生产的过渡更加平滑。
4. 社区支持：CentOS Stream拥有活跃的社区支持，开发人员可以从中获得帮助和资源。

前沿技术：CentOS Stream提供了比传统CentOS更前沿的技术和功能，使开发人员能够提前适应和测试这些新特性。

稳定性：尽管CentOS Stream包含较新的功能，但它仍然保持了CentOS的稳定性，适合生产环境使用。

RHEL兼容性：由于CentOS Stream是RHEL的上游，它与RHEL高度兼容，使得从开发到生产的过渡更加平滑。

社区支持：CentOS Stream拥有活跃的社区支持，开发人员可以从中获得帮助和资源。

2.3 CentOS Stream与开发环境的契合性

CentOS Stream的特性使其成为构建开发环境的理想选择：

• 它提供了最新的软件包和工具，支持现代开发需求。
• 与RHEL的兼容性确保了开发环境与生产环境的一致性。
• 稳定性和安全性的平衡使其适合长期使用。

3. CI/CD基础

3.1 CI/CD概念解析

持续集成（Continuous Integration, CI）是一种开发实践，要求开发人员频繁地将代码集成到共享仓库中。每次代码提交后，自动构建和测试代码，以便及早发现和修复问题。

持续部署（Continuous Deployment, CD）是CI的延伸，它自动将通过所有测试的代码部署到生产环境中。这使得新功能可以快速、可靠地交付给用户。

3.2 CI/CD的重要性

1. 提高开发效率：自动化流程减少了手动操作，使开发人员能够专注于编码和创新。
2. 减少错误：自动化测试和部署减少了人为错误的可能性。
3. 快速反馈：开发人员可以迅速了解他们的更改是否引入了问题。
4. 持续交付：新功能和修复可以更快地交付给用户。
5. 一致性：自动化流程确保了每次部署的一致性，减少了”在我的机器上可以运行”的问题。

提高开发效率：自动化流程减少了手动操作，使开发人员能够专注于编码和创新。

减少错误：自动化测试和部署减少了人为错误的可能性。

快速反馈：开发人员可以迅速了解他们的更改是否引入了问题。

持续交付：新功能和修复可以更快地交付给用户。

一致性：自动化流程确保了每次部署的一致性，减少了”在我的机器上可以运行”的问题。

3.3 常见的CI/CD工具

1. Jenkins：一个开源的自动化服务器，支持构建、部署和自动化任何项目。
2. GitLab CI/CD：与GitLab集成的CI/CD工具，提供完整的DevOps生命周期支持。
3. GitHub Actions：GitHub的自动化工作流工具，可以直接在代码仓库中定义CI/CD流程。
4. Travis CI：一个基于云的CI服务，特别适合开源项目。
5. CircleCI：一个现代化的CI/CD平台，提供快速和可扩展的自动化。

Jenkins：一个开源的自动化服务器，支持构建、部署和自动化任何项目。

GitLab CI/CD：与GitLab集成的CI/CD工具，提供完整的DevOps生命周期支持。

GitHub Actions：GitHub的自动化工作流工具，可以直接在代码仓库中定义CI/CD流程。

Travis CI：一个基于云的CI服务，特别适合开源项目。

CircleCI：一个现代化的CI/CD平台，提供快速和可扩展的自动化。

4. 在CentOS Stream上搭建CI/CD环境

4.1 系统准备

首先，我们需要准备一个CentOS Stream系统。以下是在CentOS Stream上安装基本开发环境的步骤：

2. # 更新系统
3. sudo dnf update -y
5. # 安装基本开发工具
6. sudo dnf groupinstall "Development Tools" -y
8. # 安装额外的依赖
9. sudo dnf install -y git curl wget

复制代码

4.2 安装Docker

Docker是现代CI/CD流水线的重要组成部分，它提供了容器化环境，确保构建和测试的一致性。

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 start docker
8. sudo systemctl enable docker
10. # 将当前用户添加到docker组
11. sudo usermod -aG docker $USER
13. # 重新登录以应用组更改

复制代码

4.3 安装Jenkins

Jenkins是一个流行的CI/CD工具，我们将在CentOS Stream上安装它：

2. # 添加Jenkins仓库
3. sudo wget -O /etc/yum.repos.d/jenkins.repo https://pkg.jenkins.io/redhat-stable/jenkins.repo
4. sudo rpm --import https://pkg.jenkins.io/redhat-stable/jenkins.io.key
6. # 安装Java（Jenkins的依赖）
7. sudo dnf install -y java-11-openjdk
9. # 安装Jenkins
10. sudo dnf install -y jenkins
12. # 启动并启用Jenkins
13. sudo systemctl start jenkins
14. sudo systemctl enable jenkins
16. # 检查Jenkins状态
17. sudo systemctl status jenkins

复制代码

安装完成后，可以通过浏览器访问http://<服务器IP>:8080来配置Jenkins。初始管理员密码可以在/var/lib/jenkins/secrets/initialAdminPassword文件中找到。

4.4 安装GitLab Runner（可选）

如果你使用GitLab CI/CD，可以安装GitLab Runner：

2. # 添加GitLab仓库
3. curl -L https://packages.gitlab.com/install/repositories/runner/gitlab-runner/script.rpm.sh | sudo bash
5. # 安装GitLab Runner
6. sudo dnf install -y gitlab-runner
8. # 注册Runner
9. sudo gitlab-runner register

复制代码

在注册过程中，你需要提供GitLab实例的URL和注册令牌。

5. 从代码提交到部署的完整流程

5.1 代码仓库设置

首先，我们需要设置一个代码仓库。这里以GitLab为例：

1. 在GitLab上创建一个新项目。
2. 初始化本地仓库并推送到GitLab：

2. # 初始化本地仓库
3. mkdir my-project && cd my-project
4. git init
6. # 添加远程仓库
7. git remote add origin git@gitlab.com:username/my-project.git
9. # 创建初始文件
10. echo "# My Project" > README.md
12. # 提交并推送
13. git add .
14. git commit -m "Initial commit"
15. git push -u origin master

复制代码

5.2 创建CI/CD配置文件

在项目根目录创建.gitlab-ci.yml文件（对于GitLab CI/CD）或Jenkinsfile（对于Jenkins），定义CI/CD流水线。

以下是一个示例.gitlab-ci.yml文件：

2. # 定义阶段
3. stages:
4.   - build
5.   - test
6.   - deploy
8. # 构建阶段
9. build_job:
10.   stage: build
11.   image: centos:stream8
12.   script:
13.     - echo "Building the application..."
14.     - dnf install -y gcc make
15.     - make
16.   artifacts:
17.     paths:
18.       - build/
20. # 测试阶段
21. test_job:
22.   stage: test
23.   image: centos:stream8
24.   script:
25.     - echo "Running tests..."
26.     - dnf install -y python3-pip
27.     - pip3 install -r requirements.txt
28.     - python3 -m pytest tests/
29.   dependencies:
30.     - build_job
32. # 部署阶段
33. deploy_job:
34.   stage: deploy
35.   image: centos:stream8
36.   script:
37.     - echo "Deploying the application..."
38.     - dnf install -y rsync
39.     - rsync -avz build/ user@production-server:/var/www/my-app/
40.   only:
41.     - master
42.   dependencies:
43.     - test_job

复制代码

5.3 代码提交触发CI/CD

当代码被推送到仓库时，CI/CD流水线会自动触发。例如：

2. # 添加一些更改
3. echo "print('Hello, World!')" > app.py
5. # 提交并推送
6. git add app.py
7. git commit -m "Add main application file"
8. git push

复制代码

推送后，GitLab Runner会自动检测到更改并开始执行定义的流水线。

5.4 构建阶段详解

构建阶段通常包括以下步骤：

1. 环境准备：安装必要的依赖和工具。
2. 代码编译：将源代码编译成可执行文件或包。
3. 打包：将应用程序及其依赖打包成可部署的单元。

以下是一个更详细的构建脚本示例：

2. #!/bin/bash
4. # 更新系统
5. dnf update -y
7. # 安装构建依赖
8. dnf groupinstall -y "Development Tools"
9. dnf install -y python3 python3-pip
11. # 安装Python依赖
12. pip3 install -r requirements.txt
14. # 编译代码（如果需要）
15. python3 setup.py build
17. # 创建打包目录
18. mkdir -p build/dist
20. # 复制必要文件到打包目录
21. cp -r src/* build/dist/
22. cp requirements.txt build/dist/
24. # 创建可执行包
25. cd build/dist
26. tar -czf ../my-app.tar.gz .

复制代码

5.5 测试阶段详解

测试阶段确保代码的质量和功能正确性。常见的测试类型包括：

1. 单元测试：测试单个函数或组件。
2. 集成测试：测试多个组件之间的交互。
3. 端到端测试：模拟真实用户操作，测试整个应用程序。

以下是一个测试脚本示例：

2. #!/bin/bash
4. # 安装测试依赖
5. pip3 install pytest pytest-cov
7. # 运行单元测试
8. python3 -m pytest tests/unit/ --cov=src --cov-report=xml
10. # 运行集成测试
11. python3 -m pytest tests/integration/
13. # 生成测试报告
14. mkdir -p test-results
15. cp coverage.xml test-results/

复制代码

5.6 部署阶段详解

部署阶段将经过测试的应用程序部署到目标环境。这可能包括：

1. 准备目标环境：安装必要的依赖和配置。
2. 部署应用程序：将应用程序文件复制到目标服务器。
3. 配置服务：设置和启动应用程序服务。
4. 健康检查：验证应用程序是否正常运行。

以下是一个部署脚本示例：

2. #!/bin/bash
4. # 目标服务器配置
5. TARGET_SERVER="user@production-server"
6. TARGET_DIR="/var/www/my-app"
8. # 同步文件到目标服务器
9. rsync -avz --delete build/dist/ $TARGET_SERVER:$TARGET_DIR/
11. # 在目标服务器上执行部署命令
12. ssh $TARGET_SERVER << EOF
13.   # 进入目标目录
14.   cd $TARGET_DIR
15.   
16.   # 安装依赖
17.   pip3 install -r requirements.txt
18.   
19.   # 配置服务
20.   sudo cp my-app.service /etc/systemd/system/
21.   sudo systemctl daemon-reload
22.   sudo systemctl enable my-app
23.   sudo systemctl restart my-app
24.   
25.   # 健康检查
26.   curl -f http://localhost:8080/health || exit 1
27. EOF
29. echo "Deployment completed successfully!"

复制代码

6. 实际案例和最佳实践

6.1 案例：Web应用的CI/CD流水线

让我们通过一个实际的Web应用案例来展示CentOS Stream与CI/CD的完美融合。

假设我们有一个基于Flask的Web应用，项目结构如下：

2. my-web-app/
3. ├── app/
4. │   ├── __init__.py
5. │   ├── routes.py
6. │   └── templates/
7. │       └── index.html
8. ├── tests/
9. │   ├── test_routes.py
10. │   └── test_templates.py
11. ├── requirements.txt
12. ├── Dockerfile
13. ├── docker-compose.yml
14. └── .gitlab-ci.yml

复制代码

Dockerfile内容：

2. FROM centos:stream8
4. # 安装Python和pip
5. RUN dnf install -y python3 python3-pip && \
6.     dnf clean all
8. # 设置工作目录
9. WORKDIR /app
11. # 复制依赖文件并安装
12. COPY requirements.txt .
13. RUN pip3 install -r requirements.txt
15. # 复制应用代码
16. COPY . .
18. # 暴露端口
19. EXPOSE 5000
21. # 启动命令
22. CMD ["python3", "-m", "flask", "run", "--host=0.0.0.0"]

复制代码

docker-compose.yml内容：

2. version: '3'
3. services:
4.   web:
5.     build: .
6.     ports:
7.       - "5000:5000"
8.     environment:
9.       - FLASK_ENV=production
10.       - FLASK_APP=app
11.   db:
12.     image: centos/postgresql-12-centos7
13.     environment:
14.       - POSTGRESQL_USER=myuser
15.       - POSTGRESQL_PASSWORD=mypassword
16.       - POSTGRESQL_DATABASE=mydb
17.     volumes:
18.       - db-data:/var/lib/pgsql/data
19. volumes:
20.   db-data:

复制代码

.gitlab-ci.yml内容：

2. stages:
3.   - build
4.   - test
5.   - deploy
7. variables:
8.   DOCKER_DRIVER: overlay2
9.   DOCKER_TLS_CERTDIR: ""
11. services:
12.   - docker:dind
14. before_script:
15.   - docker info
17. build:
18.   stage: build
19.   script:
20.     - docker build -t my-web-app:$CI_COMMIT_SHA .
21.     - docker tag my-web-app:$CI_COMMIT_SHA my-web-app:latest
22.   artifacts:
23.     paths:
24.       - docker-images/
26. test:
27.   stage: test
28.   script:
29.     - docker load -i docker-images/my-web-app.tar
30.     - docker run --rm my-web-app:$CI_COMMIT_SHA python3 -m pytest tests/
31.   dependencies:
32.     - build
34. deploy_staging:
35.   stage: deploy
36.   script:
37.     - docker load -i docker-images/my-web-app.tar
38.     - echo "$DOCKER_PASSWORD" | docker login -u "$DOCKER_USERNAME" --password-stdin
39.     - docker tag my-web-app:$CI_COMMIT_SHA $DOCKER_USERNAME/my-web-app:staging
40.     - docker push $DOCKER_USERNAME/my-web-app:staging
41.     - ssh $STAGING_SERVER "docker pull $DOCKER_USERNAME/my-web-app:staging && docker-compose -f docker-compose.staging.yml up -d"
42.   environment:
43.     name: staging
44.     url: https://staging.example.com
45.   only:
46.     - master
47.   dependencies:
48.     - test
50. deploy_production:
51.   stage: deploy
52.   script:
53.     - docker load -i docker-images/my-web-app.tar
54.     - echo "$DOCKER_PASSWORD" | docker login -u "$DOCKER_USERNAME" --password-stdin
55.     - docker tag my-web-app:$CI_COMMIT_SHA $DOCKER_USERNAME/my-web-app:production
56.     - docker push $DOCKER_USERNAME/my-web-app:production
57.     - ssh $PRODUCTION_SERVER "docker pull $DOCKER_USERNAME/my-web-app:production && docker-compose -f docker-compose.production.yml up -d"
58.   environment:
59.     name: production
60.     url: https://example.com
61.   when: manual
62.   only:
63.     - master
64.   dependencies:
65.     - test

复制代码

1. 构建阶段：使用Docker构建应用镜像，并将其保存为工件。
2. 测试阶段：加载构建的Docker镜像，并在容器中运行测试。
3. 部署阶段：暂存环境：自动将应用部署到暂存环境，供测试和验证。生产环境：手动触发部署到生产环境，确保经过充分验证后才发布。
4. 暂存环境：自动将应用部署到暂存环境，供测试和验证。
5. 生产环境：手动触发部署到生产环境，确保经过充分验证后才发布。

构建阶段：使用Docker构建应用镜像，并将其保存为工件。

测试阶段：加载构建的Docker镜像，并在容器中运行测试。

部署阶段：

• 暂存环境：自动将应用部署到暂存环境，供测试和验证。
• 生产环境：手动触发部署到生产环境，确保经过充分验证后才发布。

6.2 最佳实践

1. 快速反馈：确保流水线执行速度快，以便开发人员能够快速获得反馈。
2. 并行执行：尽可能并行执行独立的任务，如不同类型的测试。
3. 失败快速：在流水线早期阶段捕获问题，避免浪费资源。
4. 环境一致性：使用容器确保开发、测试和生产环境的一致性。

快速反馈：确保流水线执行速度快，以便开发人员能够快速获得反馈。

并行执行：尽可能并行执行独立的任务，如不同类型的测试。

失败快速：在流水线早期阶段捕获问题，避免浪费资源。

环境一致性：使用容器确保开发、测试和生产环境的一致性。

1. 密钥管理：使用CI/CD工具的密钥管理功能，避免在代码中硬编码敏感信息。
2. 镜像扫描：在构建过程中扫描Docker镜像中的安全漏洞。
3. 访问控制：限制对生产环境的部署权限，实施审批流程。

密钥管理：使用CI/CD工具的密钥管理功能，避免在代码中硬编码敏感信息。

镜像扫描：在构建过程中扫描Docker镜像中的安全漏洞。

访问控制：限制对生产环境的部署权限，实施审批流程。

1. 缓存依赖：缓存构建依赖，避免每次都重新下载。
2. 增量构建：只构建和测试更改的部分，而不是整个项目。
3. 资源管理：合理分配CI/CD运行器的资源，避免资源浪费。

缓存依赖：缓存构建依赖，避免每次都重新下载。

增量构建：只构建和测试更改的部分，而不是整个项目。

资源管理：合理分配CI/CD运行器的资源，避免资源浪费。

7. 可能遇到的挑战和解决方案

7.1 挑战：环境不一致

问题描述：开发、测试和生产环境之间的差异可能导致”在我的机器上可以运行”的问题。

解决方案：

• 使用容器技术（如Docker）确保环境一致性。
• 在CI/CD流水线中使用与生产环境相同的操作系统和依赖版本。
• 实施基础设施即代码（IaC）实践，如使用Ansible或Terraform管理环境配置。

示例：使用Docker Compose定义开发环境：

2. version: '3'
3. services:
4.   app:
5.     build: .
6.     ports:
7.       - "5000:5000"
8.     environment:
9.       - FLASK_ENV=development
10.     volumes:
11.       - .:/app
12.   db:
13.     image: centos/postgresql-12-centos7
14.     environment:
15.       - POSTGRESQL_USER=devuser
16.       - POSTGRESQL_PASSWORD=devpassword
17.       - POSTGRESQL_DATABASE=devdb
18.     ports:
19.       - "5432:5432"

复制代码

7.2 挑战：流水线执行缓慢

问题描述：CI/CD流水线执行时间过长，影响开发效率。

解决方案：

• 实施并行测试，将测试套件分成多个并行运行的部分。
• 使用缓存机制，避免重复下载依赖或重新构建未更改的组件。
• 优化测试代码，移除不必要的测试或改进慢速测试。

示例：在GitLab CI中配置并行测试：

2. test:
3.   stage: test
4.   script:
5.     - pytest tests/ --split-by=file --chunks=4
6.   parallel: 4
7.   cache:
8.     paths:
9.       - .cache/pip/
10.       - venv/

复制代码

7.3 挑战：部署失败

问题描述：部署过程中出现错误，导致应用程序不可用。

解决方案：

• 实施蓝绿部署或金丝雀发布策略，减少部署风险。
• 添加回滚机制，在部署失败时快速恢复到之前的版本。
• 实施健康检查，确保部署后应用程序正常运行。

示例：蓝绿部署脚本：

2. #!/bin/bash
4. # 配置
5. BLUE_CONTAINER="my-app-blue"
6. GREEN_CONTAINER="my-app-green"
7. CURRENT_CONTAINER=$(docker ps --format "table {{.Names}}" | grep -E "(blue|green)" | head -n 1)
9. # 确定新容器颜色
10. if [ "$CURRENT_CONTAINER" = "$BLUE_CONTAINER" ]; then
11.   NEW_CONTAINER="$GREEN_CONTAINER"
12. else
13.   NEW_CONTAINER="$BLUE_CONTAINER"
14. fi
16. # 停止并删除旧容器（如果存在）
17. docker stop $NEW_CONTAINER 2>/dev/null || true
18. docker rm $NEW_CONTAINER 2>/dev/null || true
20. # 启动新容器
21. docker run -d --name $NEW_CONTAINER my-app:$IMAGE_TAG
23. # 健康检查
24. for i in {1..30}; do
25.   if curl -f http://localhost:5000/health; then
26.     echo "Health check passed"
27.     break
28.   fi
29.   echo "Waiting for health check..."
30.   sleep 2
31. done
33. # 如果健康检查失败，停止新容器并退出
34. if ! curl -f http://localhost:5000/health; then
35.   echo "Health check failed, rolling back"
36.   docker stop $NEW_CONTAINER
37.   exit 1
38. fi
40. # 切换流量到新容器
41. # 这里假设使用反向代理如Nginx
42. sed -i "s/$CURRENT_CONTAINER/$NEW_CONTAINER/g" /etc/nginx/conf.d/my-app.conf
43. nginx -s reload
45. # 停止旧容器
46. docker stop $CURRENT_CONTAINER
48. echo "Deployment completed successfully"

复制代码

7.4 挑战：资源限制

问题描述：CI/CD运行器资源不足，导致构建或测试失败。

解决方案：

• 监控资源使用情况，识别瓶颈。
• 根据需要扩展CI/CD基础设施，增加更多运行器或升级硬件。
• 优化流水线，减少资源密集型任务。

示例：使用Kubernetes扩展CI/CD运行器：

2. # gitlab-runner-deployment.yaml
3. apiVersion: apps/v1
4. kind: Deployment
5. metadata:
6.   name: gitlab-runner
7.   namespace: gitlab-runner
8. spec:
9.   replicas: 3  # 根据需要调整副本数量
10.   selector:
11.     matchLabels:
12.       app: gitlab-runner
13.   template:
14.     metadata:
15.       labels:
16.         app: gitlab-runner
17.     spec:
18.       containers:
19.       - args:
20.         - run
21.         image: gitlab/gitlab-runner:latest
22.         name: gitlab-runner
23.         resources:
24.           requests:
25.             memory: "256Mi"
26.             cpu: "250m"
27.           limits:
28.             memory: "512Mi"
29.             cpu: "500m"

复制代码

8. 结论与展望

8.1 总结

CentOS Stream与CI/CD流水线的融合为开发团队提供了一个强大、高效的自动化开发环境。通过本文的详细解析，我们了解了如何从代码提交到部署实现全流程自动化，包括：

1. 在CentOS Stream上搭建CI/CD环境的基本步骤。
2. 从代码提交到部署的完整流程解析。
3. 实际案例和最佳实践。
4. 常见挑战及其解决方案。

这种融合不仅提高了开发效率，还增强了软件质量和可靠性，使团队能够更快地响应市场需求。

8.2 未来展望

随着技术的不断发展，CentOS Stream与CI/CD的融合还有很大的发展空间：

1. AI辅助开发：将人工智能集成到CI/CD流水线中，自动检测代码问题、优化性能和安全性。
2. GitOps实践：进一步采用GitOps方法，将基础设施和应用程序配置完全版本化，实现更高级的自动化。
3. 多云部署：扩展CI/CD流水线，支持同时部署到多个云平台，提高灵活性和可靠性。
4. 边缘计算支持：适应边缘计算的需求，优化CI/CD流水线以支持分布式部署。

AI辅助开发：将人工智能集成到CI/CD流水线中，自动检测代码问题、优化性能和安全性。

GitOps实践：进一步采用GitOps方法，将基础设施和应用程序配置完全版本化，实现更高级的自动化。

多云部署：扩展CI/CD流水线，支持同时部署到多个云平台，提高灵活性和可靠性。

边缘计算支持：适应边缘计算的需求，优化CI/CD流水线以支持分布式部署。

通过持续创新和改进，CentOS Stream与CI/CD的融合将继续为开发团队提供更强大、更高效的自动化解决方案，推动软件开发向更高水平发展。

9. 参考资料

1. CentOS Stream官方文档:https://docs.centos.org/en-US/centos-stream/
2. GitLab CI/CD文档:https://docs.gitlab.com/ee/ci/
3. Jenkins用户手册:https://www.jenkins.io/doc/book/
4. Docker文档:https://docs.docker.com/
5. “Continuous Delivery” by Jez Humble and David Farley

版权声明

1、转载或引用本网站内容(CentOS Stream与CI/CD流水线完美融合 打造高效自动化开发环境从代码提交到部署全流程解析)须注明原网址及作者(威震华夏关云长)，并标明本网站网址(https://www.pixtech.cc/)。

2、对于不当转载或引用本网站内容而引起的民事纷争、行政处理或其他损失，本网站不承担责任。

3、对不遵守本声明或其他违法、恶意使用本网站内容者，本网站保留追究其法律责任的权利。

本文地址: https://www.pixtech.cc/thread-36813-1-1.html