Devops 开发运维高级篇之Jenkins+Docker+SpringCloud微服务持续集成

---

一、持续集成流程说明

1. 大致流程解析

① 开发人员每天把代码提交到 Gitlab 代码仓库
② Jenkins从 Gitlab中拉取项目源码，编译并打成jar包，然后构建成Docker镜像，将镜像上传到Harbor私有仓库。
③ Jenkins发送SSH远程命令，让生产部署服务器到Harbor私有仓库拉取镜像到本地，然后创建容器。
④ 最后，用户可以访问到容器

2. 服务器列表

服务器名称	IP地址	安装的软件
代码托管服务器	192.168.8.18	Gitlab
持续集成服务器	192.168.8.19	Jenkins，Maven，Docker18.06.1-ce
Docker仓库服务器	192.168.8.20	Docker18.06.1-ce，Harbor1.9.2
生产部署服务器	192.168.8.17	Docker18.06.1-ce

3. SpringCloud微服务项目架构解析

• 项目架构： 前后端分离

• 后端技术栈： SpringBoot+SpringCloud+SpringDataJpa（Spring全家桶）

• 微服务项目结构：
  
  tensquare_parent： 父工程 ， 存放基础配置
  tensquare_common： 通用工程，存放工具类
  tensquare_eureka_server： SpringCloud的Eureka注册中心
  tensquare_zuul： SpringCloud 的网关服务
  tensquare_admin_service： 基础权限认证中心，负责用户认证（使用JWT认证）
  tensquare_gathering： 一个简单的业务模块，活动微服务相关逻辑

• 数据库结构
  
  tensquare_user： 用户认证数据库，存放用户账户数据。对应tensquare_admin_service微服务tensquare_gathering： 活动微服务数据库。对应tensquare_gathering微服务

• 微服务配置分析：
  tensquare_eureka ——》注册中心，优先开启
  tensquare_zuul ——》网关
  tensquare_admin_service ——》权限管理
  tensquare_gathering——》业务活动

二、微服务部署

1. 导入微服务项目包

微服务项目包解压，目录在idea中打开，idea会自动下载相关组件插件（等待时间较长）

等待下载完成

---

报错解决：
SpringBoot启动类报错can not resolve method 'run(java.lang.class,String [])'问题

2. Windows本地配置maven环境

添加两个变量

修改配置文件组建下载地址设置

    <mirror>
      <id>aliyunmaven</id>
      <mirrorOf>central</mirrorOf>
      <name>aliyun maven</name>
      <url>http://maven.aliyun.com/repository/public</url>
    </mirror>

修改idea指向maven

自动更新

添加构建条件

    <build>
        <plugins>
            <plugin>
                <!--提供打包(将应用打包成可执行的jar包)-->
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <plugin>
                <!-- 指定maven编译的jdk版本 -->
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <verbose>true</verbose>
                    <fork>true</fork>
                    <!--jdk地址-->
                    <executable>C:/Program Files/Java/jdk1.8.0_152/bin/javac</executable>
                </configuration>
            </plugin>
        </plugins>
    </build>

---

3. 安装MySQL数据库

• 本地数据库导入（windows本地安装mysql5.7）

安装完成以后需要配置环境变量

导入软件脚本到MySQL数据库中

#创建二个库
create database tensquare_gathering;
create database tensquare_user;

#导入脚本文件
use tensquare_gathering;
source D:/tensquare_gathering.sql;

use tensquare_user;
source D:/tensquare_user.sql;

4. 安装 Visual Studio Code

5. 安装 node.js

添加系统环境变量，需要识别npm命令

Vscode终端中运行：npm run dev，会发现报错

解决方法：

• 安装Python2

npm install -g cnpm --registry=https://registry.npm.taobao.org

使用cmd切换到tensquareAdmin目录下执行 cnpm uninstall node-sass

再执行安装命令 cnpm install node-sass

启动前端项目 ——》cnpm run dev

到此位置，前端部分已经安装部署完成

---

6. 配置启动Eureka注册中心

修改配置文件application.yml

# 单机版
server:
  port: 10086

#基本服务器信息
spring:
  application:
     name: eureka-server  #服务ID

#enreka服务器配置
eureka:
  client:
    fetch-registry: false    #单机版关闭enreka相互注册
    register-with-eureka: false
    service-url:
      defaultZone:  http://localhost:${server.port}/eureka #暴露eureka服务访问地址
  server:
    enable-self-preservation: false #关闭自我保护

运行注册中心

浏览器访问 http://localhost:10086

7. 配置启动网关zuul

8. 配置启动权限管理admin_service

9. 配置启动业务模块

到此，微服务的所有服务都已开启成功

---

三、微服务测试

1. 测试后端服务

安装postmam

获取token令牌

eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiIxMTk0MjgxNTMzMjMwNDE5OTY4Iiwic3ViIjoiYWRtaW4iLCJpYXQiOjE2NDUzNzM3OTMsInJvbGVzIjoiYWRtaW4iLCJleHAiOjE2NDUzNzU1OTN9.XyodVOf3_2ioYOO9F6EexxUA9Kruridt3AN0cmD3NE8

获取数据库信息成功

2. 测试前端服务

cnpm run dev

登录平台
http://localhost:9528

这里可以看到数据库中存储的信息，表明前端和数据库对接成功

四、对微服务中的服务进行打包

1. IDEA中进行jar包构建

这里如果提示mvn无法识别则需要重启IDEA再进行打包

2. 对jar包进行单独运行

java -jar tensquare_eureka_server-1.0-SNAPSHOT.jar

3. 浏览器访问

使用浏览器访问
http://localhost:10086/

由此可以看出，对于打的jar包是可以单独在本地进行运行的

五、部署docker及harbor仓库

docker的部署及基础操作可参考前文

1. 部署docker

以下服务器上均需部署docker

Jenkins 服务器 192.168.8.19
Harbor镜像仓库服务器 192.168.8.20
生产部署服务器 192.168.8.17

#环境配置
systemctl stop firewalld
systemctl disable firewalld

vim /etc/selinux/config
SELINUX=disabled

vim /etc/resolv.conf
nameserver 114.114.114.114

#安装依赖包
yum install -y yum-utils device-mapper-persistent-data lvm2

#设置阿里云镜像源
cd /etc/yum.repos.d/
yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

#安装 docker-ce 社区版
yum install -y docker-ce
systemctl start docker
systemctl enable docker

#配置镜像加速，官方网址可参考：https://help.aliyun.com/document_detail/60750.html
mkdir -p /etc/docker
#直接命令行输入以下内容：

tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://t466r8qg.mirror.aliyuncs.com"]
}
EOF

#把Harbor地址加入到Docker信任列表（harbor仓库的docker中不需要配）
vim /etc/docker/daemon.json 

{
  "registry-mirrors": ["https://t466r8qg.mirror.aliyuncs.com"],
"insecure-registries": ["192.168.8.20:85"]
}

systemctl daemon-reload							
systemctl restart docker						

#网络优化
vim /etc/sysctl.conf
net.ipv4.ip_forward=1

sysctl -p
systemctl restart network
systemctl restart docker
docker version	 						

2. harbor仓库部署

注意：需要先部署docker，并且启动docker

• 先安装 docker-compose

cd /usr/local/bin/
#docker-compose下载好拖进该目录中
chmod +x /usr/local/bin/docker-compose

• 查看docker-compose是否安装成功

docker-compose -version

• 上传压缩包到 linux，并解压

tar zxvf harbor-offline-installer-v1.9.2.tgz -C /opt/

• 修改配置文件

cd /opt/harbor
vim harbor.yml
#修改 hostname 和 port hostname: 192.168.8.20
port: 85

• 安装Harbor（docker处于启动状态）

./prepare
./install.sh 

• Harbor的命令如下

docker-compose up -d 启动
docker-compose stop 停止
docker-compose restart 重新启动

• 访问 Harbor
  http://192.168.8.20:85
默认账户密码：admin/Harbor12345

创建项目

• Harbor的项目分为公开和私有的：
  公开项目：所有用户都可以访问，通常存放公共的镜像，默认有一个library公开项目。
  私有项目：只有授权用户才可以访问，通常存放项目本身的镜像。

创建用户，分配权限

给私有项目分配用户

角色	权限说明
访客	对于指定项目拥有只读权限
开发人员	对于指定项目拥有读写权限
维护人员	对于指定项目拥有读写权限，创建 Webhooks
项目管理员	除了读写权限，同时拥有用户管理/镜像扫描等管理权限

3. 使用Dockerfile制作微服务镜像

利用Dockerfile制作一个Eureka注册中心的镜像

• 上传 Eureka 的微服务 jar 包到 linux 中，并编写Dockerfile

FROM openjdk:8-jdk-alpine 
ARG JAR_FILE
COPY ${JAR_FILE} app.jar 
EXPOSE 10086
ENTRYPOINT ["java","-jar","/app.jar"]

• 构建镜像

docker build --build-arg JAR_FILE=tensquare_eureka_server-1.0-SNAPSHOT.jar -t eureka:v1 .

• 创建容器

docker run -i --name=eureka -p 10086:10086 eureka:v1

• 访问容器

http://192.168.8.19:10086/

4. Jenkins服务器上传镜像至Harbor仓库

• 给镜像打上标签

docker tag eureka:v1 192.168.8.20:85/tensquare/eureka:v1

• 登录harbor仓库，获取权限

docker login -u tom -p Abcd1234 192.168.8.20:85

• 推送镜像

docker push 192.168.8.20:85/tensquare/eureka:v1 

5. 生产服务器上拉取镜像

• 登录harbor仓库，获取权限

docker login -u tom -p Abcd1234 192.168.8.20:85

• 拉取镜像

docker pull 192.168.8.20:85/tensquare/eureka:v1 

六、项目代码上传到Gitlab仓库

1. Gitlab仓库建立二个项目（前端与后端）

2. 提交后端项目

重新定义远程仓库地址

这里需要复制gitlab仓库中 tensquare_back 项目中 HTTP 的URL

提交完成后，在Gitlab仓库中查看项目的变化

3. 提交前端项目

Windows本地安装TortoiseGit（小乌龟）用来提交前端项目代码

安装汉化包

右键桌面，点击设置进行汉化选择

到前端项目的路径下，右击鼠标选中Git同步

在Gitlab仓库上查看是否提交成功

七、从Gitlab上拉取项目源码

1. 创建pipeline项目

使用项目中Jenkinsfile方式去拉取代码

使用流水线语法中的片段生成器来进行生成拉取代码

2. 设置参数化构建

3. 创建Jenkinsfile文件

//定义gitlab的凭证
def git_auth="03757112-b3bd-4955-93ef-ad84869f39a9"
//定义gitlab的URL路径
def git_url="git@192.168.8.18:gl/tensquare_back.git"

node {
    stage('pull code') {
        checkout([$class: 'GitSCM', branches: [[name: "*/${branch}"]], extensions: [], userRemoteConfigs: [[credentialsId: "${git_auth}", url: "${git_url}"]]])
    }
}

提交到Gitlab仓库

4. 查看构建项目的结果

八、SonarQube代码审查

1. 创建项目，设置参数

使用上面的tensquare_back项目，并进行参数配置

tensquare_eureka_server
tensquare_zuul
tensquare_admin_service
tensquare_gathering
注册中心
服务网关
认证中心
活动微服务

2. 每个项目的根目录下添加sonar-project.properties

# must be unique in a given SonarQube instance
sonar.projectKey=tensquare_admin_service
# this is the name and version displayed in the SonarQube UI. Was mandatory prior to SonarQube 6.1.
sonar.projectName=tensquare_admin_service
sonar.projectVersion=1.0

# Path is relative to the sonar-project.properties file. Replace "\" by "/" on Windows.
# This property is optional if sonar.modules is set.
sonar.sources=.
sonar.exclusions=**/test/**,**/target/**
sonar.java.binaries=.

sonar.java.source=1.8
sonar.java.target=1.8
#sonar.java.libraries=**/target/classes/**

# Encoding of the source code. Default is default system encoding
sonar.sourceEncoding=UTF-8

3. 修改Jenkinsfile构建脚本

//定义gitlab的凭证
def git_auth="03757112-b3bd-4955-93ef-ad84869f39a9"
//定义gitlab的URL路径
def git_url="git@192.168.8.18:gl/tensquare_back.git"

node {
    stage('pull code') {
        //切换成变量，字符串符号使用双引号
        checkout([$class: 'GitSCM', branches: [[name: "*/${branch}"]], extensions: [], userRemoteConfigs: [[credentialsId: "${git_auth}", url: "${git_url}"]]])
    }
    stage('check code') {
            //定义SonarQubeScanner工具
            def scannerHome = tool 'sonar-scanner'
            //引用SonarQube系统环境
            withSonarQubeEnv('sonarqube') {
            sh """
                cd ${project_name}
                ${scannerHome}/bin/sonar-scanner
               """
               }
    }
}

提交Jenkinsfile文件到Gitlab仓库

再次构建进行代码检查

登录sonarqube，检查结果

九、Dockerfile编译、生成镜像

1. 安装通用工程common

在idea中对Jenkinsfile进行更改，增加安装common工具的命令

//定义gitlab的凭证
 def git_auth="03757112-b3bd-4955-93ef-ad84869f39a9"
 //定义gitlab的URL路径
 def git_url="git@192.168.8.18:gl/tensquare_back.git"

 node {
     stage('pull code') {
         checkout([$class: 'GitSCM', branches: [[name: "*/${branch}"]], extensions: [], userRemoteConfigs: [[credentialsId: "${git_auth}", url: "${git_url}"]]])
    }
     stage('check code') {
                    //定义SonarQubeScanner工具
                     def scannerHome = tool 'sonar-scanner'
                     //引用SonarQube系统环境
                     withSonarQubeEnv('sonarqube') {
                     sh """
                         cd ${project_name}
                         ${scannerHome}/bin/sonar-scanner
                        """
                     }
     }
     //编译,打包,镜像制作
     stage('make package images') {
        sh "mvn -f tensquare_common clean install"
     }
 }

2. 构建tensquare_back项目进行测试

问题分析：
在每一个微服务中都有一个pom.xml文件，里面有指向父进程 pom.xml的选项（如下图），common工具在进行加载的时候会先对其中的 pom.xml 文件进行加载，挨个加载其中的插件，因为 common 本身是一个工具而不是服务，工具在进行打包编译的时候并不需要指定方式。

解决方案：

把父工程 pom.xml 中的 maven 插件代码移至除了 tensquare_common 以外每个子工程 pom.xml中

剪切的代码粘贴到每个微服务的pom.xml文件中，除了common不用放，其他四个微服务都需要操作

3. 重新构建项目

构建成功，公共子工程被安装到的路径:
/root/repo/com/tensquare/tensquare_common/1.0-SNAPSHOT/tensquare_common-1.0-SNAPSHOT.jar

4. 编译打包所有微服务项目

在 Jenkinsfile 中写入微服务打包代码

//定义gitlab的凭证
 def git_auth="03757112-b3bd-4955-93ef-ad84869f39a9"
 //定义gitlab的URL路径
 def git_url="git@192.168.8.18:gl/tensquare_back.git"

 node {
     stage('pull code') {
         checkout([$class: 'GitSCM', branches: [[name: "*/${branch}"]], extensions: [], userRemoteConfigs: [[credentialsId: "${git_auth}", url: "${git_url}"]]])
    }
     stage('check code') {
                    //定义SonarQubeScanner工具
                     def scannerHome = tool 'sonar-scanner'
                     //引用SonarQube系统环境
                     withSonarQubeEnv('sonarqube') {
                     sh """
                         cd ${project_name}
                         ${scannerHome}/bin/sonar-scanner
                        """
                     }
     }
     //添加公共子工程
     stage('make install public sub project') {
            sh "mvn -f tensquare_common clean install"
     }
     //编译打包微服务
     stage('make package') {
            sh "mvn -f ${project_name} clean package"
     }
 }

进行代码提交

构建eureka服务

构建tensquare_zuul服务网关

失败原因：
因为Jenkins服务器中并没有tensquare_paren工程，而zuul需要依赖这个工程

解决方法：
传递父工程进Jenkins仓库

继续打包zuul服务网关

打包权限中心服务

打包活动微服务

到此所有的微服务项目就已经全部打包成功了

5. 构建Docker镜像

利用 dockerfile-maven-plugin 插件构建 Docker 镜像

在每个微服务项目的 pom.xml 加入 dockerfile-maven-plugin 插件

            <plugin>
                <groupId>com.spotify</groupId>
                <artifactId>dockerfile-maven-plugin</artifactId>
                <version>1.3.6</version>
                <configuration>
                    <repository>${project.artifactId}</repository>
                    <buildArgs>
                        <JAR_FILE>target/${project.build.finalName}.jar</JAR_FILE>
                    </buildArgs>
                </configuration>
            </plugin>

在每个微服务项目根目录下建立Dockerfile文件，需要注意的是每个项目公开的端口是不一样的

tensquare_admin_service:

#FROM java:8
FROM openjdk:8-jdk-alpine
ARG JAR_FILE
COPY ${JAR_FILE} app.jar
EXPOSE 9001
ENTRYPOINT ["java","-jar","/app.jar"]

tensquare_eureka_server:

#FROM java:8
FROM openjdk:8-jdk-alpine
ARG JAR_FILE
COPY ${JAR_FILE} app.jar
EXPOSE 10086
ENTRYPOINT ["java","-jar","/app.jar"]

tensquare_gathering:

#FROM java:8
FROM openjdk:8-jdk-alpine
ARG JAR_FILE
COPY ${JAR_FILE} app.jar
EXPOSE 9002
ENTRYPOINT ["java","-jar","/app.jar"]

tensquare_zuul:

#FROM java:8
FROM openjdk:8-jdk-alpine
ARG JAR_FILE
COPY ${JAR_FILE} app.jar
EXPOSE 10020
ENTRYPOINT ["java","-jar","/app.jar"]

修改 Jenkinsfile ，在其中写入构建脚本

构建eureka服务

Jenkins服务器中查看镜像

制作其他微服务的镜像

到此为此，所有微服务镜像制作完成！！

十、镜像上传 Harbor 仓库

1. 对镜像打标签

修改Jenkinsfile脚本

//定义gitlab的凭证
 def git_auth="03757112-b3bd-4955-93ef-ad84869f39a9"
 //定义gitlab的URL路径
 def git_url="git@192.168.8.18:gl/tensquare_back.git"

//镜像标签
def tag="latest"
//harbor的url地址
def harbor_url="192.168.8.20:85"
//镜像仓库名
def harbor_name="tensquare"

 node {
     stage('pull code') {
         checkout([$class: 'GitSCM', branches: [[name: "*/${branch}"]], extensions: [], userRemoteConfigs: [[credentialsId: "${git_auth}", url: "${git_url}"]]])
    }
     stage('check code') {
                    //定义SonarQubeScanner工具
                     def scannerHome = tool 'sonar-scanner'
                     //引用SonarQube系统环境
                     withSonarQubeEnv('sonarqube') {
                     sh """
                         cd ${project_name}
                         ${scannerHome}/bin/sonar-scanner
                        """
                     }
     }
     //添加公共子工程
     stage('make install public sub project') {
            sh "mvn -f tensquare_common clean install"
     }
     //编译打包微服务，制作镜像
     stage('make package') {
            sh "mvn -f ${project_name} clean package dockerfile:build"
            //定义镜像名称
                       def imageName="${project_name}:${tag}"
            //对镜像打标签
            sh "docker tag ${imageName} ${harbor_url}/${harbor_name}/${imageName}"
     }
 }

代码提交后，构建eureka测试打标签结果

对所有的微服务进行打标签

2. Jenkins中添加 harbor 的凭证

镜像上传 harbor 仓库需要先进行登录，但是如果把账号密码卸载脚本中并不是很安全也不切合实际，所以需要使用变量的方式来进行调用。

输入harbor用户的账号和密码并添加凭证

变量中会用到这个凭证的ID

778a9460-c68d-4ab6-ab7f-f5113ec3a900

使用流水线语法中的片段生成器来生成代码，并把复制到Jenkinsfile脚本中

//定义gitlab的凭证
 def git_auth="03757112-b3bd-4955-93ef-ad84869f39a9"
 //定义gitlab的URL路径
 def git_url="git@192.168.8.18:gl/tensquare_back.git"

//镜像标签
def tag="latest"
//harbor的url地址
def harbor_url="192.168.8.20:85"
//镜像仓库名
def harbor_name="tensquare"
//harbor凭证
def harbor_auth="778a9460-c68d-4ab6-ab7f-f5113ec3a900"

 node {
     stage('pull code') {
         checkout([$class: 'GitSCM', branches: [[name: "*/${branch}"]], extensions: [], userRemoteConfigs: [[credentialsId: "${git_auth}", url: "${git_url}"]]])
    }
     stage('check code') {
                    //定义SonarQubeScanner工具
                     def scannerHome = tool 'sonar-scanner'
                     //引用SonarQube系统环境
                     withSonarQubeEnv('sonarqube') {
                     sh """
                         cd ${project_name}
                         ${scannerHome}/bin/sonar-scanner
                        """
                     }
     }
     //添加公共子工程
     stage('make install public sub project') {
            sh "mvn -f tensquare_common clean install"
     }
     //编译打包微服务，制作镜像
     stage('make package') {
            sh "mvn -f ${project_name} clean package dockerfile:build"
            //定义镜像名称
            def imageName="${project_name}:${tag}"
            //对镜像打标签
            sh "docker tag ${imageName} ${harbor_url}/${harbor_name}/${imageName}"
            //镜像推送到harbor
            withCredentials([usernamePassword(credentialsId: "${harbor_auth}", passwordVariable: 'password', usernameVariable: 'username')]) {
                //登录harbor
                sh "docker login -u ${username} -p ${password} ${harbor_url}"
                //镜像上传
                sh "docker push ${harbor_url}/${harbor_name}/${imageName}"
                sh "echo 镜像上传成功"
            }
     }
 } 

更改提交代码后，测试镜像上传

3. 登录harbor仓库查看结果

登录harbor仓库查看项目中的镜像是否已经上传成功

到此，所有微服务的镜像成功上传到harbor仓库中

十一、拉取镜像和发布应用

1. 安装 Publish Over SSH 插件

Publish Over SSH 插件可以实现远程发送Shell命令，安装完需要重启 Jenkins

2. 配置远程部署服务器

拷贝公钥，从Jenkins服务器拷贝到生产服务器

ssh-copy-id 192.168.8.17

Jenkins 系统配置中添加远程服务器

3. 修改Jenkinsfile构建脚本生成远程调用模板代码

//定义gitlab的凭证
 def git_auth="03757112-b3bd-4955-93ef-ad84869f39a9"
 //定义gitlab的URL路径
 def git_url="git@192.168.8.18:gl/tensquare_back.git"

//镜像标签
def tag="latest"
//harbor的url地址
def harbor_url="192.168.8.20:85"
//镜像仓库名
def harbor_name="tensquare"
//harbor凭证
def harbor_auth="778a9460-c68d-4ab6-ab7f-f5113ec3a900"

 node {
     stage('pull code') {
         checkout([$class: 'GitSCM', branches: [[name: "*/${branch}"]], extensions: [], userRemoteConfigs: [[credentialsId: "${git_auth}", url: "${git_url}"]]])
    }
     stage('check code') {
                    //定义SonarQubeScanner工具
                     def scannerHome = tool 'sonar-scanner'
                     //引用SonarQube系统环境
                     withSonarQubeEnv('sonarqube') {
                     sh """
                         cd ${project_name}
                         ${scannerHome}/bin/sonar-scanner
                        """
                     }
     }
     //添加公共子工程
     stage('make install public sub project') {
            sh "mvn -f tensquare_common clean install"
     }
     //编译打包微服务，制作镜像
     stage('make package') {
            sh "mvn -f ${project_name} clean package dockerfile:build"
            //定义镜像名称
            def imageName="${project_name}:${tag}"
            //对镜像打标签
            sh "docker tag ${imageName} ${harbor_url}/${harbor_name}/${imageName}"
            //镜像推送到harbor
            withCredentials([usernamePassword(credentialsId: "${harbor_auth}", passwordVariable: 'password', usernameVariable: 'username')]) {
                //登录harbor
                sh "docker login -u ${username} -p ${password} ${harbor_url}"
                //镜像上传
                sh "docker push ${harbor_url}/${harbor_name}/${imageName}"
                sh "echo 镜像上传成功"
            }
            //部署应用
            sshPublisher(publishers: [sshPublisherDesc(configName: 'master_server', transfers: [sshTransfer(cleanRemote: false, excludes: '', execCommand: "/opt/jenkins_shell/deploy.sh ${harbor_url} ${harbor_name} ${project_name} ${tag} ${port}", execTimeout: 120000, flatten: false, makeEmptyDirs: false, noDefaultExcludes: false, patternSeparator: '[, ]+', remoteDirectory: '', remoteDirectorySDF: false, removePrefix: '', sourceFiles: '')], usePromotionTimestamp: false, useWorkspaceInPromotion: false, verbose: false)])
     }
 }

添加端口新参数

4. 部署脚本deploy.sh中的内容

#! /bin/sh
#接收外部参数
harbor_url=$1
harbor_project_name=$2
project_name=$3
tag=$4
port=$5

imageName=$harbor_url/$harbor_project_name/$project_name:$tag

echo "$imageName"

#查询容器是否存在，存在则删除
containerId=`docker ps -a | grep -w ${project_name}:${tag}  | awk '{print $1}'`
if [ "$containerId" !=  "" ] ; then
    #停掉容器
    docker stop $containerId

    #删除容器
    docker rm $containerId
 
 echo "成功删除容器"
fi

#查询镜像是否存在，存在则删除
imageId=`docker images | grep -w $project_name  | awk '{print $3}'`

if [ "$imageId" !=  "" ] ; then
      
    #删除镜像
    docker rmi -f $imageId
 
 echo "成功删除镜像"
fi

# 登录Harbor
docker login -u tom -p Abcd1234 $harbor_url

# 下载镜像
docker pull $imageName

# 启动容器
docker run -di -p $port:$port $imageName

echo "容器启动成功"

在生产服务器上创建目录，并放入脚本

mkdir /opt/jenkins_shell
cd /opt/jenkins_shell/
vim deploy.sh
chmod +x deploy.sh 

Jenkinsfile更改提交进行构建测试

5. 验证结果

在生产服务器上检查结果

在浏览器中查看服务

十二、通过微服务访问后端数据库

1. idea中修改微服务配置文件

tensquare_admin_service

tensquare_eureka_server

tensquare_gathering

tensquare_gathering

修改完以后进行提交代码仓库

进行构建

生产服务器上查看结果

登录注册中心查看是否注册成功

2. 数据库进行授权远程登录

把脚本文件放入/root/目录下

mysql -uroot -pabc123
grant all privileges on *.* to 'root'@'%' identified by 'abc123' with grant option;

create database tensquare_gathering;
create database tensquare_user;

#导入脚本文件
use tensquare_gathering;
source /root/tensquare_gathering.sql;

use tensquare_user;
source /root/tensquare_user.sql;

3. 使用postman连接数据库

十三、部署前端静态web网站

1. 安装nginx服务器

生产服务器上部署nginx服务器

yum install -y epel-release 
yum -y install nginx 

#修改nginx的端口，默认80，改为9090
vi /etc/nginx/nginx.conf

    server {
        listen       9090;
        listen       [::]:9090;
        server_name  _;
        root         /usr/share/nginx/html;

#关闭selinux，将SELINUX=disabled 
setenforce 0 						#先临时关闭
vi /etc/selinux/config 				#编辑文件，永久关闭 SELINUX=disabled

#启动Nginx
systemctl enable nginx 设置开机启动
systemctl start nginx 启动
systemctl stop nginx 停止
systemctl restart nginx 重启

访问：http://192.168.8.17:9090/

2. 安装NodeJS插件

3. 配置Nginx服务器

Manage Jenkins->Global Tool Configuration

创建前端流水线项目

添加参数化构建

添加声明式脚本代码

//harbor的凭证
def  git_auth="03757112-b3bd-4955-93ef-ad84869f39a9"

node {
    stage('pull code') {
        //切换成变量，字符串符号使用双引号
        checkout([$class: 'GitSCM', branches: [[name: "*/${branch}"]], extensions: [], userRemoteConfigs: [[credentialsId: "${git_auth}", url: 'git@192.168.8.18:gl/tensquare_back.git']]])
    }

    stage('make package,deploy') {
            //使用nodejs的npm打包
            nodejs('nodejs12'){
                sh '''
                    npm install
                    npm run build
                '''
            }
            //远程部署
            sshPublisher(publishers: [sshPublisherDesc(configName: 'master_server', transfers: [sshTransfer(cleanRemote: false, excludes: '', execCommand: '', execTimeout: 120000, flatten: false, makeEmptyDirs: false, noDefaultExcludes: false, patternSeparator: '[, ]+', remoteDirectory: '/usr/share/nginx/html', remoteDirectorySDF: false, removePrefix: 'dist', sourceFiles: 'dist/**')], usePromotionTimestamp: false, useWorkspaceInPromotion: false, verbose: false)])
    }
}

前端项目中更改配置文件中的网关地址

点击提交以后，点击推送

在Gitlab上查看提交结果

构建完成以后重新登录