零基础指南：在Linux上用Docker和Jenkins实现Spring Cloud微服务的CI/CD

零基础指南：在Linux上用Docker和Jenkins实现Spring Cloud微服务的CI/CD

这篇博客是为完全零基础的用户设计的。我们假设你已经在GitHub上有一个Spring Cloud微服务项目（例如https://github.com/TestXXXX/spring-cloud-demo），GitHub账号和密码都是TestXXXX。我将从在Linux服务器上用Docker安装Jenkins开始，一步步教你如何配置Jenkins、设置项目的pom.xml，并最终实现CI/CD（持续集成/持续部署）。我会尽量用简单的话解释每个步骤的目的。

---

前提条件

• 一台Linux服务器（比如Ubuntu，租一个云服务器即可）
• 你知道如何用终端输入命令（我会教你具体敲什么）
• Docker已经装好（如果没装，运行sudo apt update && sudo apt install docker.io -y）
• 一个Spring Cloud项目已经在GitHub上

---

第一步：在Linux服务器上用Docker安装Jenkins

1. 什么是Jenkins？

Jenkins是一个工具，帮助我们自动构建、测试和部署代码。就像一个机器人，帮你干重复的活。我们要用Docker（一个能打包软件的工具）把它跑起来。

2. 下载Jenkins

在Linux终端输入：

docker pull jenkins/jenkins:lts

• 这是在下载Jenkins的最新稳定版（LTS = Long Term Support）。
• 等几分钟，下载完后不会有太多提示，别担心。

3. 启动Jenkins

输入以下命令启动Jenkins：

docker run -d -p 8080:8080 -p 50000:50000 -v jenkins_home:/var/jenkins_home --name jenkins jenkins/jenkins:lts

• -d：让Jenkins在后台运行。
• -p 8080:8080：让Jenkins的网页能在8080端口访问。
• -p 50000:50000：Jenkins内部通信用的端口。
• -v jenkins_home:/var/jenkins_home：把Jenkins的设置保存在服务器上，不会因为重启丢失。
• --name jenkins：给这个容器取名叫"jenkins"。

运行后，输入docker ps检查，應該能看到"jenkins"在运行。

4. 访问Jenkins网页

• 在浏览器输入http://<你的服务器IP>:8080（比如http://192.168.1.100:8080）。

• 第一次打开会让你输入一个密码。回到终端，输入：

  docker exec jenkins cat /var/jenkins_home/secrets/initialAdminPassword

• 复制输出的长字符串，粘贴到网页，点击"Continue"。

5. 初始化Jenkins

• 网页会问你要装哪些插件，选"Install suggested plugins"（推荐插件），然后等几分钟。
• 安装完后，创建管理员账户：
  • 用户名：admin
  • 密码：TestXXXX
  • 确认密码：TestXXXX
  • 名字和邮箱随便填，比如"Admin"和"[email protected]"。
• 点击"Save and Finish"，然后"Start using Jenkins"。

现在Jenkins已经跑起来了！

---

第二步：配置Jenkins（详细版）

1. 为什么要配置Jenkins？

Jenkins默认啥也不会，我们得教它怎么用Java、Maven（构建工具）、GitHub和Docker来干活。

2. 安装插件

• 点击左边菜单"Manage Jenkins" > "Manage Plugins"。
• 点击"Available"标签，在搜索框输入以下插件名，勾选并点击"Install without restart"：
  • Maven Integration：让Jenkins能跑Maven命令。
  • Pipeline：支持写流水线脚本（自动化步骤）。
  • GitHub Integration：连接你的GitHub仓库。
  • Docker Pipeline：让Jenkins能造Docker镜像。
• 安装完后，点"Restart Jenkins when installation is complete"重启。

3. 配置工具（JDK、Maven、Docker）

• 点击"Manage Jenkins" > "Global Tool Configuration"。
• JDK ：
  • 找到"JDK"部分，点击"Add JDK"。
  • 名字填JDK11（Spring Cloud用Java 11）。
  • 勾选"Install automatically"，选版本"11.0.XX"（随便一个11开头版本）。
  • 点击"Save"。
• Maven ：
  • 找到"Maven"部分，点击"Add Maven"。
  • 名字填Maven3。
  • 勾选"Install automatically"，选版本"3.X.X"（最新就行）。
  • 点击"Save"。
• Docker ：
  • 不需要特别配置，但确保服务器能跑docker命令（输入docker --version试试，有输出就行）。

4. 添加GitHub凭据

• 点击"Manage Jenkins" > "Manage Credentials"。
• 点击"(global)"旁边的"Add Credentials"。
• 填入：
  • Kind：Username with password
  • Username：TestXXXX
  • Password：TestXXXX
  • ID：github-cred（记住这个ID，后面要用）
  • Description：GitHub Credentials
• 点击"OK"保存。

5. 添加Docker Hub凭据（可选）

• 如果你要推镜像到Docker Hub（一个存Docker镜像的地方），重复上面步骤：
  • Username：TestXXXX（你的Docker Hub账号）
  • Password：你的Docker Hub密码
  • ID：dockerhub-cred
  • Description：Docker Hub Credentials

---

第三步：配置Spring Cloud项目的pom.xml

1. pom.xml是干嘛的？

pom.xml是Maven的配置文件，告诉Maven怎么构建你的项目。它既给Jenkins用（跑构建命令），也给Docker用（生成镜像）。我们一步步来。

2. 示例pom.xml

假设你的项目叫user-service，在项目根目录创建或修改pom.xml：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <!-- 基本信息 -->
    <groupId>com.example</groupId>
    <artifactId>user-service</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <!-- 继承Spring Boot -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.5</version>
    </parent>

    <!-- 设置Java版本和Spring Cloud版本 -->
    <properties>
        <java.version>11</java.version>
        <spring-cloud.version>2021.0.4</spring-cloud.version>
        <docker.image.prefix>testxxxx</docker.image.prefix>
    </properties>

    <!-- 依赖：项目需要的库 -->
    <dependencies>
        <!-- Web功能 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- Eureka客户端（Spring Cloud微服务注册） -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <!-- 测试 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <!-- Spring Cloud版本管理 -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <!-- 构建配置 -->
    <build>
        <plugins>
            <!-- Spring Boot插件：打包成可运行的JAR -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <!-- Docker插件：生成和推送Docker镜像 -->
            <plugin>
                <groupId>com.spotify</groupId>
                <artifactId>dockerfile-maven-plugin</artifactId>
                <version>1.4.13</version>
                <executions>
                    <execution>
                        <id>default</id>
                        <goals>
                            <goal>build</goal>
                            <goal>push</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <repository>${docker.image.prefix}/${project.artifactId}</repository>
                    <tag>${project.version}</tag>
                    <buildArgs>
                        <JAR_FILE>${project.build.finalName}.jar</JAR_FILE>
                    </buildArgs>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

3. 每部分解释

• 基本信息 ：groupId、artifactId、version定义项目名称和版本。
• parent：继承Spring Boot，方便管理依赖。
• properties ：设置Java 11和Spring Cloud版本，docker.image.prefix是Docker镜像的前缀（用你的Docker Hub用户名）。
• dependencies：添加Web和Eureka功能（微服务注册）。
• plugins ：
  • spring-boot-maven-plugin：让Maven打包成JAR，给Jenkins用。
  • dockerfile-maven-plugin：让Maven生成Docker镜像，给Docker用。

4. 创建Dockerfile

在项目根目录创建Dockerfile（给Docker用，告诉它怎么打包你的JAR）：

FROM openjdk:11-jre-slim
ARG JAR_FILE
COPY target/${JAR_FILE} app.jar
ENTRYPOINT ["java", "-jar", "/app.jar"]

• FROM：用Java 11基础镜像。
• COPY：把Maven打包的JAR复制进去。
• ENTRYPOINT：运行JAR的命令。

---

第四步：创建Jenkins流水线

1. 什么是流水线？

流水线是Jenkins的自动化脚本，告诉它从GitHub拉代码、构建、生成镜像到部署的步骤。

2. 新建任务

• 在Jenkins首页，点击"New Item"。
• 输入名字spring-cloud-demo-pipeline，选"Pipeline"，点击"OK"。
• 在"Pipeline"部分，选"Pipeline script"。

3. 编写Jenkinsfile

在项目根目录创建Jenkinsfile：

pipeline {
    agent any
    tools {
        maven 'Maven3'
        jdk 'JDK11'
    }
    environment {
        DOCKERHUB_CREDENTIALS = credentials('dockerhub-cred')
    }
    stages {
        stage('Checkout') {
            steps {
                git branch: 'main', credentialsId: 'github-cred', url: 'https://github.com/TestXXXX/spring-cloud-demo.git'
            }
        }
        stage('Build') {
            steps {
                sh 'mvn clean package -DskipTests'
            }
        }
        stage('Build Docker Image') {
            steps {
                sh 'mvn dockerfile:build'
            }
        }
        stage('Push Docker Image') {
            steps {
                sh 'echo $DOCKERHUB_CREDENTIALS_PSW | docker login -u $DOCKERHUB_CREDENTIALS_USR --password-stdin'
                sh 'mvn dockerfile:push'
            }
        }
        stage('Deploy') {
            steps {
                sh 'docker stop user-service || true'
                sh 'docker rm user-service || true'
                sh 'docker run -d --name user-service -p 8081:8080 testxxxx/user-service:0.0.1-SNAPSHOT'
            }
        }
    }
    post {
        always {
            sh 'docker logout'
        }
    }
}

4. 每部分解释

• agent any：用任何可用节点运行。
• tools：用我们配置的Maven和JDK。
• environment：加载Docker Hub凭据。
• stages ：
  • Checkout：从GitHub拉代码。
  • Build：用Maven打包JAR。
  • Build Docker Image：生成Docker镜像。
  • Push Docker Image：推到Docker Hub。
  • Deploy：在服务器上跑镜像。

---

第五步：运行和测试

1. 把pom.xml、Dockerfile、Jenkinsfile上传到GitHub。
2. 在Jenkins中，打开spring-cloud-demo-pipeline，点击"Build Now"。
3. 查看"Console Output"，确保每步都成功。
4. 在浏览器访问http://<服务器IP>:8081，看服务是否跑起来。

---

小白常见问题

• Jenkins打不开 ：检查服务器防火墙（sudo ufw allow 8080）。
• 构建失败：看日志，可能缺依赖或凭据不对。
• Docker命令不行 ：确保Jenkins容器能用宿主机的Docker（加--userns=host重跑容器试试）。

恭喜你！现在你已经学会从零配置CI/CD了！