【无标题】

Jenkins 自动化部署 Spring Boot + Vue3 项目完整教程

本文详细介绍如何使用 Jenkins 实现 Spring Boot 后端 + Vue3 前端项目的自动化构建与部署，从零开始配置，适合初学者。

一、环境准备

1.1 Jenkins 服务器环境

• JDK 8 或 11
• Maven 3.8+
• Node.js 18+
• pnpm
• Git

1.2 部署服务器环境

• JDK 8
• Nginx
• MySQL 8
• Redis

1.3 代码仓库

• Gitee 账号及项目仓库

二、安装 Jenkins（原生方式）

2.1 macOS 安装

# 使用 Homebrew 安装
brew install jenkins-lts

# 启动 Jenkins
brew services start jenkins-lts

2.2 Ubuntu/Debian 安装

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

# 安装
sudo apt update
sudo apt install jenkins

# 启动
sudo systemctl start jenkins
sudo systemctl enable jenkins

2.3 CentOS/RHEL 安装

# 添加 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

# 安装
sudo yum install jenkins

# 启动
sudo systemctl start jenkins
sudo systemctl enable jenkins

2.4 获取初始密码

# macOS
cat /Users/$(whoami)/.jenkins/secrets/initialAdminPassword

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

2.5 访问 Jenkins

浏览器打开 http://localhost:8080，输入初始密码，按提示安装推荐插件。

三、安装依赖环境

Jenkins 原生安装后，可以直接使用本机的 Maven、Node.js 等工具。

3.1 安装 JDK 8

macOS：

brew install openjdk@8
# 或使用 Amazon Corretto
brew install --cask corretto8

Ubuntu：

sudo apt install openjdk-8-jdk

验证安装：

java -version
echo $JAVA_HOME

3.2 安装 Maven

macOS：

brew install maven

Ubuntu：

sudo apt install maven

验证安装：

mvn -version

3.3 安装 Node.js 和 pnpm

macOS：

brew install node@18
npm install -g pnpm

Ubuntu：

curl -fsSL https://deb.nodesource.com/setup_18.x | sudo -E bash -
sudo apt install nodejs
npm install -g pnpm

验证安装：

node -v
pnpm -v

四、安装 Jenkins 插件

进入 Manage Jenkins → Plugins → Available plugins，搜索并安装：

插件名称	用途
Git	Git 代码拉取
Pipeline	流水线支持
NodeJS	Node.js 环境
Gitee	Gitee 仓库集成
SSH Agent	SSH 远程部署
Publish Over SSH	SSH 文件传输

安装完成后重启 Jenkins。

五、全局工具配置

进入 Manage Jenkins → Tools

5.1 配置 JDK

1. 找到 JDK 安装 部分
2. 点击「新增 JDK」
3. 填写：
   • 别名：JDK8
   • 取消勾选「自动安装」
   • JAVA_HOME：填写本机 JDK 路径

查看 JDK 路径：

# macOS
/usr/libexec/java_home -V

# Linux
update-alternatives --list java

常见路径：

• macOS：/Library/Java/JavaVirtualMachines/corretto-1.8.0_xxx/Contents/Home
• Ubuntu：/usr/lib/jvm/java-8-openjdk-amd64

5.2 配置 Maven

1. 找到 Maven 安装 部分
2. 点击「新增 Maven」
3. 填写：
   • Name：Maven-3.8
   • 取消勾选「自动安装」
   • MAVEN_HOME：填写本机 Maven 路径

查看 Maven 路径：

mvn -version
# 或
which mvn

常见路径：

• macOS (Homebrew)：/opt/homebrew/opt/maven
• Ubuntu：/usr/share/maven

5.3 配置 NodeJS

1. 找到 NodeJS 安装 部分
2. 点击「新增 NodeJS」
3. 填写：
   • Name：Node-18
   • 取消勾选「自动安装」
   • Installation directory：填写本机 Node.js 路径

查看 Node.js 路径：

which node
# 去掉 /bin/node，取父目录

常见路径：

• macOS (Homebrew)：/opt/homebrew/opt/node@18
• Ubuntu：/usr

5.4 配置 Git

保持默认配置即可：

• Name：Default
• Path to Git executable：git

点击「保存」。

六、配置凭据

进入 Manage Jenkins → Credentials → System → 全局凭据 → Add Credentials

6.1 添加 Gitee 凭据

用于拉取代码：

• 类型：Username with password
• 用户名：Gitee 登录用户名（手机号或邮箱）
• 密码：Gitee 私人令牌（不是登录密码！）
• ID：gitee-credentials
• 描述：Gitee 仓库凭据

获取 Gitee 私人令牌：

1. 打开 https://gitee.com/profile/personal_access_tokens
2. 点击「生成新令牌」
3. 勾选 projects 权限
4. 复制生成的令牌

6.2 添加 SSH 部署密钥

用于连接部署服务器：

• 类型：SSH Username with private key
• ID：deploy-ssh-key
• 用户名：root
• Private Key：选择「Enter directly」，粘贴 SSH 私钥
• Passphrase：留空（如果私钥没有密码）

生成 SSH 密钥：

ssh-keygen -t rsa -b 4096
cat ~/.ssh/id_rsa      # 私钥，填到 Jenkins
cat ~/.ssh/id_rsa.pub  # 公钥，添加到服务器

6.3 服务器添加公钥

在部署服务器上执行：

mkdir -p ~/.ssh
chmod 700 ~/.ssh
echo "你的公钥内容" >> ~/.ssh/authorized_keys
chmod 600 ~/.ssh/authorized_keys

七、配置 Gitee 连接

进入 Manage Jenkins → System ，找到 Gitee 配置：

1. 勾选「开启 gitee-project 接口验证」
2. 点击「新增」Gitee 链接：
   • 链接名：gitee
   • Gitee 域名网址：https://gitee.com
   • 证书令牌：点击「+」添加 Gitee API Token

添加 Gitee API Token

• 类型：Gitee API Token
• Gitee APIV5 私人令牌：粘贴你的私人令牌
• ID：gitee-api-token

八、配置 SSH Server（可选）

进入 Manage Jenkins → System ，找到 Publish over SSH：

1. 在 Key 部分粘贴 SSH 私钥
2. 点击「新增」SSH Server：
   • Name：deploy-server
   • Hostname：服务器 IP 地址
   • Username：root
   • Remote Directory：/opt/fruit-mall

九、创建 Jenkinsfile

在项目根目录创建 Jenkinsfile：

pipeline {
    agent any

    environment {
        // Gitee 仓库
        GIT_REPO = 'https://gitee.com/你的用户名/你的仓库.git'
        DEPLOY_BRANCH = 'main'

        // 部署服务器配置
        DEPLOY_SERVER = '你的服务器IP'
        DEPLOY_USER = 'root'
        DEPLOY_PATH = '/opt/fruit-mall'

        // 应用配置
        APP_NAME = 'yudao-server'
        APP_PORT = '40080'
    }

    tools {
        maven 'Maven-3.8'
        nodejs 'Node-18'
    }

    options {
        buildDiscarder(logRotator(numToKeepStr: '10'))
        timeout(time: 30, unit: 'MINUTES')
        disableConcurrentBuilds()
    }

    stages {
        stage('拉取代码') {
            steps {
                echo "从 Gitee 拉取代码..."
                git branch: "${DEPLOY_BRANCH}",
                    credentialsId: 'gitee-credentials',
                    url: "${GIT_REPO}"
            }
        }

        stage('编译后端') {
            steps {
                echo '编译 Spring Boot 后端...'
                sh 'mvn clean package -Dmaven.test.skip=true -T 2C'
            }
            post {
                success {
                    archiveArtifacts artifacts: 'yudao-server/target/*.jar', fingerprint: true
                }
            }
        }

        stage('编译前端') {
            steps {
                echo '编译 Vue3 前端...'
                dir('yudao-ui-admin-vue3-master') {
                    sh '''
                        pnpm install || npm install
                        pnpm run build:prod || pnpm run build || npm run build
                    '''
                }
            }
        }

        stage('部署后端') {
            steps {
                echo '部署后端服务...'
                sshagent(['deploy-ssh-key']) {
                    sh '''
                        # 创建部署目录
                        ssh ${DEPLOY_USER}@${DEPLOY_SERVER} "mkdir -p ${DEPLOY_PATH}/backend"

                        # 上传 JAR 包
                        scp yudao-server/target/yudao-server.jar ${DEPLOY_USER}@${DEPLOY_SERVER}:${DEPLOY_PATH}/backend/

                        # 重启服务
                        ssh ${DEPLOY_USER}@${DEPLOY_SERVER} << 'EOF'
                            cd /opt/fruit-mall/backend

                            # 停止旧进程
                            PID=$(pgrep -f "yudao-server.jar" || true)
                            if [ -n "$PID" ]; then
                                echo "停止旧进程: $PID"
                                kill -15 $PID
                                sleep 5
                            fi

                            # 启动新进程
                            nohup java -Xms512m -Xmx512m \
                                -jar yudao-server.jar \
                                --spring.profiles.active=prod \
                                > app.log 2>&1 &

                            echo "后端服务已启动，PID: $!"
EOF
                    '''
                }
            }
        }

        stage('部署前端') {
            steps {
                echo '部署前端静态文件...'
                sshagent(['deploy-ssh-key']) {
                    sh '''
                        # 查找构建产物目录
                        DIST_DIR=""
                        for dir in "dist-prod" "dist" "build"; do
                            if [ -d "yudao-ui-admin-vue3-master/$dir" ]; then
                                DIST_DIR="yudao-ui-admin-vue3-master/$dir"
                                break
                            fi
                        done

                        if [ -z "$DIST_DIR" ]; then
                            echo "错误：未找到前端构建产物"
                            exit 1
                        fi

                        # 上传到 Nginx 目录
                        ssh ${DEPLOY_USER}@${DEPLOY_SERVER} "mkdir -p /usr/share/nginx/html"
                        rsync -avz --delete ${DIST_DIR}/ ${DEPLOY_USER}@${DEPLOY_SERVER}:/usr/share/nginx/html/

                        # 重载 Nginx
                        ssh ${DEPLOY_USER}@${DEPLOY_SERVER} "nginx -s reload || systemctl reload nginx"
                    '''
                }
            }
        }

        stage('健康检查') {
            steps {
                echo '检查服务状态...'
                script {
                    def maxRetries = 12
                    def healthy = false

                    for (int i = 1; i <= maxRetries; i++) {
                        try {
                            sh "curl -sf http://${DEPLOY_SERVER}:${APP_PORT}/actuator/health"
                            healthy = true
                            echo '✅ 后端服务健康检查通过！'
                            break
                        } catch (Exception e) {
                            echo "等待服务启动... (${i}/${maxRetries})"
                            sleep 10
                        }
                    }

                    if (!healthy) {
                        error '❌ 服务健康检查失败！'
                    }
                }
            }
        }
    }

    post {
        success {
            echo '✅ 部署成功！'
        }
        failure {
            echo '❌ 部署失败！'
        }
        always {
            cleanWs()
        }
    }
}

将 Jenkinsfile 推送到 Gitee 仓库：

git add Jenkinsfile
git commit -m "添加 Jenkins 流水线配置"
git push origin main

十、创建 Jenkins 任务

10.1 新建任务

1. 点击「新建 Item」
2. 输入任务名称：fruit-mall
3. 选择「流水线 (Pipeline)」
4. 点击确定

10.2 配置 General

• Gitee 链接：选择之前配置的 Gitee 连接
• 不允许并发构建：勾选
• 丢弃旧的构建：勾选，保留最近 10 次

10.3 配置 Triggers

• Gitee webhook 触发构建 ：勾选
  • 推送代码：勾选
  • 新建 Pull Requests：勾选

10.4 配置流水线

• 定义 ：Pipeline script from SCM
• SCM ：Git
• Repository URL ：https://gitee.com/你的用户名/你的仓库.git
• Credentials ：选择 gitee-credentials
• Branches to build ：*/main
• 脚本路径 ：Jenkinsfile

点击「保存」。

十一、配置 Gitee Webhook（可选）

如果 Jenkins 部署在公网服务器上，可以配置 Webhook 实现自动触发：

1. 进入 Gitee 仓库 → 管理 → WebHooks
2. 添加 WebHook：
   • URL：http://你的Jenkins地址:8080/gitee-project/fruit-mall
   • 触发事件：Push、Pull Request

十二、运行构建

1. 进入任务页面
2. 点击「立即构建」
3. 点击构建记录查看「控制台输出」

构建流程

拉取代码 → 编译后端(Maven) → 编译前端(pnpm) → 部署后端(SSH) → 部署前端(rsync) → 健康检查

十三、服务器 Nginx 配置

在部署服务器上配置 Nginx：

sudo vim /etc/nginx/conf.d/fruit-mall.conf

server {
    listen 80;
    server_name _;

    # 前端静态文件
    location / {
        root /usr/share/nginx/html;
        index index.html;
        try_files $uri $uri/ /index.html;
    }

    # 后端 API 代理
    location /admin-api/ {
        proxy_pass http://127.0.0.1:40080/admin-api/;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }

    location /app-api/ {
        proxy_pass http://127.0.0.1:40080/app-api/;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

sudo nginx -t
sudo systemctl reload nginx

十四、常见问题

Q1: 无法连接 Gitee 仓库

错误 ：Authentication failed

解决：

• 确认使用的是 Gitee 私人令牌，不是登录密码
• 检查用户名是否正确（手机号或邮箱）

Q2: 找不到 Jenkinsfile

错误 ：No flow definition

解决：

• 确认 Jenkinsfile 已推送到仓库
• 检查分支名称是否正确（main 或 master）
• 检查脚本路径是否正确

Q3: 工具名称不匹配

错误 ：Tool type "maven" does not have an install of "xxx" configured

解决：

• Jenkinsfile 中的工具名称必须与 Jenkins 全局工具配置中的名称一致

Q4: 找不到 mvn 或 node 命令

错误 ：mvn: command not found

解决：

• 检查全局工具配置中的路径是否正确
• 确认本机已安装对应工具
• 检查 Jenkins 用户是否有权限访问这些工具

Q5: SSH 连接失败

解决：

• 确认公钥已添加到服务器 ~/.ssh/authorized_keys
• 确认私钥已正确配置到 Jenkins 凭据
• 检查服务器防火墙是否开放 22 端口
• 测试 SSH 连接：ssh root@服务器IP

Q6: Jenkins 启动失败

解决：

# 查看日志
# macOS
cat ~/Library/Logs/Jenkins/jenkins.log

# Linux
sudo journalctl -u jenkins

十五、总结

通过本教程，我们实现了：

1. ✅ 原生安装 Jenkins（非 Docker）
2. ✅ 使用本机 Maven、NodeJS、Git 工具
3. ✅ 配置 Gitee 和 SSH 凭据
4. ✅ 创建 Pipeline 流水线任务
5. ✅ 自动化构建和部署 Spring Boot + Vue3 项目

原生安装 vs Docker 安装

对比项	原生安装	Docker 安装
工具访问	直接使用本机工具	需要挂载或容器内安装
配置复杂度	较低	较高
环境隔离	无	完全隔离
迁移难度	较高	较低

对于开发环境，推荐使用原生安装，可以直接复用本机已有的开发工具。

---

作者：你的名字

如果本文对你有帮助，欢迎点赞收藏！