黑马头条Day12-项目部署

一、今日内容介绍

1. 什么是持续集成

持续集成（Continuous integration，简称CI），指的是频繁地（一天多次）将代码集成到主干。

持续集成的组成要素：

一个自动构建过程，从检出代码、编译构建、运行测试、结果记录、测试统计等都是自动完成的，无需人工干预。
一个代码存储库，即需要版本控制软件来保障代码的可维护性，同时作为构建过程的素材库，一般使用SVN或Git。
一个持续集成服务器，Jenkins就是一个配置简单和使用方便的持续集成服务器。

2. 持续集成的好处

1. 降低风险，由于持续集成不断去构建、编译和测试，可以很早期发现问题，所以修复的代价就少；
2. 对系统健康持续检查，减少发布风险带来的问题；
3. 减少重复性工作；
4. 持续部署，提供可部署单元包；
5. 持续交付可供使用的版本；
6. 增强团队信心；

3. 今日内容

二、软件开发模式

1. 软件开发生命周期

软件开发生命周期又叫SDLC（Software Development Life Cycle），它是集合了计划、开发、测试和部署过程的集合。如下图所示：

需求分析

这是生命周期的第一阶段，根据项目需求，团队执行一个可行性计划的分析。项目需求可能是公司内部或者客户提出的。这个阶段主要是对信息的收集，也有可能是对现有项目的改善和重新做一个新的项目。还要分析项目的预算多长，可以从哪方面收益及布局，这也是项目创建的目标。

设计

第二阶段就是设计阶段，系统架构和满意状态（就是要做成什么样子，有什么功能），和创建一个项目计划。计划可以使用图表，布局设计或文字的方式呈现。

实现

第三阶段就是实现阶段，项目经理创建和分配工作给开发者，开发者根据任务和设计阶段定义的目标进行代码开发。依据项目的大小和复杂程度，可能需要数月或更长时间才能完成。

测试

测试人员进行代码测试，包括功能测试、代码测试、压力测试等。

进化

最后进阶阶段就是对产品不断的进化改进和维护阶段，根据用户的使用情况，可能需要对某功能进行修改，bug修复，功能增加等。

2. 软件开发瀑布模型

瀑布模型是最著名和最常使用的软件开发模型。瀑布模型就是一系列的软件开发过程。它是由制造业繁衍出来的。一个高度化的结构流程在一个方向上流动，有点像生产线一样。在瀑布模型创建之初，没有其他开发的模型，有很多东西全靠开发人员去猜测，去开发。这样的模型仅适用于那些简单的软件开发，但是已经不适合现在的开发了。

下图对软件开发模型的一个阐述

优势	劣势
简单易用和理解	各个阶段的划分完全固定，阶段之间产生大量的文档，极大地增加了工作量
当前一阶段完成后，您只需要去关注后续阶段	由于开发模型是线性的，用户只有等到整个过程的末期才能见到开发成果，从而增加了开发风险
为项目提供了按阶段划分的检查节点	瀑布模型的突出缺点是不适应用户需求的变化

3. 软件的敏捷开发

什么是敏捷开发？

敏捷开发（Agile Development）的核心是迭代开发（Iterative Development）与增量开发。

何为迭代开发？

对于大型软件项目，传统的开发方式是采用一个大周期（比如一年）进行开发，整个过程就是一次“大开发”；迭代开发的方式则不一样，它将开发过程拆分为多个周期，即一次“大开发”变成多次“小开发”，每次小开发都是同样的流程，所以看上去就好像重复在做同样的步骤。

举例来说，SpaceX公司想造一个大推力火箭，将人类送到火星。但是，它不是一开始就造火箭，而是先造一个最简陋的小火煎Falcon 1。结果，第一次发射就爆炸了，直到第四次发射，才成功进入诡道。然后，开发了中型火箭Falcon 9，九年中发射了70次。最后，才开发Falcon重型火箭。如果SpaceX不采用迭代开发，它可能直到现在还无法上天。

何为增量开发？

软件的每个版本，都会新增一个用户可以感知的完整功能。也就是说，安装新增功能来划分迭代。

举例来说，房产公司开发一个10栋楼的小区。如果采用增量开发的模式，该公司第一个迭代就是交付一号楼，第二个迭代交付二号楼......每个迭代都是完成一栋完整的楼。而不是第一个迭代挖好10栋楼的地基，第二个迭代建好每栋楼的骨架，第三个迭代架设屋顶......

敏捷开发如何迭代？

虽然敏捷开发将软件开发分成多个迭代，但是也要求，每次迭代都是一个完整的软件开发周期，必须按照软件工程的方法论，进行正规的流程管理。

敏捷开发有什么好处？

早期交付

敏捷开发的第一个好处，就是早期交付，从而大大降低成本。还是以上一节的房产公司为例，如果按照传统的“瀑布开发模式”，先挖10栋楼的地基、再盖骨架、然后架设屋顶，每个阶段都等到前一个阶段完成后开始，可能需要两年才能一次性交付10栋楼。也就是说，如果不考虑预售，该项目必须等到两年后才能回款。敏捷开发是6个月后交付一号楼，后面每两个月交付一栋楼。因此，半年就能回款10%，后面是每个月都会有现金流，资金压力就大大减轻了。

降低风险

敏捷开发的第二个好处是，及时了解市场需求，降低产品不适用的风险。请想一想，哪一种情况损失比较小：10栋楼都造好以后，才发现卖不出去，还是造好第一栋楼，就发现卖不出去，从而改进或停建后面9栋楼？

三、Jenkins安装配置

1. Jenkins介绍

Jenkins是一款流行的开源持续集成（Continuous Integration）工具，广泛用于项目开发，具有自动化构建、测试和部署等功能。官网：Jenkins

Jenkins的特征：

开源的Java语言开发持续集成工具，支持持续集成，持续部署；
易于安装部署配置：可以通过yum安装，或者下载war包以及通过docker容器等快速实现安装部署，可方便web界面配置管理；
消息通知及测试报告：集成RSS/E-mail通过RSS发布构建结果或当构建完成时通过email通知，生成JUnit/TestNG测试报告；
分布式构建：支持Jenkins能够让多台计算机一起构建/测试；
文件识别：Jenkins能够跟踪哪次构建生成哪些jar，哪次构建使用哪个版本的jar等；
丰富的插件支持：支持扩展插件，可以开发适合自己团队使用的工具，如git、svn、maven、docker等

Jenkins安装和持续集成环境配置

1）首先，开发人员每天进行代码提交，提交到Git仓库

2）然后，Jenkins作为持续集成工具，使用Git工具到Git仓库拉取代码到集成服务器，再配置JDK、Maven等软件完成代码编译、代码测试与审查、测试、打包等工作，在这个过程中，每一步出错，都重新再执行一次整个流程

3）最后，Jenkins把生成的jar或war包发布测试服务器或者生产服务器，测试人员或用户就可以访问应用

2. Jenkins环境搭建

2.1 Jenkins安装配置

步骤①：导入资料中提供的镜像，启动虚拟机

服务器用户名：root 密码：itcast ，固定IP：192.168.200.100

当前镜像已经安装了jenkins，访问地址：http://192.168.200.100:16060

jenkins用户名：itcast 密码：itcast

安装步骤：

（1）采用YUM方式安装

①：加入Jenkins安装源

sudo wget -O /etc/yum.repos.d/jenkins.repo https://pkg.jenkins.io/redhat-stable/jenkins.repo --no-check-certificate

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

②执行yum命令安装

yum -y install jenkins

（2）采用RPM安装包方式

①Jenkins安装包下载地址：https://pkg.jenkins.io/redhat-stable/

wget https://pkg.jenkins.io/redhat-stable/jenkins-2.190.1-1.1.noarch.rpm

②执行安装

rpm -ivh jenkins-2.190.1-1.1.noarch.rpm

（3）配置

①修改配置文件

vi /etc/sysconfig/jenkins

②修改内容

# 修改为对应的目标用户， 这里使用的是root
$JENKINS_USER="root"
# 服务监听端口
JENKINS_PORT="16060"

③目录权限

chown -R root:root /var/lib/jenkins
chown -R root:root /var/cache/jenkins
chown -R root:root /var/log/jenkins

④重启

systemctl restart jenkins

如果启动失败，出现错误信息：

Starting Jenkins bash: /usr/bin/java: No such file or directory

创建JAVA环境的软链接：

ln -s /usr/local/jdk/bin/java /usr/bin/java

⑤管理后台初始化设置

http://192.168.200.100:16060/

需要输入管理密码，在以下位置查看：

cat /var/lib/jenkins/secrets/initialAdminPassword

按默认配置，把建议的插件都安装上

这一步等待时间较长，安装完成之后，创建管理员用户：

配置访问地址：

配置完成之后，会进行重启，之后可以看到管理后台：

2.2 Jenkins插件安装

在实现持续集成之前，需要确保以下插件安装成功

Maven Integration pugin：Maven集成管理插件
Docker plugin：Docker集成插件
GitLab plugin：GitLab集成插件
Publish Over SSH：远程文件发布插件
SSH：远程脚本执行插件

安装方法：

①进入【系统管理】- 【插件管理】

②点击标签页的【可选插件】，在过滤框中搜索插件名称

③勾选插件，点击直接安装即可

注意，如果没有安装按钮，需要更改配置。在安装插件的高级配种中，修改升级站点的连接为：http://updates.jenkins.io/update-center.json保存

2.3 Git安装配置

（1）yum安装方式

yum -y install git

（2）采用源码包方式安装

①安装依赖包

yum -y install curl-devel expat-devel gettext-devel openssl-devel zlib-devel
yum -y install gcc perl-ExtUtils-MakeMaker

如果之前有安装旧版本，先做卸载，没有安装则忽略

yum remove git

②下载源码包

cd /usr/local
wget https://mirrors.edge.kernel.org/pub/software/scm/git/git-1.8.3.1.tar.gz
tar -xvf git-1.8.3.1.tar.gz

也可以安装其他版本，地址：Index of /pub/software/scm/git/

③编译安装

cd git-1.8.3.1
make prefix=/usr/local/git all
make prefix=/usr/local/git install
echo "export PATH=$PATH:/usr/local/git/bin" >> /etc/bashrc
source /etc/bashrc

④检查git版本

git version

2.4 Maven安装配置

①下载安装包，上传到 /usr/local/maven目录下

下载地址： Maven – Download Apache Maven

②解压安装包

cd /usr/local/maven
unzip -o apache-maven-3.6.1.zip

③上传本地仓库并解压

④配置

配置环境变量

vi /etc/profile

增加如下内容：

export MAVEN_HOME=/usr/local/maven/apache-maven-3.6.1
export PATH=$PATH:$MAVEN_HOME/bin

如果权限不够，则需要增加当前目录的权限

chmod 777 /usr/local/maven/apache-maven-3.6.1/bin/mvn

修改镜像仓库配置：

vi /usr/local/maven/apache-maven-3.6.1/conf/settings.xml

需要把本机的仓库打包上传到服务器上（不上传会自动下载），然后指定上传后的仓库配置

2.5 Docker安装配置

步骤①：更新软件包版本

yum -y update

②卸载旧版本

yum -y remove docker  docker-common docker-selinux docker-engine

③安装软件依赖包

yum install -y yum-utils device-mapper-persistent-data lvm2

④设置yum源为阿里云

sudo yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

⑤安装后查看docker版本

docker -v

⑥启动

设置开机启动

systemctl enable docker

启动docker

systemctl start docker

3. Jenkins工具配置

步骤①：进入【系统管理】 -> 【全局工具配置】

步骤②：MAVEN配置全局配置

步骤③：指定JDK配置

步骤④：指定MAVEN目录

步骤⑤：指定DOCKER目录

步骤⑥：指定Git目录

四、后端项目部署

1. 多环境切换

在项目开发部署的过程中，一般都会有三套项目环境

Development：开发环境

Production：生产环境

Test：测试环境

例如：开发环境的mysql连接的是本地，生产环境需要连接线上的mysql环境

2. 多环境切换 - 微服务中多环境配置

步骤①：在微服务中的bootstrap.yml中新增配置

server:
  port: 51801
spring:
  application:
    name: leadnews-user
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.200.130:8848
      config:
        server-addr: 192.168.200.130:8848
        file-extension: yml
  profiles:
    active: dev

步骤②：在nacos的配置中心轴新增各个环境的配置文件，例如user微服务中新增

创建对应的nacos的多环境配置：

leadnews-user-dev.yml

spring:
  redis:
    host: 192.168.200.130
    password: leadnews
    port: 6379
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/leadnews_user?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC&useSSL=false
    username: root
    password: root
# 设置Mapper接口所对应的XML文件位置，如果你在Mapper接口中有自定义方法，需要进行该配置
mybatis-plus:
  mapper-locations: classpath*:mapper/*.xml
  # 设置别名包扫描路径，通过该属性可以给包中的类注册别名
  type-aliases-package: com.heima.model.user.pojos

leadnews-user-prod.yml

spring:
  redis:
    host: 192.168.200.130
    password: leadnews
    port: 6379
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://192.168.200.130:3306/leadnews_user?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC&useSSL=false
    username: root
    password: root
# 设置Mapper接口所对应的XML文件位置，如果你在Mapper接口中有自定义方法，需要进行该配置
mybatis-plus:
  mapper-locations: classpath*:mapper/*.xml
  # 设置别名包扫描路径，通过该属性可以给包中的类注册别名
  type-aliases-package: com.heima.model.user.pojos

注意事项：

其中DataID属性命名有规范：

prefix，默认使用${spring.application.name}，也可也通过spring.cloud.nacos.config.prefix来配置；
spring.profile.active，即为当前环境对应的profile，详情可以参考Spring Boot 文档。注意：当spring.profile.active为空时，对应的连接符-也将不存在，dataId的拼接格式变成${prefix}.${file-extension}
file-extension，为配置内容的数据格式，可以通过配置项spring.cloud.nacos.config.file-extension来配置。目前只支持properties和yaml类型。

3. 整体思路

目标：把黑马头条的app端相关的微服务部署到192.168.200.100这台服务器上

步骤①：创建gitee仓库，把本地的heima-leadnews项目提交到远程仓库

4. 服务集成Docker配置

目标：部署的每一个微服务都是先创建docker镜像后创建对应容器启动

方式一：本地微服务打包以后上传到服务器，编写Dockerfile文件完成

方式二：使用dockerfile-maven-plugin插件，可以直接把微服务创建为镜像使用（更省事）

每个微服务都引入该依赖，以heima-leadnews-user微服务为例

<?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">
    <parent>
        <artifactId>heima-leadnews-service</artifactId>
        <groupId>com.heima</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>heima-leadnews-user</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <docker.image>docker_storage</docker.image>
    </properties>

    <build>
        <finalName>heima-leadnews-user</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.7.0</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                </configuration>
            </plugin>
            <plugin>
                <groupId>com.spotify</groupId>
                <artifactId>dockerfile-maven-plugin</artifactId>
                <version>1.3.6</version>
                <configuration>
                    <repository>${docker.image}/${project.artifactId}</repository>
                    <buildArgs>
                        <JAR_FILE>target/${project.build.finalName}.jar</JAR_FILE>
                    </buildArgs>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

服务集成Dockerfile文件

# 设置JAVA版本
FROM openjdk:8
# 指定存储卷, 任何向/tmp写入的信息都不会记录到容器存储层
VOLUME /tmp
# 拷贝运行JAR包
ARG JAR_FILE
COPY ${JAR_FILE} app.jar
# 设置JVM运行参数， 这里限定下内存大小，减少开销
ENV JAVA_OPTS="\
-server \
-Xms256m \
-Xmx512m \
-XX:MetaspaceSize=256m \
-XX:MaxMetaspaceSize=512m"
#空参数，方便创建容器时传参
ENV PARAMS=""
# 入口点， 执行JAVA运行命令
ENTRYPOINT ["sh","-c","java -jar $JAVA_OPTS /app.jar $PARAMS"]

5. Jenkins基础依赖打包配置

所有微服务打包的方式类似，以heima-leadnews-user微服务为例

步骤①：新建任务

步骤②：找到自己指定的git仓库，设置用户名和密码

添加描述信息

添加凭据，即gitee的用户名和密码

步骤③：添加构建步骤，执行maven命令

步骤④：执行构建build now

6. Jenkins微服务打包配置

所有的微服务打包的方式类似，以heima-leadnews-user微服务为例

步骤①：新建任务 heima-leadnews-user

步骤②：添加自己指定的git仓库，设置用户名和密码

步骤③：执行maven命令

clean install -Dmaven.test.skip=true dockerfile:build -f heima-leadnews-service/heima-leadnews-user/pom.xml

-Dmaven.test.skip=true 跳过测试
dockerfile:build 启动dockerfile插件构建容器
-f heima-leadnews-user/pom.xml 指定需要构建的文件（必须是pom）

步骤④：执行shell脚本

if [ -n  "$(docker ps -a -f  name=$JOB_NAME  --format '{{.ID}}' )" ]
 then
 #删除之前的容器
 docker rm -f $(docker ps -a -f  name=$JOB_NAME  --format '{{.ID}}' )
fi
 # 清理镜像
docker image prune -f 
 # 启动docker服务
docker run -d --net=host -e PARAMS="--spring.profiles.active=prod"  --name $JOB_NAME docker_storage/$JOB_NAME

步骤⑤：执行构建build now

在次之前，先更换镜像加速器 -> etc/docker/daemon.json

开通阿里云容器镜像服务 -> 替换镜像加速器地址

查看镜像

查看容器

查看容器运行日志：docker logs -f 容器ID

步骤⑥：本地连接虚拟机中的数据库，用户名：root，密码：root

导入课前资料中提供的四个数据库

步骤⑦：打开Postman进行测试：http://192.168.200.100:51801/api/v1/login/login_auth

7. 部署服务到远程服务器上

目标：使用Jenkins(192.168.200.100)把微服务打包部署到192.168.200.130服务器上

7.1 安装配置私有仓库

对于持续集成环境的配置，Jenkins会发布大量的微服务，要与多台机器进行交交互，可以采用docker镜像的保存与导出功能结合SSH实现，但这样交互繁琐，稳定性差，而且不便管理。这里我们通过搭建Docker的私有仓库来实现，这个类似于Git仓库，集中统一管理资源，由客户端拉取或更新。

步骤①：下载最新Registry镜像

docker pull registry:latest

步骤②：启动Registry镜像服务

docker run -d -p 5000:5000 --name registry -v /usr/local/docker/registry:/var/lib/registry registry:latest

映射5000端口；-v是将Registry内的镜像数据卷与本地文件关联，便于管理和维护Registry内的数据

步骤③：查看仓库资源

访问地址：http://192.168.200.100:5000/v2/_catalog

启动正常，可以看到返回：

{"repositories":[]}

若并没有上传镜像，显示空数据。如果上传成功，可以看到数据：

步骤④：配置Docker客户端

正常生产环境中使用，要配置HTTPS服务，确保安全，内部开发或测试集成的局域网环境，可以采用简便的方式，不做安全控制。

先确保持续集成环境的机器已经安装好Docker客户端，然后做以下修改：

vi /lib/systemd/system/docker.service

修改内容：

ExecStart=/usr/bin/dockerd --insecure-registry 192.168.200.100:5000

指向安装Registry的服务IP与端口。

重启生效：

systemctl daemon-reolad
systemctl restart docker.service

7.2 Jenkins中安装插件

安装插件：Publish Over SSH、SSH plugin

7.3 Jenkins系统配置远程服务器链接

步骤①：添加凭证，位置：Manage Jenkins -> Manage CreDentials

添加链接到192.168.200.130服务器的用户名和密码。用户名：root 密码：itcast

步骤②：Manage Jenkins -> Configure System

7.4 Jenkins项目创建与其他微服务相同

步骤①：修改pom.xml(heima-leadnews-article)

<?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">
    <parent>
        <artifactId>heima-leadnews-service</artifactId>
        <groupId>com.heima</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>heima-leadnews-article</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <docker.image>docker_storage</docker.image>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-freemarker</artifactId>
        </dependency>
        <dependency>
            <groupId>com.heima</groupId>
            <artifactId>heima-file-starter</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

        <!--xxl-job-->
        <dependency>
            <groupId>com.xuxueli</groupId>
            <artifactId>xxl-job-core</artifactId>
            <version>2.3.0</version>
        </dependency>

        <!-- Kafka Stream -->
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-streams</artifactId>
            <exclusions>
                <exclusion>
                    <artifactId>connect-json</artifactId>
                    <groupId>org.apache.kafka</groupId>
                </exclusion>
                <exclusion>
                    <groupId>org.apache.kafka</groupId>
                    <artifactId>kafka-clients</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <build>
        <finalName>heima-leadnews-article</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.7.0</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                </configuration>
            </plugin>
            <plugin>
                <groupId>com.spotify</groupId>
                <artifactId>dockerfile-maven-plugin</artifactId>
                <version>1.3.6</version>
                <configuration>
                    <repository>${docker.image}/${project.artifactId}</repository>
                    <buildArgs>
                        <JAR_FILE>target/${project.build.finalName}.jar</JAR_FILE>
                    </buildArgs>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

步骤②：添加Dockerfile

# 设置JAVA版本
FROM openjdk:8
# 指定存储卷, 任何向/tmp写入的信息都不会记录到容器存储层
VOLUME /tmp
# 拷贝运行JAR包
ARG JAR_FILE
COPY ${JAR_FILE} app.jar
# 设置JVM运行参数， 这里限定下内存大小，减少开销
ENV JAVA_OPTS="\
-server \
-Xms256m \
-Xmx512m \
-XX:MetaspaceSize=256m \
-XX:MaxMetaspaceSize=512m"
#空参数，方便创建容器时传参
ENV PARAMS=""
# 入口点， 执行JAVA运行命令
ENTRYPOINT ["sh","-c","java -jar $JAVA_OPTS /app.jar $PARAMS"]

步骤③：提交并推送代码

7.5 设置参数

步骤①：新建Item

步骤②：添加参数

7.6 构建执行 - Execute shell

步骤①：源码管理

步骤②：增加构建步骤

maven命令

clean install -Dmaven.test.skip=true dockerfile:build -f heima-leadnews-service/heima-leadnews-article/pom.xml

shell脚本

image_tag=$docker_registry/docker_storage/$JOB_NAME
echo '================docker镜像清理================'
if [ -n  "$(docker ps -a -f  name=$JOB_NAME  --format '{{.ID}}' )" ]
 then
 #删除之前的容器
 docker rm -f $(docker ps -a -f  name=$JOB_NAME  --format '{{.ID}}' )
fi
 # 清理镜像
docker image prune -f 

# 创建TAG
docker tag docker_storage/$JOB_NAME $image_tag
echo '================docker镜像推送================'
# 推送镜像
docker push $image_tag
# 删除TAG
docker rmi $image_tag
echo '================docker tag 清理 ================'

7.7 在远程服务器上执行脚本

步骤①：

echo '================拉取最新镜像================'
docker pull $docker_registry/docker_storage/$JOB_NAME

echo '================删除清理容器镜像================'
if [ -n  "$(docker ps -a -f  name=$JOB_NAME  --format '{{.ID}}' )" ]
 then
 #删除之前的容器
 docker rm -f $(docker ps -a -f  name=$JOB_NAME  --format '{{.ID}}' )
fi
 # 清理镜像
docker image prune -f 

echo '===============启动容器================'
docker run -d   --net=host -e PARAMS="--spring.profiles.active=prod" --name $JOB_NAME $docker_registry/docker_storage/$JOB_NAME

步骤②：build with Paramerters

步骤③：查看

7.8 构建完成以后，可以登录130服务器，查看是否有相关的镜像和容器

步骤①：pom.xml(heima-leadnews-app-gateway)

<?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">
    <parent>
        <artifactId>heima-leadnews-gateway</artifactId>
        <groupId>com.heima</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>heima-leadnews-app-gateway</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <docker.image>docker_storage</docker.image>
    </properties>

    <build>
        <finalName>heima-leadnews-app-gateway</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.7.0</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                </configuration>
            </plugin>
            <plugin>
                <groupId>com.spotify</groupId>
                <artifactId>dockerfile-maven-plugin</artifactId>
                <version>1.3.6</version>
                <configuration>
                    <repository>${docker.image}/${project.artifactId}</repository>
                    <buildArgs>
                        <JAR_FILE>target/${project.build.finalName}.jar</JAR_FILE>
                    </buildArgs>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

步骤②：Dockerfile

# 设置JAVA版本
FROM openjdk:8
# 指定存储卷, 任何向/tmp写入的信息都不会记录到容器存储层
VOLUME /tmp
# 拷贝运行JAR包
ARG JAR_FILE
COPY ${JAR_FILE} app.jar
# 设置JVM运行参数， 这里限定下内存大小，减少开销
ENV JAVA_OPTS="\
-server \
-Xms256m \
-Xmx512m \
-XX:MetaspaceSize=256m \
-XX:MaxMetaspaceSize=512m"
#空参数，方便创建容器时传参
ENV PARAMS=""
# 入口点， 执行JAVA运行命令
ENTRYPOINT ["sh","-c","java -jar $JAVA_OPTS /app.jar $PARAMS"]

步骤③：bootstrap.yml

server:
  port: 51601
spring:
  application:
    name: leadnews-app-gateway
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.200.130:8848
      config:
        server-addr: 192.168.200.130:8848
        file-extension: yml
  profiles:
    active: prod

步骤④：在nacos配置中心添加两份配置文件

步骤⑤：提交并推送更改

步骤⑥：新建任务

Maven目标改为：

clean install -Dmaven.test.skip=true dockerfile:build -f heima-leadnews-gateway/heima-leadnews-app-gateway/pom.xml

步骤⑦：build now

步骤⑧：查看镜像和容器

步骤⑨：修改本地nginx中的配置反向代理地址为100这台服务器：heima-leadnews-app.conf

步骤⑩：重启nginx，打开页面进行测试

http://localhost:8801/#/login

五、Jenkins触发器配置

1. URL触发远程构建

触发远程构建，修改Jenkins的配置，如下：

触发构建url：http://192.168.200.100:16060/job/heima-leadnews-app-gateway/build?token=itcast-leadnews-app-gateway

2. 其他工程构建后触发

配置需要触发的工程

3. 定时构建

定时构建（build periodically）

定时字符串从左往右分别为：分时日月周

定时构建-定时表达式

组成部分	含义	取值范围
第一部分	minute (分)	0~59
第二部分	hour(小时)	0~23
第三部分	day(天)	1~31
第四部分	month(月)	1~12
第五部分	week(周)	0~7，0 和 7 都是表示星期天