Rocky Linux 8.5部署Jenkins CI/CD流水线实战指南-代码聚汇网

Rocky Linux 8.5部署Jenkins CI/CD流水线实战指南

JenkinsCI/CDRocky Linux

|难度：普通|阅读约 40 分钟

1. 项目概述

在当今DevOps实践中，持续集成与持续交付(CI/CD)已成为软件开发的标准配置。作为最流行的开源自动化服务器，Jenkins凭借其强大的插件生态和灵活性，在企业级CI/CD流水线中占据主导地位。而Rocky Linux作为RHEL的替代发行版，以其稳定性和长期支持特性，正成为越来越多企业的服务器操作系统选择。

本文将详细记录在Rocky Linux 8.5系统上部署Jenkins并构建支持跨平台CI/CD自动化流水线的全过程，特别针对容器化构建场景进行优化配置。不同于简单的安装教程，我会分享在实际企业环境中部署时遇到的典型问题及解决方案，包括性能调优、安全加固和容器集成等实战经验。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 环境准备与基础安装

2.1 Rocky Linux 8.5系统配置

在开始Jenkins安装前，需要对操作系统进行必要的配置：

bash复制# 更新系统并安装基础工具
sudo dnf update -y
sudo dnf install -y vim wget curl git

# 配置防火墙(如果启用)
sudo firewall-cmd --permanent --add-port=8080/tcp
sudo firewall-cmd --reload

# 设置SELinux(建议保持启用但调整策略)
sudo setsebool -P httpd_can_network_connect 1

提示：生产环境中建议使用非root用户操作，通过sudo授权。本文为演示方便，部分命令可能直接使用root权限。

2.2 Java环境安装

Jenkins基于Java开发，需要先安装合适的JDK版本。推荐使用OpenJDK 11：

bash复制sudo dnf install -y java-11-openjdk-devel

# 验证安装
java -version

如果系统需要同时维护多个Java版本，可以使用alternatives工具管理：

bash复制sudo alternatives --config java

2.3 Jenkins安装与初始配置

Rocky Linux 8.5的默认仓库不包含Jenkins，需要先添加官方仓库：

bash复制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

安装LTS版本的Jenkins：

bash复制sudo dnf install -y jenkins

# 启动服务并设置开机自启
sudo systemctl enable --now jenkins

首次访问Jenkins需要解锁管理员账户：

bash复制sudo cat /var/lib/jenkins/secrets/initialAdminPassword

将输出的密码填入Web界面(http://your-server-ip:8080)，然后选择"安装推荐的插件"。

3. Jenkins核心配置优化

3.1 系统性能调优

默认安装的Jenkins可能不适合生产环境负载，需要进行以下优化：

JVM参数调整：

编辑/etc/sysconfig/jenkins文件，修改JENKINS_JAVA_OPTIONS：

bash复制JENKINS_JAVA_OPTIONS="-Djava.awt.headless=true -Xms2g -Xmx4g -XX:MaxRAMPercentage=70.0 -XX:+UseG1GC -XX:MaxGCPauseMillis=200"

参数说明：

-Xms2g -Xmx4g：设置JVM堆内存初始和最大值
-XX:MaxRAMPercentage：限制Jenkins使用的最大物理内存比例
-XX:+UseG1GC：使用G1垃圾收集器
-XX:MaxGCPauseMillis：目标最大GC停顿时间

调整系统限制：

编辑/etc/security/limits.conf，添加：

bash复制jenkins soft nofile 65536
jenkins hard nofile 65536
jenkins soft nproc 8192
jenkins hard nproc 16384

然后重启Jenkins服务生效：

bash复制sudo systemctl restart jenkins

3.2 安全加固配置

启用HTTPS：

使用Let's Encrypt获取免费SSL证书：

bash复制sudo dnf install -y certbot python3-certbot-apache
sudo certbot certonly --standalone -d your-domain.com

配置Jenkins使用SSL证书：

bash复制# 转换证书格式
sudo openssl pkcs12 -export -in /etc/letsencrypt/live/your-domain.com/fullchain.pem \
    -inkey /etc/letsencrypt/live/your-domain.com/privkey.pem \
    -out /var/lib/jenkins/jenkins.p12 -name jenkins -passout pass:yourpassword

# 修改Jenkins配置
sudo vi /etc/sysconfig/jenkins

添加以下内容：

bash复制JENKINS_HTTPS_KEYSTORE="/var/lib/jenkins/jenkins.p12"
JENKINS_HTTPS_KEYSTORE_PASSWORD="yourpassword"
JENKINS_HTTPS_PORT="8443"

配置身份验证：

建议使用Matrix-based security或Role-based Authorization Strategy插件实现细粒度权限控制。安装插件后：

创建不同的用户角色(如admin、developer、readonly)
为每个角色分配精确的权限
禁用匿名用户访问

定期备份策略：

安装ThinBackup插件，配置自动备份：

bash复制# 创建备份目录
sudo mkdir /var/jenkins_backups
sudo chown jenkins:jenkins /var/jenkins_backups

在Jenkins管理界面配置ThinBackup：

备份目录：/var/jenkins_backups
备份频率：每日
保留策略：保留最近7次完整备份

4. 容器化构建环境配置

4.1 Docker安装与集成

安装Docker CE：

bash复制sudo dnf config-manager --add-repo=https://download.docker.com/linux/centos/docker-ce.repo
sudo dnf install -y docker-ce docker-ce-cli containerd.io

# 启动服务
sudo systemctl enable --now docker

# 将Jenkins用户加入docker组
sudo usermod -aG docker jenkins

配置Docker守护进程：

编辑/etc/docker/daemon.json优化配置：

json复制{
  "exec-opts": ["native.cgroupdriver=systemd"],
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "100m",
    "max-file": "3"
  },
  "storage-driver": "overlay2",
  "registry-mirrors": ["https://registry-mirror.example.com"]
}

重启Docker生效：

bash复制sudo systemctl restart docker

4.2 Kubernetes集成(可选)

对于需要Kubernetes构建的场景，可以安装Kubernetes插件并配置：

安装kubectl：

bash复制cat <<EOF | sudo tee /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://packages.cloud.google.com/yum/repos/kubernetes-el7-\$basearch
enabled=1
gpgcheck=1
repo_gpgcheck=1
gpgkey=https://packages.cloud.google.com/yum/doc/yum-key.gpg https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg
EOF

sudo dnf install -y kubectl

配置kubeconfig：

将集群的kubeconfig文件复制到/var/lib/jenkins/.kube/config，并确保权限正确：

bash复制sudo mkdir -p /var/lib/jenkins/.kube
sudo cp ~/.kube/config /var/lib/jenkins/.kube/
sudo chown -R jenkins:jenkins /var/lib/jenkins/.kube

5. 构建跨平台CI/CD流水线

5.1 基础流水线配置

创建Pipeline项目：

新建Item → 选择Pipeline
在Pipeline部分选择"Pipeline script from SCM"
配置Git仓库地址和凭证
指定Jenkinsfile路径(默认为根目录下的Jenkinsfile)

示例Jenkinsfile：

groovy复制pipeline {
    agent any
    
    options {
        timeout(time: 30, unit: 'MINUTES')
        buildDiscarder(logRotator(numToKeepStr: '10'))
    }
    
    environment {
        DOCKER_REGISTRY = 'registry.example.com'
        PROJECT_NAME = 'my-app'
        VERSION = "${env.BUILD_NUMBER}"
    }
    
    stages {
        stage('Checkout') {
            steps {
                checkout scm
            }
        }
        
        stage('Build') {
            steps {
                script {
                    if (isUnix()) {
                        sh 'mvn clean package'
                    } else {
                        bat 'mvn clean package'
                    }
                }
            }
        }
        
        stage('Docker Build') {
            steps {
                script {
                    docker.build("${DOCKER_REGISTRY}/${PROJECT_NAME}:${VERSION}")
                }
            }
        }
        
        stage('Deploy') {
            when {
                branch 'production'
            }
            steps {
                script {
                    docker.withRegistry('https://${DOCKER_REGISTRY}', 'docker-registry-creds') {
                        docker.image("${DOCKER_REGISTRY}/${PROJECT_NAME}:${VERSION}").push()
                    }
                    
                    sshagent(['deploy-key']) {
                        sh "ssh -o StrictHostKeyChecking=no deploy@server.example.com \
                            'docker pull ${DOCKER_REGISTRY}/${PROJECT_NAME}:${VERSION} && \
                            docker-compose -f /opt/${PROJECT_NAME}/docker-compose.yml up -d'"
                    }
                }
            }
        }
    }
    
    post {
        always {
            junit '**/target/surefire-reports/*.xml'
            archiveArtifacts artifacts: '**/target/*.jar', fingerprint: true
            cleanWs()
        }
        failure {
            emailext body: '${DEFAULT_CONTENT}\n\n构建日志: ${BUILD_URL}console', 
                     subject: '构建失败: ${JOB_NAME} - ${BUILD_NUMBER}', 
                     to: 'dev-team@example.com'
        }
    }
}

5.2 多平台构建支持

对于需要支持多种操作系统/架构的场景，可以使用以下策略：

使用标签选择执行节点：

在Jenkins管理 → 节点管理中为不同平台的节点打标签，如：

linux-amd64
windows-amd64
macos-arm64

然后在Pipeline中指定agent：

groovy复制stage('Windows Build') {
    agent {
        label 'windows-amd64'
    }
    steps {
        bat 'msbuild MySolution.sln'
    }
}

多架构Docker构建：

使用Buildx插件构建多平台镜像：

groovy复制stage('Multi-arch Docker Build') {
    steps {
        script {
            docker.withRegistry('https://registry.example.com', 'docker-creds') {
                def image = docker.buildx(
                    name: "myapp",
                    buildArgs: [VERSION: "${env.BUILD_NUMBER}"],
                    platforms: "linux/amd64,linux/arm64"
                )
                image.push()
            }
        }
    }
}

5.3 高级优化技巧

并行执行阶段：

groovy复制stage('Parallel Tests') {
    parallel {
        stage('Unit Tests') {
            steps {
                sh 'mvn test'
            }
        }
        stage('Integration Tests') {
            steps {
                sh 'mvn verify -Pintegration'
            }
        }
    }
}

使用共享库减少重复代码：

创建共享库仓库，在Jenkins全局配置中定义：

code复制Global Pipeline Libraries
Name: company-libs
Default version: main
Retrieval method: Modern SCM
Source Code Management: Git
Project Repository: https://github.com/company/jenkins-shared-libs.git

然后在Jenkinsfile中使用：

groovy复制@Library('company-libs') _

pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                companyLibs.buildJavaApp()
            }
        }
    }
}

缓存依赖加速构建：

groovy复制stage('Build') {
    steps {
        script {
            // 缓存Maven依赖
            withMaven(
                maven: 'Maven 3.8.4',
                mavenLocalRepo: '.repository',
                options: [
                    artifactsPublisher(disabled: true),
                    junitPublisher(disabled: true)
                ]
            ) {
                sh 'mvn clean package'
            }
        }
    }
}

6. 监控与维护

6.1 Jenkins系统监控

安装Monitoring插件：

推荐安装以下插件：

Monitoring
Prometheus metrics
Build Monitor View

配置Prometheus监控：

编辑/etc/sysconfig/jenkins添加：

bash复制JAVA_OPTS="-Djenkins.metrics.prometheus.enabled=true \
           -Djenkins.metrics.prometheus.port=9936 \
           ${JAVA_OPTS}"

然后在Prometheus配置中添加job：

yaml复制scrape_configs:
  - job_name: 'jenkins'
    metrics_path: '/prometheus'
    static_configs:
      - targets: ['jenkins.example.com:9936']

6.2 流水线性能分析

使用Pipeline: Stage View插件和Blue Ocean可视化构建流程，识别瓶颈阶段。

对于复杂流水线，可以使用Timestamper插件记录各阶段耗时：

groovy复制pipeline {
    options {
        timestamps()
    }
    // ...
}

6.3 定期维护任务

清理旧构建：

配置项目级别的构建丢弃策略，或在系统级别设置：

code复制Jenkins管理 → 系统配置 → 构建丢弃策略

插件更新：

定期检查并更新插件，建议：

每月检查一次更新
先在测试环境验证
备份Jenkins home目录后再升级

磁盘空间监控：

设置监控告警，重点关注：

JENKINS_HOME目录
Docker存储目录
构建工作空间

7. 常见问题与解决方案

7.1 安装与配置问题

问题1：Jenkins启动失败，端口被占用

解决方案：

bash复制# 查找占用端口的进程
sudo ss -tulnp | grep 8080

# 如果确实冲突，可以修改Jenkins端口
sudo vi /etc/sysconfig/jenkins
# 修改JENKINS_PORT="8080"为其他端口

问题2：Docker命令执行权限不足

解决方案：

bash复制# 确保jenkins用户在docker组
sudo usermod -aG docker jenkins

# 重启服务
sudo systemctl restart jenkins docker

7.2 流水线执行问题

问题1：Git克隆失败，SSL证书问题

解决方案：
在Jenkins全局配置中，添加Git额外配置：

code复制git config --global http.sslVerify false

或者在Jenkinsfile中添加：

groovy复制stage('Checkout') {
    steps {
        git(
            url: 'https://github.com/user/repo.git',
            credentialsId: 'your-credentials',
            branch: 'main',
            extensions: [[
                $class: 'CloneOption',
                shallow: true,
                timeout: 10,
                noTags: true,
                reference: '',
                honorRefspec: true
            ]]
        )
    }
}

问题2：Maven构建内存不足

解决方案：
在Jenkinsfile中设置MAVEN_OPTS：

groovy复制environment {
    MAVEN_OPTS = '-Xmx2048m -XX:MaxRAMPercentage=70.0'
}

7.3 性能问题

问题1：Jenkins响应缓慢

优化建议：

增加JVM堆内存
减少同时运行的构建数量
使用轻量级执行器容器替代常驻节点
定期清理旧构建数据

问题2：Docker构建速度慢

优化建议：

使用多阶段构建减少最终镜像大小
合理利用构建缓存
配置本地registry mirror
使用BuildKit替代传统构建方式

dockerfile复制# syntax=docker/dockerfile:1.4
FROM --platform=$BUILDPLATFORM maven:3.8-jdk-11 AS build
# ...构建步骤...

FROM eclipse-temurin:11-jre
# ...仅复制必要的运行时文件...

8. 安全最佳实践

凭证管理：
- 使用Jenkins的Credentials插件集中管理敏感信息
- 为不同项目/团队划分凭证作用域
- 定期轮换密钥和凭证
流水线安全：
- 启用Script Security插件
- 在沙箱中运行不信任的Pipeline脚本
- 限制共享库的权限
容器安全：
- 使用非root用户运行容器
- 扫描镜像中的漏洞
- 限制容器权限

dockerfile复制FROM eclipse-temurin:11-jre

# 创建非root用户
RUN useradd -m myuser
USER myuser

# ...其他配置...

网络隔离：
- 将Jenkins服务器放在内部网络
- 使用跳板机访问构建节点
- 限制构建节点的出站连接

9. 扩展与集成

9.1 与代码仓库集成

GitLab集成示例：

安装GitLab插件
配置Webhook触发构建
在GitLab项目中设置：
- URL: http://jenkins.example.com/project/my-project
- Secret Token: (在Jenkins项目配置中生成)
- 触发事件: Push events, Merge Request events

GitHub Actions集成：

可以在GitHub Actions中触发Jenkins构建：

yaml复制name: Trigger Jenkins
on: [push]
jobs:
  trigger-jenkins:
    runs-on: ubuntu-latest
    steps:
      - name: Trigger Jenkins Build
        run: |
          curl -X POST \
            -u "jenkins-user:api-token" \
            "http://jenkins.example.com/job/my-job/build?token=TRIGGER_TOKEN"

9.2 通知与告警

Slack集成：

安装Slack Notification插件
配置全局Slack设置：
- Workspace: your-team.slack.com
- Credentials: Slack API token
- Default channel: #jenkins-notifications
在Pipeline中添加：

groovy复制post {
    success {
        slackSend(color: 'good', message: "构建成功: ${env.JOB_NAME} #${env.BUILD_NUMBER}")
    }
    failure {
        slackSend(color: 'danger', message: "构建失败: ${env.JOB_NAME} #${env.BUILD_NUMBER}")
    }
}

邮件通知优化：

使用Email Extension插件配置丰富的邮件模板：

groovy复制post {
    always {
        emailext(
            subject: '${PROJECT_NAME} - 构建 #${BUILD_NUMBER} - ${BUILD_STATUS}',
            body: '''${SCRIPT,template="groovy-html.template"}''',
            recipientProviders: [
                [$class: 'DevelopersRecipientProvider'],
                [$class: 'RequesterRecipientProvider']
            ],
            attachLog: true,
            compressLog: true
        )
    }
}

9.3 高级集成场景

与Kubernetes集群集成：

安装Kubernetes插件
配置Cloud:
- Kubernetes URL: https://k8s-api.example.com
- Namespace: jenkins
- Credentials: kubeconfig或ServiceAccount
使用Pod模板定义构建环境：

groovy复制pipeline {
    agent {
        kubernetes {
            label 'my-k8s-agent'
            yaml """
apiVersion: v1
kind: Pod
spec:
  containers:
  - name: jnlp
    image: jenkins/inbound-agent:4.3-4
  - name: maven
    image: maven:3.8-openjdk-11
    command: ['cat']
    tty: true
    volumeMounts:
    - name: maven-cache
      mountPath: /root/.m2
  volumes:
  - name: maven-cache
    emptyDir: {}
"""
        }
    }
    stages {
        stage('Build') {
            steps {
                container('maven') {
                    sh 'mvn clean package'
                }
            }
        }
    }
}

与Terraform集成实现基础设施即代码：

groovy复制stage('Provision Infrastructure') {
    steps {
        dir('terraform') {
            sh 'terraform init'
            sh 'terraform plan -out=tfplan'
            sh 'terraform apply -auto-approve tfplan'
            
            // 获取输出变量
            def endpoint = sh(script: 'terraform output -raw app_endpoint', returnStdout: true).trim()
            env.APP_ENDPOINT = endpoint
        }
    }
}

10. 性能调优实战经验

在实际企业环境中部署Jenkins时，我总结了以下性能优化经验：

构建节点策略：
- 静态节点用于稳定环境(如Docker、Kubernetes构建)
- 动态节点用于临时性任务(通过Kubernetes插件或EC2插件自动伸缩)
- 按团队/项目划分节点池，避免资源争抢
JVM调优参数：

对于大型Jenkins实例，推荐以下JVM参数：

bash复制JENKINS_JAVA_OPTIONS="-server \
-Xms4g -Xmx8g \
-XX:MaxRAMPercentage=70.0 \
-XX:+UseG1GC \
-XX:MaxGCPauseMillis=200 \
-XX:ParallelGCThreads=4 \
-XX:ConcGCThreads=2 \
-XX:+AlwaysPreTouch \
-XX:+UseStringDeduplication \
-XX:+DisableExplicitGC \
-XX:+HeapDumpOnOutOfMemoryError \
-XX:HeapDumpPath=/var/log/jenkins/heapdump.hprof \
-Djava.awt.headless=true \
-Djenkins.install.runSetupWizard=false"

数据库优化：
- 对于大型实例，考虑使用外部数据库(如PostgreSQL)替代默认的H2
- 定期执行VACUUM ANALYZE(PostgreSQL)或优化表(MySQL)
- 为常用查询添加适当索引
文件系统选择：
- 推荐使用XFS或ext4文件系统
- 避免使用NFS存储JENKINS_HOME
- 对于SSD存储，调整mount选项：
```
bash复制defaults,noatime,nodiratime,discard
```
分布式构建策略：
- 将构建任务分散到多个执行节点
- 使用标签匹配将特定任务路由到专用节点
- 设置节点使用策略(如只允许运行特定标签的任务)

日志管理：

配置日志轮转：

bash复制/var/log/jenkins/*.log {
    daily
    missingok
    rotate 7
    compress
    delaycompress
    notifempty
    create 0644 jenkins jenkins
}

对于长时间运行的流水线，定期归档日志

插件管理：
- 定期审计并移除未使用的插件
- 避免安装功能重叠的插件
- 关注插件更新，特别是安全补丁
网络优化：
- 为大型文件传输配置高速网络
- 设置代理缓存(如Nexus)减少外部依赖下载时间
- 优化Git克隆策略(浅克隆、稀疏检出)

通过以上优化，我们在生产环境中成功将Jenkins实例的构建能力提升了3倍，同时系统稳定性显著提高。