# 在云服务器上安装与使用Jenkins（基于 CentOS Stream 9）

大家好，我是汪小成。

前言

本文记录了在 CentOS Stream 9（基于 RHEL 9）云服务器 上，从零安装 Jenkins、配置运行环境、到创建流水线并构建项目的完整流程。

如果你也在云服务器上部署微服务项目，可以直接参考本教程完成一套可复用的 CI 流水线。

整体流程示意图

先用一张流程图看一下整个过程的大致步骤：

一、环境准备

1. SSH 登录云服务器并查看系统版本

如果你已经知道操作系统版本，可以跳过本小节。

使用 SSH 登录云服务器后，执行以下命令查看系统版本：

cat /etc/os-release

参考输出：

NAME="CentOS Stream"
VERSION="9"
ID="centos"
ID_LIKE="rhel fedora"
VERSION_ID="9"
PLATFORM_ID="platform:el9"
PRETTY_NAME="CentOS Stream 9"
ANSI_COLOR="0;31"
LOGO="fedora-logo-icon"
CPE_NAME="cpe:/o:centos:centos:9"
HOME_URL="https://centos.org/"
BUG_REPORT_URL="https://bugzilla.redhat.com/"
REDHAT_SUPPORT_PRODUCT="Red Hat Enterprise Linux 9"
REDHAT_SUPPORT_PRODUCT_VERSION="CentOS Stream"

可以确认当前系统为 CentOS Stream 9（基于 RHEL9）。

2. 检查是否已安装 JDK

Jenkins 运行依赖 Java 环境，这里检查是否已经安装 JDK：

java -version

示例输出：

openjdk version "17.0.16" 2025-07-15 LTS
OpenJDK Runtime Environment (Red_Hat-17.0.16.0.8-1) (build 17.0.16+8-LTS)
OpenJDK 64-Bit Server VM (Red_Hat-17.0.16.0.8-1) (build 17.0.16+8-LTS, mixed mode, sharing)

从上面的输出可以看到云服务器已安装 OpenJDK 17 。

如果没有安装，可根据系统版本自行先安装 JDK（例如 dnf install java-17-openjdk）。

3. 检查内存与磁盘空间

Jenkins 对服务器配置有一定要求，建议：

• 内存 ≥ 2GB
• 磁盘 ≥ 10GB

查看内存大小

free -h

示例输出：

               total        used        free      shared  buff/cache   available
Mem:           7.7Gi       5.0Gi       316Mi       1.6Gi       4.3Gi       2.7Gi
Swap:             0B          0B          0B

查看磁盘空间

df -h

示例输出：

Filesystem      Size  Used Avail Use% Mounted on
devtmpfs        4.0M     0  4.0M   0% /dev
tmpfs           3.9G     0  3.9G   0% /dev/shm
tmpfs           1.6G   79M  1.5G   6% /run
/dev/vda2        40G   15G   24G  38% /
/dev/vda1       200M  7.5M  193M   4% /boot/efi
tmpfs           787M     0  787M   0% /run/user/0

确认可用空间满足 Jenkins 运行需求即可。

二、安装 Jenkins

1. 添加 Jenkins 仓库与导入密钥

在 CentOS/RHEL 系统上通过官方仓库安装 Jenkins：

sudo wget -O /etc/yum.repos.d/jenkins.repo \
  https://pkg.jenkins.io/redhat/jenkins.repo

sudo rpm --import https://pkg.jenkins.io/redhat/jenkins.io-2023.key

2. 安装 Jenkins

sudo dnf install -y jenkins

3. 启动 Jenkins 并设置为开机自启

# 设置开机自启
sudo systemctl enable jenkins

# 启动 Jenkins
sudo systemctl start jenkins

# 查看 Jenkins 状态
sudo systemctl status jenkins

如果状态为 active (running) 则说明 Jenkins 已经成功启动。

4. 首次登录与初始化配置

默认情况下，Jenkins 会监听 8080 端口。在浏览器中访问：

http://你的服务器公网IP:8080

进入初始密码输入界面：

在云服务器终端中执行以下命令获取初始管理员密码：

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

复制该密码，粘贴到浏览器页面中，按照向导完成：

1. 选择 "安装推荐插件"
2. 安装完成后，创建第一个管理员账号
3. 保存配置并进入 Jenkins 主界面

5. 修改 Jenkins 端口号

如果服务器上 8080 端口已被占用，可以通过编辑 systemd 单元文件修改 Jenkins 端口。

Jenkins 在 RHEL/CentOS 上通常通过 systemd 配置端口，默认单元文件路径为：

/usr/lib/systemd/system/jenkins.service

查看当前端口配置：

sudo cat /usr/lib/systemd/system/jenkins.service | grep -n JENKINS

输出中可以看到类似内容：

Environment="JENKINS_PORT=8080"

编辑该文件，将 8080 改为希望使用的端口号（例如 9090），保存并退出，然后执行：

sudo systemctl daemon-reload
sudo systemctl restart jenkins

⚠️ 别忘了在云厂商控制台的安全组中放行新端口，否则外网无法访问 Jenkins。

三、安装 Git 与 Maven

在云服务器上安装 Git 和 Maven（供 Jenkins 使用）：

sudo dnf install -y git maven

安装完成后，检查版本：

git --version
mvn --version

能正常输出版本信息即可。

四、在 Jenkins 中配置 JDK 与 Maven

在 Jenkins 页面中，点击右上角的 "系统管理" 图标，然后进入 "全局工具配置"：

进入后可以看到 JDK、Git、Maven 等工具的配置项：

1. 配置 JDK

找到 JDK 区域：

1. 取消勾选 "自动安装"
2. 输入一个易于识别的 名称/别名 （例如 jdk17）
3. 在 JAVA_HOME 中填入 Java 安装目录

如果不确定 JDK 安装路径，可以在终端中执行：

readlink -f $(which java)

示例输出：

/usr/lib/jvm/java-17-openjdk-17.0.16.0.8-2.el9.x86_64/bin/java

则 JAVA_HOME 应填写为去掉 /bin/java 之后的部分：

/usr/lib/jvm/java-17-openjdk-17.0.16.0.8-2.el9.x86_64

2. 配置 Maven

在同一页面找到 Maven 区域：

1. 取消勾选 "自动安装"
2. 填写一个 Name（例如 maven-3）
3. 在 MAVEN_HOME 中填写本机 Maven 安装目录，例如：

/usr/share/maven

配置完成后点击页面底部的 "保存" 按钮。

五、配置 Jenkins 拉取代码（SSH Key）

为了让 Jenkins 以 jenkins 用户身份从 Git 平台（GitHub/Gitee 等）拉取代码，需要为 jenkins 用户配置 SSH Key。

1. 切换到 jenkins 用户并生成 SSH Key：

# 切换到 jenkins 用户
sudo su - jenkins

# 生成 SSH Key（请将邮箱改为你自己的）
ssh-keygen -t rsa -b 4096 -C "your_email@example.com"

一路回车即可（使用默认路径和空密码）。

2. 查看并复制公钥内容：

cat ~/.ssh/id_rsa.pub

复制输出的整行内容。

3. 将公钥添加到你的 Git 平台：

• GitHub：Settings → SSH and GPG keys → New SSH key
• Gitee：设置 → SSH 公钥

4. 在云服务器上测试 SSH 是否配置成功：

# GitHub
ssh -T git@github.com

# 或 Gitee
ssh -T git@gitee.com

如果能看到欢迎提示就说明 SSH 通了，Jenkins 也可以通过 SSH 拉取代码。

---

六、项目目录结构说明

假设所有微服务统一部署在服务器的 /ruoyi 根目录下，每个微服务独占一个子目录，便于统一管理和发布。

以 system 模块为例：

• 模块根目录：/ruoyi/system
• 日志目录：/ruoyi/system/logs
• Jar 包路径：/ruoyi/system/ruoyi-system.jar
• 管理脚本：/ruoyi/system/manage-ruoyi-system.sh

完整目录结构示例：

system
├── logs
│   ├── ruoyi-system
│   │   ├── console.log
│   │   ├── error.log
│   │   └── info.log
│   └── ruoyi-system.out
├── manage-ruoyi-system.sh
├── ruoyi-system.jar
└── ruoyi-system.pid

建议所有服务都遵守类似的目录约定，这样在 Jenkins 脚本中就可以用统一的路径规则进行部署与重启。

七、为 jenkins 用户分配项目目录权限

为避免每次构建都使用 root 权限，推荐将项目目录的所有者改为 jenkins 用户。

使用 root 用户执行：

sudo chown -R jenkins:jenkins /ruoyi
sudo chmod -R u+rwX /ruoyi

这样 Jenkins 在构建、打包、覆盖 Jar 包、写日志等操作时就不会因为权限问题失败。

八、新建 Jenkins 流水线任务

1. 创建任务

1. 在 Jenkins 首页点击 "新建任务"
2. 输入任务名称（例如：ruoyi-system-pipeline）
3. 选择 "流水线（Pipeline）" 类型
4. 点击 "确定"，进入任务配置页面

2. 配置任务参数与流水线脚本

进入任务配置页面后，按以下步骤配置：

1. 任务描述

   在「描述」中简单说明该流水线的用途，例如：

   负责 ruoyi-system 模块的拉取、打包与部署。

2. 参数化构建过程

   勾选 "参数化构建过程" ，点击 "添加参数" → 选择 "选项参数"：

   

   例如可以配置发布环境参数：

   • 名称：PROFILE

   • 选项（每行一个）：

     dev
     prod

   • 描述：选择要部署的环境（默认 dev）

   注意：第一行选项为默认值。

   

3. 编写流水线脚本（Pipeline Script）

   在「流水线」一栏中填入你的 Pipeline 脚本，例如从 Git 拉取代码、使用 Maven 打包、将 Jar 部署到 /ruoyi/system 并通过脚本重启服务等（这里根据你的实际脚本自行填写）。

   // 声明式 Pipeline
   pipeline {
       // 使用任意可用的节点（也可以写成 agent { label 'xxx' } 指定构建机）
       agent any
   
       // 声明 Jenkins 里配置好的 JDK 和 Maven 工具
       tools {
           // 在 "全局工具配置" 中配置一个名称为 jdk17 的 JDK，指向 Java 17
           jdk   'jdk17'
           // 在 "全局工具配置" 中配置一个名称为 maven-3 的 Maven
           maven 'maven-3.6.3'
       }
   
       // 一些全局选项，可选
       options {
           // 在控制台日志中显示时间戳，方便排查问题
           timestamps()
           // 保留最近 10 次构建记录（视情况可调整）
           buildDiscarder(logRotator(numToKeepStr: '10'))
       }
   
       // 全局环境变量
       environment {
           // 应用部署目录
           APP_DIR  = '/ruoyi/system'
           // 目标 Jar 名称（部署后文件名）
           JAR_NAME = 'ruoyi-system.jar'
           // 从项目根目录到构建出的 Jar 的相对路径
           JAR_REL_PATH = 'ruoyi-modules/ruoyi-system/target/ruoyi-system.jar'
       }
   
       stages {
   
           stage('Checkout 代码') {
               steps {
                   script {
                       // 说明：
                       // 1. credentialsId 请改成你在 Jenkins 中创建的 SSH 凭据 ID（例如 codeup-ssh）
                       // 2. branch 熟悉仓库后可改成实际分支（如 master、main、dev 等）
                       git branch: '2.X',
                           url: 'git@codeup.aliyun.com:xxxxxxxx/xxxxx/xxx.git',
                           credentialsId: 'codeup-ssh'
                   }
               }
           }
   
           stage('Build 编译打包（从项目根目录）') {
               steps {
                   dir("${env.WORKSPACE}") {
                       sh '''
                           echo "===== 从项目根目录执行 Maven clean install ====="
                           export MAVEN_OPTS="-Xms512m -Xmx1024m"
                           # 1. 清理并构建整个工程
                           mvn clean package -DskipTests -Pdev
   
                           echo "===== clean package 完成，所有父 POM/模块已安装到本地 ====="
   
                           # 2. 如果你只想重新打包某个模块，也可以单独再跑一遍（可选）
                           # mvn -pl ruoyi-modules/ruoyi-system -am clean package -DskipTests
                       '''
                   }
               }
           }
   
           stage('Deploy 部署 ruoyi-system') {
               steps {
                   sh '''
                       set -e  # 任意命令失败则整个脚本失败
   
                       echo "===== 部署阶段环境自检 ====="
                       echo "当前用户：$(whoami)"
                       echo "当前目录：$(pwd)"
                       echo "Jenkins 认为的 APP_DIR=${APP_DIR}"
                       echo "WORKSPACE=${WORKSPACE}"
                       
                       # 关键：让后面启动的 Java 进程"不属于这个 Build"
                       export BUILD_ID=dontKillMe
   
                       echo "===== 检查构建产物是否存在 ====="
                       JAR_SRC="${JAR_REL_PATH}"
                       APP_DIR="${APP_DIR}"
                       JAR_NAME="${JAR_NAME}"
                       JAR_DEST="${APP_DIR}/${JAR_NAME}"
   
                       echo "JAR_SRC=${JAR_SRC}"
                       echo "JAR_DEST=${JAR_DEST}"
   
                       if [ ! -f "$JAR_SRC" ]; then
                       echo "ERROR: 构建产物不存在：$JAR_SRC"
                       exit 1
                       fi
   
                       echo "构建产物存在：$JAR_SRC"
   
                       echo "===== 创建 / 确认部署目录：$APP_DIR ====="
                       mkdir -p "$APP_DIR"
   
                       echo "===== 拷贝 Jar 到部署目录 ====="
                       cp "$JAR_SRC" "$JAR_DEST"
                       ls -l "$JAR_DEST"
   
                       echo "===== 切换到 APP_DIR 并执行重启脚本 ====="
                       cd "$APP_DIR"
                       echo "现在目录：$(pwd)"
                       ls -l
   
                       echo "调用 manage-ruoyi-system.sh restart ..."
                       /ruoyi/system/manage-ruoyi-system.sh restart || {
                       echo "manage-ruoyi-system.sh restart 退出码 $?"
                       echo "最近 50 行业务日志："
                       tail -n 50 logs/ruoyi-system.out || echo "日志文件不存在"
                       exit 1
                       }
   
                       echo "===== restart 调用结束，立即查看 status 和进程 ====="
                       /ruoyi/system/manage-ruoyi-system.sh status || true
   
                       if [ -f ruoyi-system.pid ]; then
                       echo "PID 文件内容：$(cat ruoyi-system.pid)"
                       ps -p "$(cat ruoyi-system.pid)" -o pid,user,cmd || echo "ps 查不到这个 PID"
                       else
                       echo "PID 文件不存在"
                       fi
   
                       echo "===== 部署阶段结束 ====="
                   '''
               }
           }
   
       }
   
       // 构建后的一些收尾操作（可选）
       post {
           success {
               echo '构建 & 部署成功 🎉'
           }
           failure {
               echo '构建或部署失败，请查看控制台日志排查问题。'
           }
           always {
               // 这里可以做一些通用收尾，如归档日志等
               echo 'Pipeline 结束。'
           }
       }
   }

4. 配置完成后，点击页面底部的 "保存" 按钮。

九、构建项目（参数化构建）

完成任务配置后就可以开始构建项目了：

1. 在 Jenkins 首页的任务列表中点击对应任务名称，进入任务详情页面。
2. 点击左侧的 "Build with Parameters（带参数构建）"。
3. 在参数页面选择对应的参数（例如环境 dev/prod），然后点击 "Build" 按钮发起一次构建。

构建成功后，你就拥有了一条可反复使用的自动化构建流水线，可以根据参数灵活切换不同环境，非常适合多模块、多环境的微服务项目。

到这里，一套从 云服务器准备 → 安装 Jenkins → 配置工具和 SSH → 规范项目目录 → 创建流水线 → 参数化构建 的完整流程就打通了，你可以在此基础上继续扩展更多自动化步骤。