【Jenkins】持续集成部署学习

【一】Jenkins介绍

【二】Docker安装Gitlab

【1】首先准备一台空的虚拟机服务器

Gitlab用的端口是80，可能会跟其它应用冲突，并且Gitlab所需内存也很大，所以还是单独放在一个服务器上比较好。
用原来空的虚拟机服务器克隆一个，注意内存要选大一点，6G左右

【2】安装服务器所需的依赖

（1）ip a / ip addr / ifconfig 不显示ip问题

yum install iproute ftp bind-utils net-tools wget -y

【3】Docker的安装

（1）查看系统的内核版本

uname -r 4.18.0-80.11.2.el8_0.x86_64

执行命令：uname -r
注意：x86 64位系统，如果是32位是不能安装 docker 的

（2）yum更新到最新版本

sudo yum -y update

执行命令：sudo yum update
注意：看到显示 Complete 就代表完成了，整个过程需要 5-10 分钟左右

更新gcc（C语言的编译环境）

yum -y install gcc
yum -y install gcc-c++

（3）安装Docker所需的依赖包

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

执行命令：sudo yum install -y yum-utils device-mapper-persistent-data lvm2
注意：看到显示 Complete 就代表完成了，整个过程需要 1-3 分钟左右

（4）设置Docker的yum的源

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

（5）更新yum软件包索引

yum makecache fast

（6）查看仓库所有Docker版本

yum list docker-ce --showduplicates | sort -r

（7）安装Docker
安装默认最新版本的Docker

yum -y install docker-ce docker-ce-cli containerd.io

（8）启动Docker并添加开机自启动
启动Docker

sudo systemctl start docker

设置开机启动Docker

systemctl enable docker

重启docker

systemctl restart docker

停止docker

systemctl stop docker

（9）查看Docker版本

docker --version

（10）测试

ps -ef|grep docker

docker version

（11）卸载Docker

systemctl stop docker
yum remove docker-ce docker-ce-cli containerd.io
rm -rf /var/lib/docker
rm -rf /var/lib/containerd

（12）Docker常用命令

[root@CodeGuide ~]# docker --help				#Docker帮助
[root@CodeGuide ~]# docker --version			#查看Docker版本
[root@CodeGuide ~]# docker search <image>		#搜索镜像文件，如：docker search mysql
[root@CodeGuide ~]# docker pull <image>		#拉取镜像文件， 如：docker pull mysql
[root@CodeGuide ~]# docker images				#查看已经拉取下来的所以镜像文件
[root@CodeGuide ~]# docker rmi <image>		#删除指定镜像文件
[root@CodeGuide ~]# docker run --name <name> -p 80:8080 -d <image>		#发布指定镜像文件
[root@CodeGuide ~]# docker ps					#查看正在运行的所有镜像
[root@CodeGuide ~]# docker ps -a				#查看所有发布的镜像
[root@CodeGuide ~]# docker rm <image>			#删除执行已发布的镜像

（13）如何创建自启动的容器
（1）还没run创建容器的
使用 docker run 命令运行时，增加 --restart=always 参数即可

（2）已运行的容器修改其自启动策略
执行命令：
docker update --restart=always 容器名或容器ID
docker container update --restart=【容器策略】 容器名称

# no 容器退出时不重启容器
# on-failure 只有在非零状态退出时才重新启动容器
--restart=on-failure:【重启次数】
# always 无论退出状态如何都

【4】阿里云镜像加速

（1）获取阿里云加速器地址
登陆阿里云，点击控制台，然后点击菜单，找到“容器镜像服务”

创建个人容器镜像托管服务

然后点击镜像工具，进入镜像加速器，即可看到阿里云加速器地址，把这个加速器地址配置到docker容器里

（2）创建文件夹并执行脚本
先创建文件夹

mkdir -p /etc/docker

执行脚本

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

（3）重新加载配置文件

systemctl daemon-reload

（4）重新启动docker

systemctl restart docker

（5）查看 daemon.json 是否已经生效了

tail /etc/docker/daemon.json

【5】安装Gitlab

关闭所有防火墙
service firewalld status
service firewalld stop
重启docker：systemctl restart docker

（1）拉取镜像，创建容器
直接使用创建命令，系统会自动进行拉取

# 添加容器
docker run --detach \
 --hostname 192.168.19.8  \
 --publish 443:443 --publish 80:80 \
 --name gitlab \
 --restart always \
 --volume $GITLAB_HOME/config:/etc/gitlab \
 --volume $GITLAB_HOME/logs:/var/log/gitlab \
 --volume $GITLAB_HOME/data:/var/opt/gitlab \
 --shm-size 256m \
 registry.gitlab.cn/omnibus/gitlab-jh:latest


 gitlab/gitlab-ce:latest

（2）启动容器

docker start gitlab

查看已经存在的容器

docker ps -a

（3）进入容器

docker exec -it gitlab /bin/bash

（4）外网访问测试
首先保证前面关闭防火墙
访问下面连接（注意http不加s）：http://192.168.19.8/
要稍微等一会

查看内存使用情况

free -m

等内存加载的差不多了，就可以打开网页了


（5）管理员账号密码登录
密码是进入容器后查找的

cat /etc/gitlab/initial_root_password

登录名是root，密码直接复制过来使用

（6）修改默认密码
启动 gitlab-rails console要等一会

进入容器：
~/files/code/gitlab$ docker exec -it gitlab bash
启动 gitlab-rails console：

root@gitlab:/# gitlab-rails console
--------------------------------------------------------------------------------
 Ruby:         ruby 2.7.5p203 (2021-11-24 revision f69aeb8314) [x86_64-linux]
 GitLab:       14.7.2 (89599212ee6) FOSS
 GitLab Shell: 13.22.2
 PostgreSQL:   12.7
--------------------------------------------------------------------------------
Loading production environment (Rails 6.1.4.4)
irb(main):001:0> user =User.find(1)
=> #<User id:1 @root>
irb(main):002:0> user.password = '111111admin'
=> "111111admin"
irb(main):003:0> user.password_confirmation = '111111admin'
=> "111111admin"
irb(main):004:0> user.send_only_admin_changed_your_password_notification!
=> true
irb(main):005:0> user.save!
=> true
irb(main):006:0> exit
root@gitlab:/# exit

【三】Gitlab的使用

（1）Gitlab创建项目

首先创建一个空白的项目

（2）Idea工具创建本地仓库

在IDEA中创建好项目，点击VCS，按照下图指示先给项目创建本地Git仓库

（3）选择此项目根目录作为发布的仓库

（4）把项目ADD添加到git缓冲区

选择最右侧的 “add”

（5）再将项目COMMIT提交到本地仓库

选择最右侧第一个 “Commit Directory…”
点击之后，在弹窗里填写备注信息

（6）把项目PUSH推送到远程仓库

URL复制下面这个
连接的时候输入root和对应的密码就行了

这样就可以提交上去了

更新项目的话，commit的时候选择你修改的文件，push的时候，对应的url就是你要更新项目仓库的url。这样，gitlab上面仓库里面的项目就是你选择的文件进行修改了。也就是只是局部进行修改。

（7）查看commit的几次，就是看版本

看到以上commit了3次；

我们想要回到某一次，我们可以右击想要回到的版本

只要点击了以上的这个，就回去了

【Checkout Revision】和【Reset Current Branch to Here】的区别？

（8）创建分支

我们想要在当前的项目的基础上面，创建一个分支，相当于对于当前的项目复制一份，变为一个分支

如何查看是不是切换过去了

idea右下角，就可以看到当前的项目在哪个分支

也可以直接在右下角进行点击创建

【四】Docker安装Jenkins

【1】安装JDK、Maven、Git（可跳过）

（1）安装JDK

参考文章：Linux安装JDK
（1）yum下载JDK

yum search java | grep java-1.8
# 安装JRE
yum install java-1.8.0-openjdk
# 安装JDK
yum install -y java-devel

安装完成后，默认的安装路径为：

cd /usr/lib/jvm/

（2）配置JDK环境变量
1-编辑系统配置文件

vim /etc/profile

2-在profile的最后面添加，下面的JAVA_HOME是JDK文件夹

JAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk
PATH=$JAVA_HOME/bin:$PATH
CLASSPATH=$JAVA_HOME/lib/tools.jar:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/jre/lib/rt.jar:$JAVA_HOME/jre/lib/ext
 
export PATH JAVA_HOME CLASSPATH

3-让配置生效

source /etc/profile

4-查看jdk是否生效

（2）安装Maven

（1）下载maven
下载地址：https://dlcdn.apache.org/maven/maven-3/3.8.8/binaries/apache-maven-3.8.8-bin.tar.gz

（2）把下载包上传到服务器的/usr/lib/jvm目录下

cd /usr/lib/jvm
#解压maven
tar -zxvf apache-maven-3.8.8-bin.tar.gz

（3）设置环境变量

vim /etc/profile

JAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk
PATH=$JAVA_HOME/bin:$PATH
CLASSPATH=$JAVA_HOME/lib/tools.jar:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/jre/lib/rt.jar:$JAVA_HOME/jre/lib/ext
 
export PATH JAVA_HOME CLASSPATH
export MAVEN_HOME=/usr/lib/jvm/apache-maven-3.8.8
export PATH=${MAVEN_HOME}/bin:${PATH}

让配置生效

source /etc/profile

查看mvn的版本，测试是否安装成功

mvn -v

（4）配置Maven加速镜像

cd /usr/lib/jvm/apache-maven-3.8.8/conf/

vim settings.xml

编辑添加下面内容

<mirrors>
	<mirror>
	    <id>alimaven</id>
	    <name>aliyun maven</name>
	    <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
	    <mirrorOf>central</mirrorOf>
	</mirror>
</mirrors>

（3）安装Git

docker安装的git自带git

【2】安装Jenkins

（1）拉取镜像

拉取镜像，这里指定是2.415版本，默认最新的是2.3版本，在初始化插件的时候会因为版本低而下载失败

docker pull jenkins/jenkins:2.415

（2）修改目录权限

会把容器中的Jenkins主目录给持久化到主机本地目录里，因此需要先在主机上新建一个本地目录，并设置权限

需要修改下目录权限，因为当映射本地数据卷时，/data/jenkins_home/目录的拥有者为root用户，

而容器中jenkins用户的 uid 为 1000。

我们创建一个jenkins目录
# mkdir /var/jenkins_home
# chown -R 1000:1000 /var/jenkins_home/

（3）运行容器

（1）–name jenkins：命名
（2）-d：表示后台运行
（3）-p 10240:8080：把宿主机的10240端口映射到8080端口
（4）-v /var/jenkins_home:/var/jenkins_home
（5）-v /etc/localtime:/etc/localtime
（6）-v /var/run/docker.sock:/var/run/docker.sock：让Jenkins能够与主机的Docker进行通讯

如果上面没有安装JDK、Maven、Git这些，就不需要进行挂载了，后面直接使用docker安装自带的jdk和git，还可以自动安装maven

docker run -d -p 10240:8080 -p 10241:50000 -v /var/jenkins_home:/var/jenkins_home -v /etc/localtime:/etc/localtime --name myjenkins -v /var/run/docker.sock:/var/run/docker.sock jenkins/jenkins:2.415

如果已经安装了JDK、Maven、Git这些，可以在启动的时候挂载

docker run -di --name=myjenkins -p 10240:8080 -p 10241:50000 -v /var/jenkins_home:/var/jenkins_home \
-v /etc/localtime:/etc/localtime \
-v /usr/local/java/jdk:/usr/local/jdk1.8 \
-v /usr/local/java/apache-maven-3.8.5:/usr/local/apache-maven-3.8.5 \
-v /var/run/docker.sock:/var/run/docker.sock jenkins/jenkins:2.415

-v /home/jenkins_home:/var/jenkins_home：是对容器内存储Jenkins的一些配置信息的文件夹
-v /usr/local/java/jdk:/usr/local/jdk1.8：是把linux下的jdk和容器内的关联（配置Jenkins时使用）
-v /usr/local/java/apache-maven-3.8.5:/usr/local/apache-maven-3.8.5：是把linux下的maven和容器内的关联（配置Jenkins时使用）

（4）浏览器访问Jenkins页面

输入http://192.168.XX.XX:10240
IP是服务器IP地址
端口号是我们刚刚设置的端口号

（5）获取管理员密码

vim /var/jenkins_home/secrets/initialAdminPassword

复制密码然后登录

（6）安装插件

这里先跳过安装

（7）创建管理员

root
admin

（8）实例配置

url不用动

配置完成
http://192.168.19.7:10240/

（9）通过docker安装的jenkins自带git和JDK，就不需要再安装了

Jenkins本机默认使用“yum -y install git” 安装的 git

docker exec -it myjenkins /bin/bash

git --version

java --version

echo $JAVA_HOME

（10）查看Jenkins版本

滑到最底下，可以看到当前安装的版本是2.328

【五】Jenkins使用

【1】配置插件镜像

滑到下面，找到升级站点

输入：https://mirrors.tuna.tsinghua.edu.cn/jenkins/updates/update-center.json

点击提交，然后重启jenkins：http://localhost:8080/restart

【2】定制安装所需的插件

因为环境网络问题前面跳过了插件的安装，在这一步选择一个简单的jenkins系统所需要的插件。

配置路径：Manage Jenkins>> Manage Plugins

选择所需要插件，点击安装（Install without restart）

有两个重要的插件需要安装：publish over ssh和Maven Integration plugin

（1）安装publish over ssh

我们想把Jenkins打包好的jar包通过SSH发送到远程测试服务器上，在远程测试服务上进行启动使用，所以需要这个插件，安装完插件以后，会在system系统配置里进行配置，也就是添加远程服务器的连接信息，这个后面会讲到

注意：这里直接安装可能会失败，查看失败的详情信息，提示说需要更高版本的Jenkins才可以：Jenkins (2.332.1) or higher required，所以刚开始直接安装的2.4版本Jenkins

那么我们可以换个更低版本的插件来安装试试，插件网址：http://updates.jenkins-ci.org/download/plugins/

查看它前面的版本是否符合要求，下载一个hpi文件，离线方式安装插件：


重启jenkins

（2）安装Maven Integration

然后还有Maven插件

安装完成后重新启动一下

（3）安装中文翻译插件

安装Local和Chinese两个插件
点击【Configure System】选项。
找到【Locale】选项，输入【zh_CN】,勾选下面的选项，最后点击【应用】即可。

（4）安装Git插件

直接搜Git，安装流程如上

【3】开始配置

（1）配置ssh（可跳过，在后面用到的时候配）

Dashboard——》ManageJenkins——》System

配置全局凭据，这个全局凭据看起来高大上，其实挺好理解，就是一个配置项，然后你配置好以后，你就可以通过jenkins登录到你想进入的那台服务器里面，你还可以在那台服务器上执行你设计的指令。而咱们前面安装的publish over ssh插件，就是用来干这事的！

（1）生成ssh私钥和公钥
假设我有两台机器A，B然后我想在A机器上远程登录到B机器上，那么我就应该在A机器中通过ssh生成公钥和私钥，然后把公钥放到B机器中，私钥自己留着。

（2）配置jdk和maven和git

Dashboard——》ManageJenkins——》Tools

（1）配置JDK

点击系统管理，找到全局工具配置

如果是在宿主机里安装的JDK

但是如果使用Docker安装的Jenkins，那么是自带JDK的，我们可以进入到jenkins容器中 echo $JAVA_HOME 获取java环境安装地址

docker exec -it myjenkins /bin/bash

git --version

java --version

echo $JAVA_HOME

获取Jenkins里的jdk路径是【/opt/java/openjdk】

（2）配置maven（选用默认的即可）

进入【首页】–【系统管理】–【全局配置】，拉到最下面maven–maven安装

下载jar包会比较慢，所以还要配置国内的镜像，所以这里也可以用自己安装的maven会更方便使用

（3）配置git

使用默认的，不需要配

点击保存

【4】helloworld项目部署：进阶一：ssh传送jar包然后手动命令启动jar

（1）准备一个springboot的helloworld项目

（1）下载地址
https://how2j.cn/k/springboot/springboot-idea/1641.html

（2）idea打开项目
下载项目文件后，解压，然后使用idea打开

（3）启动项目，测试访问
因为本地8080端口冲突，所以在配置文件里把服务端口改成了8082，启动成功以后访问：http://localhost:8082/hello

如图测试成功，接下来就是把测试成功的项目提交到自己搭建的Gitlab上去了

（4）Gitlab创建项目
首先创建一个空白的项目

（5）Idea工具创建本地仓库
在IDEA中创建好项目，点击VCS，按照下图指示先给项目创建本地Git仓库

然后选择当前项目的文件作为发布的仓库，成功之后看到所有项目文件变成了红色

（6）把项目ADD添加到git缓冲区
点击项目，然后右键，选择最右侧的 “add”，添加之后可以看到所有项目文件变成了绿色

（7）再将项目COMMIT提交到本地仓库
选择最右侧第一个 “Commit Directory…”

点击之后，在弹窗里填写备注信息

提交完成后，可以看到项目的所有文件都变成了白色

（8）把项目PUSH推送到远程仓库
先复制项目在Gitlab的git地址：http://192.168.19.8/root/hello-world.git

然后push项目

然后自定义远程地址

然后点击Push，连接的时候输入root和对应的密码就行了，这样就可以提交上去了

更新项目的话，commit的时候选择你修改的文件，push的时候，对应的url就是你要更新项目仓库的url。这样，gitlab上面仓库里面的项目就是你选择的文件进行修改了。也就是只是局部进行修改。

可以看到项目的代码都已经提交上来了

（2）Jenkins新建任务

（3）到Gitlab的项目里复制克隆路径

hello world项目：http://192.168.19.8/root/hello-world.git

（4）Jenkins的项目配置

（1）源码管理
用的是自己搭建服务器上gitlab的代码，创建的时候已经设置为public了，这里直接用：http://192.168.19.8/root/docker-springboot.git

（2）构建触发器（不改动）

（3）构建环境（不改动）

（4）Pre Steps（不改动）
可以执行一些构建之前的操作

（5）Build（构建）
在Gitlab里面可以看一下pom.xml是不是放在根目录下的，如果还有子目录，下面就要填成***/pom.xml

（6）立即构建

立即构建

因为是第一次构建，maven的仓库里没有jar包，所以全部都要下载，有可能会在下载的过程中就失败，所以构建的过程中要观察一下控制台输出

（7）启动jar包
首先找到构建好的jar包所在位置

cd /var/jenkins_home/workspace/helloworld/target

然后使用命令启动项目

java -jar springboot-0.0.1-SNAPSHOT.jar --server.port=8088

启动成功

查看端口

netstat -tuln | grep 8088

（8）访问测试
访问地址：192.168.19.9:8088/hello

如果访问不通，可能是防火墙的问题，关闭所有防火墙
service firewalld status
service firewalld stop

成功

【5】helloworld项目部署：进阶二：ssh传送jar包然后自动执行java -jar启动jar

（1）介绍

上面已经安装了SSH插件，就是通过SSH把JAR包发送到测试服务器。这里我们要再克隆一个虚拟机服务器，上面只需要安装JDK就行了。

这里想要实现的逻辑就是
（1）本地idea完成代码修改后，把代码提交到192.168.19.8服务器的Gitlab上
（2）然后192.168.19.9服务器上的Jenkins在构建项目的时候，会自动到Gitlab的服务器上拉取代码，然后使用Maven对代码进行打包，生成Jar包
（3）最后192.168.19.9服务器上的Jenkins在打包完成后，把Jar包通过SSH发送到远程测试服务器192.168.19.11上，并且会执行自定义的命令，比如java -jar，完成项目启动

综上，开发人员只需要在idea把代码提交到Gitlab，然后进入Jenkins点一下构建项目，然后就可以在测试服务器上使用部署好的代码了

（2）修改全局配置

目前是一台服务器都没有的，点击新增
1-Name：自己给服务器起个名字
2-HostName：服务器的ip地址
3-Username：登录用户名
4-点击高级，Passwor的：登录密码
5-port：端口默认22
最后点击Test Configuration测试连接，显示Success为连接成功

（3）打开项目配置

上面知道Jenkins打成的Jar包是放在workspace文件夹下的target包里的【springboot-0.0.1-SNAPSHOT.jar】，每次打包的时候后缀【-0.0.1】可能会变

cd /var/jenkins_home/workspace/helloworld/target

配置如下，点击保存

（4）远程服务器开启SSH

（1）首先查看ssh服务没有开启

查看状态：#lssrc -s sshd

如果状态为inoperative说明没有开启：

开启sshd：#startsrc -s sshd

（2）修改配置文件

root用户默认情况下是无法使用ssh连接的。

编辑：#vi /etc/ssh/sshd_config去掉前面的#，并将PermitRootLogin改为yes
#Port 22
#PermitRootLogin yes

（3）启动sshd服务

启动ssh：#startsrc -s sshd

（5）再次构建，查看构建日志

显示传送了一个文件

（6）到远程服务器上看看

看看文件是不是真的传送了

（7）看看jar是否已经自动启动

访问地址：192.168.19.11:8082/hello（因为这次启动没有指定启动端口，而项目yml里配置的端口是8082）

如果访问不通，可能是防火墙的问题，关闭所有防火墙
service firewalld status
service firewalld stop

查看端口

netstat -tuln | grep 8082

【6】helloworld项目部署：进阶三：优化启动命令实现可以反复拉取&构建&启动

（1）这种方式存在的问题

1-问题描述

上面我们在完成jar包的发送后，直接使用【nohup java -jar /root/helloworld/springboot*.jar &】命令来启动jar包，但是这种方式是一次性的，下次构建的时候再启动jar包就会有端口冲突的问题，导致新的jar包启动失败，所以就会发现每次虽然提交了新的代码，jar包也打包成功了，但是构建完成后发现新的代码没有真正的生效。具体的报错我们可以在测试服务器里查看启动日志。

还有就是使用【jps】命令查看虚拟机正在运行的进程信息。

我们正确的操作应该是，在每次启动jar包之前都要检查端口是否被占用，如果占用就查出来是具体哪个线程占用的，然后杀掉线程，之后才进行重新启动jar包。

2-第一步：解决nohup提示导致卡住问题

针对这种情况我们对上面的命令进行优化，换成

nohup java -jar /root/helloworld/springboot*.jar >my.log 2>&1 &

命令分析
（1）nohup：全称是no hang up（不挂起），也就是说，当前交互命令行退出的时候，程序还在运行。
（2）&：表示后台运行，不霸占交互命令行
（3）>my.log 2>&1：数据流重定向，把要输出的信息流指定到my.log文件，并且把标准输出和标准错误输出都写到这个文件里
数据流重定向就是把某个命令执行后应该要出现在屏幕上的数据传输到其他地方
1-标准输入（stdin）：代码为0，使用<或<<
2-标准输出（stdout）：代码为1，使用>或>>
3-标准错误输出（stderr）：diamante为2，使用2>或2>>，其中>为覆盖写，>>为追加写

总结：改成这个命令以后，原本现在屏幕的【nohup：忽略输入并把输出追加到“nohup.out”】的提示语就会被写到指定的文件里，而不会现在屏幕上导致卡住。

3-验证一下

我们最后再来测试一下修改项目代码，然后提交git，最后jenkins构建打包，看看新的代码是不是真的生效了

jenkins构建完成后，我们进入服务器的jar目录看一下
1-看jar包的创建时间，新的jar发送成功了
2-有了新的日志文件my.log，jar包的启动日志就会写入到这个文件里

我们进入my.log文件里看看，提示语写到这里了，不会出现在屏幕上导致卡住了

但是还是有报错内容，提示端口被占用，启动失败，那么我们接下来就要解决端口被占用的问题

（2）手动完成解决“地址已在使用”的问题

（1）启动jar包
当前jar包是第一次启动，我们使用命令

nohup java -jar /root/helloworld/springboot*.jar >my.log 2>&1 &

启动完成后
1-查看jar包同级目录下my.log日志
2-检查端口占用情况
3-检查jar包进程

（2）学习ps -ef命令
我们启动的jar包名字为springboot-0.0.1-SNAPSHOT.jar，ps -ef 命令会显示以下几个字段：

• UID：进程的拥有者
• PID：进程的 ID
• PPID：进程的父进程 ID
• C：进程占用 CPU 的百分比
• STIME：进程启动的时间
• TTY：进程所在的终端设备
• TIME：进程运行的时间
• CMD：进程执行的命令

ps -ef | grep springboot

（3）进一步完善命令

ps -ef | grep java | grep springboot | grep -v grep | awk '{print $2}'

grep java：留下有java关键字的
grep springboot：留下有springboot关键字的
grep -v grep：去除有grep关键字的
awk ‘{print $2}’：打印结果的第二个值，也就是PID，进程的ID

结果也确实是3200

（4）学习netstat -nltp命令
根据端口号查找进程ID

netstat -nltp | grep 8082

（3）最终完善命令

ps -ef | grep springboot-0.0.1-SNAPSHOT.jar | grep -v grep | awk '{printf $2}' | xargs kill -9
nohup java -jar /root/helloworld/springboot*.jar >my.log 2>&1 &

也就是把前面学习的两个命令整合一起执行了，第一行先检查有没有占用端口的进程，如果就杀掉进程，第二行是后台启动jar包，并且把输出的日志内容存进目标日志文件里，不会导致启动命令被卡住

保存以后进程测试，我们只需要在idea的项目里修改代码，然后commit并push，接着直接在jenkins里点击项目构建，结束后访问项目，可以看到代码已经生效了。这种方式可以实现反复的提交构建了。

【7】helloworld项目部署：进阶四：使用start.sh脚本进行启动

上面我们在Post Steps这一步进行执行shell命令，我们也可以把shell命令写到项目的一个启动脚本start.sh里，在打包的时候把启动脚本start.sh一起打包，然后使用ssh把启动脚本start.sh和jar包都发送到目标服务器，最后执行启动这个脚本就可以了

（1）脚本的位置

然后commit和push代码，jenkins执行构建，完成之后，我们看看jar包和start.sh分别放在了哪里

（2）脚本的内容

#!/bin/sh

jar_name=springboot-0.0.1-SNAPSHOT.jar
jar_path=/root/helloworld
log_path=/root/helloworld/logs
log_name=`date +%y-%m-%d`_out.log
jar_port=8082
#指向自定义jdk
#export JAVA_HOME=/xxx/xxx/jdk1.8.0_131
#export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
#export PATH=$JAVA_HOME/bin:$PATH
#sh start.sh restart
stop() {
  echo "开始关闭项目"
  pid=`ps -ef | grep java | grep ${jar_name} | grep -v grep |grep -v gateway| awk '{print$2}'`
  sleep 2
  if [ -z $pid ]; then # -z 是判断是否为空
    echo "${jar_name}未运行！"
  else
    echo "准备关闭进程$pid"
    kill -9 $pid
    sleep 0.5
    echo "${jar_name}已关闭！"
  fi
  echo "关闭操作完成"
}

start() {
  echo "开始启动项目"
  pid=$(ps -ef | grep $jar_name | grep -v grep | awk '{print $2}')
  if [ -z $pid ]; then
    cd $jar_path  # 这里转到jar包目录执行命令，是为了使用jar_path下的config文件，貌似java程序只能识别当前执行命令目录下的配置，否则就是使用已打入Jar包的配置文件。
    # 判断日志文件夹是否存在，不存在则创建
#    if [ ! -d $log_path ];then
#        mkdir $log_path
#    else
#        echo "文件夹已经存在"
#    fi
    nohup java -jar $jar_name >$log_name 2>&1 &
    pid=$(ps -ef | grep $jar_name | grep -v grep | awk '{print $2}')
    sleep 2
    echo "应用 ${jar_name}启动成功，pid=${pid}"
    # tail -f $log_path
 
  else
    echo "应用 ${jar_name} 正在运行，pid = ${pid}"
  fi
  echo "启动项目完成"
}

status() {
  echo "开始检查项目状态"
  pid=$(ps -ef | grep $jar_name | grep -v grep | awk '{print $2}')
  if [ -z $pid ]; then
    echo "应用 ${jar_name} 未运行"
  else
    echo "应用 ${jar_name} 正在运行，pid = ${pid}"
  fi
  echo "检查状态完成"

}
restart() {
  echo "开始重启项目"
  stop
  sleep 2
  echo "停止完成，准备启动jar包"
  start
  echo "重启完成"
}
action() {
  echo "请输入数字选择要执行的操作：1=启动，2=重启，3=停止，4=查看运行状态，5=退出"
  echo '你输入的数字为:'
  read a
  case $a in
  "1")
    start
    ;;
  "2")
    restart
    ;;
  "3")
    stop
    ;;
  "4")
    status
    ;;
  "5")
    exit 1
    ;;
  *)
    echo "输入错误，请重新输入"
    action
    ;;
  esac
}
#action
restart

（3）jenkins的项目配置

主要的操作包括三步
（1）pre steps：在构建前把旧的jar包删除

（2）post steps-1：把jar包通过ssh传送到服务器

（3）post steps-2：把启动脚本start.sh传送到服务器，并且到对应的目录下执行启动命令
注意：想执行远程服务器的脚本，需要先cd /root/helloworld切换到脚本所在的目录，否则构建的时候会报错【ERROR: Exception when publishing, exception message [Exec exit status not zero. Status [127]] 】，127代表的是找不到目标脚本文件。如果没有权限的话，可以到目标服务器使用【chmod 777 start.sh】给启动脚本赋权

【六】jenkins的其他配置

【1】配置参数化构建和自动构建

（1）helloworld项目创建一个新的docker分支

创建新的分支，用来提交作为docker部署的代码，在jenkins构建的时候也要指明构建这个分支的代码，而git的地址就不用变了
1-Newbranch新建一个分支，并且checkout
2-修改文件
3-add-》commit-》push

查看gitlab，看到新的分支代码已经提交

（2）jenkins配置构建的参数

（1）安装Git Parameter插件

（2）修改项目配置
填写 Git Parameter 参数配置
1-Name 自定义参数名称
2-Description 描述
3-Paramert Type 参数类型，可选 Tag 、Branch 、Branch or Tag、Revision、Pull Request
4-Default Value 默认值

指定分支引用上面的变量：${branch}

保存成功后，在job列表页，构建的时候，可以选择- Build with Parameters，接着会自动加载出项目的所有分支，可供选择

【2】钩子函数

（1）进入项目配置

1-选择构建触发器
2-勾选触发远程构建
3-自定义填写一个身份验证令牌
4-注意我们可以使用的钩子链接格式有两种，【JENKINS_URL/job/helloworld/build?token=TOKEN_NAME 或者 /buildWithParameters?token=TOKEN_NAME】

然后保存

（2）测试

在浏览器窗口输入链接：http://192.168.19.9:10240/job/helloworld/build?token=123123

回到jenkins可以看到项目自动构建了

（3）把上面的链接配置到gitlab里面去

如果是直接把这个链接配置到gitlab里，因为gitlab里没有jenkins登录的会话，所以访问也是无效的，我们可以安装插件来解决这个问题。这个插件可以实现匿名的访问jenkins系统

然后进入gitlab配置
Settings-》Webhooks-》Add new webhooks-》填写新的url：http://192.168.19.9:10240/buildByToken/build?job=helloworld&token=123123（这个链接就有了高级权限）


勾选完成后点击Add webhook，会提示本地网络不能访问

我们需要设置一下支持本地请求

（4）设置支持本地请求

在Gitlab 10.6以后的版本为了安全起见，默认不允许向本地网络发送webhook请求，但是可以使用管理员身份修改默认设置！

以管理员身份登录Gitlab后，进入adminarea，点击菜单（首页顶层一行有个小扳手图标）点击进入，接着左侧菜单栏---->settings（设置）下一级---->network（网络）---->outbound requests expend（外发请求）前面打勾（□ Allow requests to the local network from web hooks and services-允许Webhook和服务对本地网络的请求）即可！

保存以后，继续完成上一步的webhook配置操作

（5）测试

（1）可以在gitlab的webhook配置页面直接测试push操作

（2）也可以在IDEA里进行push提交测试

IDEA里提交代码后，可以看到jenkins里开始自动创建了，然后访问页面，看到代码生效了，成功

【七】jenkins部署Docker项目

【1】把helloworld项目结合Dockerfile部署到远程测试服务器

（1）远程测试服务器搭建运行环境，创建镜像运行起来

（1）安装docker
参考如上
（2）安装JDK
参考下一个案例
（3）创建Dockerfile文件，并上传jar包
创建专门用来放dockerfile和jar的文件夹

mkdir -p /root/docker/docker_helloworld

进入创建的专门放置docker文件的文件夹/docker，然后创建一个专属该项目的文件夹/docker_springboot，进入，然后vi Dockerfile创建Dockerfile文件，编辑输入以下内容

cd /root/docker/docker_helloworld
vi Dockerfile

FROM java:8
ENV APP_PATH=/docker/docker_helloworld
WORKDIR $APP_PATH
ADD ./springboot-0.0.1-SNAPSHOT.jar $APP_PATH/helloworld.jar
EXPOSE 8090
ENTRYPOINT ["java","-jar"]
CMD ["helloworld.jar","-Dfile.encoding=GBK", "--server.port=8090"]

最后再手动把jar包传到这个文件夹里

（4）构建镜像和启动容器

进入存放Dockerfile的目录下面

cd /root/docker/docker_helloworld

#docker build –f （dockerfile文件路径） –t 镜像名称:版本  .
docker build -t helloworld:1.0 .

构建完毕，然后启动容器
暴露的端口号是8090

#这里可以使用【镜像id】，也可以使用名称+版本号【helloworld:1.0】
docker run -d -p 8090:8090 --name helloworld helloworld:1.0

（5）访问测试
http://192.168.19.11:8090/hello

至此，手动完成了helloworld项目的docker部署，接下来就是用jenkins实现自动拉取代码和部署

（2）Jenkins新建项目

名称为helloworld_docker

（3）修改全局配置

上面已经配置好远程服务器的信息了，这里不改，直接用

（4）ssh方式一：不删除镜像，只重新构建容器

（1）源码管理
git地址不变，但是分支指定为新的docker分支

（2）Pre Steps

（3）Post Steps

（4）总结
首先，我们已经手动创建了helloworld的镜像，并且创建了容器，已经可以正常访问接口了。现在我们希望更新jar包，那么就在pre操作的时候，删除旧的jar包，并且停止容器，然后ssh发送新的jar包到服务器，最后执行docker start命令启动容器。

注意，整个过程中，镜像是本来就存在的，并且没有改动过！

（5）ssh方式二：删除镜像，重新创建镜像和启动容器

（1）在根目录下创建docker文件夹，添加Dockerfile文件
为了不跟之前的helloworld项目的jar包重名，先把jar包名字改了

然后再项目里添加Dockerfile文件

完整的Dockerfile内容如下

FROM java:8
ENV APP_PATH=/docker/helloworld_docker
WORKDIR $APP_PATH
ADD ./helloworld-docker-0.0.1-SNAPSHOT.jar $APP_PATH/helloworld.jar
EXPOSE 8090
ENTRYPOINT ["java","-jar"]
CMD ["helloworld.jar","-Dfile.encoding=GBK", "--server.port=8090"]

（2）Pre Steps

（3）Post Steps
分两个步骤。第一步发送jar包，jar包在target目录，第二步发送Dockerfile，Dockerfile在target同级的docker目录

（4）给docker.sock权限

chmod a+rw /var/run/docker.sock

（5）构建以后
helloworld文件夹下确实有了新的文件，并且容器重新运行了

如果第一遍Dockerfile已经传送成功了，但是启动没有成功，可能是权限不够，使用【chmod 777 Dockerfile】命令给文件授权，然后再构建一次，后续就可以实现反复构建了

【2】准备一个Docker启动的CRUD项目

（1）远程测试服务器搭建运行环境

（1）安装Docker

看上面

（2）Docker安装Portainer

（1）拉取最新的Portainer镜像

docker pull portainer/portainer

（2）运行镜像（9000）

docker run -d -p 9000:9000 -v /root/portainer:/data -v /var/run/docker.sock:/var/run/docker.sock --name dev-portainer portainer/portainer

或者

docker run -d --restart=always --name portainer -p 9000:9000 -v /var/run/docker.sock:/var/run/docker.sock portainer/portainer

参数说明：

-d #容器在后台运行
-p 9000:9000 # 宿主机9000端口映射容器中的9000端口
-v /var/run/docker.sock:/var/run/docker.sock # 把宿主机的Docker守护进程(docker daemon)默认监听的Unix域套接字挂载到容器中
-v /root/portainer:/data # 把宿主机目录 /root/portainer 挂载到容器 /data 目录；
–name dev-portainer # 指定运行容器的名称

注意：在启动容器时必须挂载本地 /var/run/docker.socker与容器内的/var/run/docker.socker连接。

（3）访问Portainer可视化界面
1-浏览器中输入：服务器的ip地址:9000，访问portainer可视化界面
第一次会弹出安装界面，配置账号密码、选择是本地Docker还是远程Docker，一般我们选择本地Docker，也就是local，可以查看宿主机配置信息、查看容器、镜像、网络、卷等相关信息。

2-创建登录账号和密码

（3）Docker安装Mysql

（1）拉取镜像：docker pull mysql:5.7
（2）查看本地镜像：docker images
（3）创建一个mysql容器，首先在根目录下创建好一个文件夹allenuse

（4）运行容器：docker run -d -p 3306:3306 --privileged=true -v /allenuse/mysql/log:/var/log/mysql -v /allenuse/mysql/data:/var/lib/mysql -v /allenuse/mysql/conf:/etc/mysql/conf.d -e MYSQL_ROOT_PASSWORD=123456 --name mysql5 mysql:5.7

如果报错的话，可能是端口3306被占用了，就用下面的命令解决
1-先查看当前占用端口：netstat -tanlp
2-杀死对应的进程：kill 1330
（5）查看是否创建成功
1-查看容器：docker ps 或者 docker ps -a
2-查看启动日志：docker logs mysql5

（6）新建my.cnf，通过容器卷同步给mysql容器实例（解决中文乱码问题）

cd /allenuse/mysql/conf/

vi my.cnf

[client]
default_character_set=utf8
[mysqld]
collation_server = utf8_general_ci
character_set_server = utf8

（7）重启mysql容器实例，再重新进入并查看字符编码
1-重启：docker restart mysql5
2-查看字符编码：docker exec -it mysql5 /bin/bash

（8）新建库新建表再插入中文测试

（9）如果不小心把mysql的容器删除了如何恢复
之前已经配置了容器卷，mysql的数据已经在本地存储了，只需要重新执行创建容器的命令就行了

docker run -d -p 3306:3306 --privileged=true -v /allenuse/mysql/log:/var/log/mysql -v /allenuse/mysql/data:/var/lib/mysql -v /allenuse/mysql/conf:/etc/mysql/conf.d -e MYSQL_ROOT_PASSWORD=123456 --name mysql5 mysql:5.7

（10）防火墙设置
1-设置mysql 3306 端口：firewall-cmd --zone=public --add-port=3306/tcp --permanent
2-重新加载：firewall-cmd --reload

（11）本地连接


（12）如果3306端口被占用了怎么处理
1-先查看当前占用端口：netstat -tanlp
2-杀死对应的进程：kill 1330

（13）初始化数据库脚本

create database tmall_springboot;
use tmall_springboot;
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- Table structure for category
-- ----------------------------
DROP TABLE IF EXISTS `category`;
CREATE TABLE `category` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=84 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of category
-- ----------------------------
BEGIN;
INSERT INTO `category` VALUES (60, '安全座椅');
INSERT INTO `category` VALUES (64, '太阳镜');
INSERT INTO `category` VALUES (68, '品牌女装');
INSERT INTO `category` VALUES (69, '时尚男鞋');
INSERT INTO `category` VALUES (71, '男士西服');
INSERT INTO `category` VALUES (72, '男士手拿包 ');
INSERT INTO `category` VALUES (73, '男表');
INSERT INTO `category` VALUES (74, '女表');
INSERT INTO `category` VALUES (75, '空调');
INSERT INTO `category` VALUES (76, '冰箱');
INSERT INTO `category` VALUES (77, '原汁机');
INSERT INTO `category` VALUES (78, '扫地机器人 ');
INSERT INTO `category` VALUES (79, '平衡车');
INSERT INTO `category` VALUES (80, '电热水器');
INSERT INTO `category` VALUES (81, '沙发');
INSERT INTO `category` VALUES (82, '马桶');
INSERT INTO `category` VALUES (83, '平板电视');
COMMIT;

（4）Docker安装JDK

（1）查找JDK

docker search jdk

（2）拉取JDK1.8镜像
从上面列表里选取一个拉取

docker pull java

（3）查看下载的镜像

docker images

（4）启动JDK镜像

docker run -di --name=jdk8 java

（5）查看镜像运行情况

docker ps

（6）进入镜像

docker exec -it jdk8 /bin/bash

查看jdk版本

退出镜像

exit

（7）镜像的运维
停止镜像：docker stop jdk8
启动镜像：docker start jdk8
重启镜像：docker restart jdk8
删除容器：

# 1.查看历史所有容器
docker ps -a
# 2.删除容器
docker rm 容器id

（2）创建一个springboot项目

项目创建后，完成以下准备工作
（1）idea连接数据库
首先启动mysql容器

docker start mysql5

然后idea连接mysql，跟上面Navicat连接的过程类似

（2）添加相关的依赖
确认一下springboot版本为2.5.2

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.49</version>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.19</version>
</dependency>
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.3</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>RELEASE</version>
    <scope>compile</scope>
</dependency>
<!--domain.page-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

（3）编写yml配置文件

server:
  port: 8989
  servlet:
    context-path: /docker_springboot
spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/tmall_springboot?characterEncoding=UTF-8&useSSL=false
    username: root
    password: 123456
mybatis:
  mapper-locations: classpath:mapper/*.xml
  type-aliases-package: com.allen.docker_springboot.entity

（4）下载自动生成代码的插件easycode
（5）使用插件自动生成增删改查的代码

（6）查看代码的生成结果

修改启动类，加上扫描路径

（7）启动项目，测试接口
访问地址：http://localhost:8989/docker_springboot/category/64

（3）docker创建网络

docker network create apps

然后查看容器

docker ps

然后把mysql加到网络中去

docker network connect apps e3

最后查看一下网络

docker inspect apps

（4）把项目打成jar包

打成jar包之前，要把yml配置文件里的mysql的ip地址，端口号，密码等信息都换成服务器的，不能直接用localhost。

我们可以直接把ip改成对应服务器的ip来替换localhost，还有另外一种方式，因为上面已经设置了网络，名称为mysql5，所以我们可以直接用mysql5

然后开始打包

（5）创建Dockerfile文件，并上传jar包

创建专门用来放dockerfile和jar的文件夹

mkdir -p /root/docker/docker_springboot

进入创建的专门放置docker文件的文件夹/docker，然后创建一个专属该项目的文件夹/docker_springboot，进入，然后vi Dockerfile创建Dockerfile文件，编辑输入以下内容

cd /root/docker/docker_springboot
vi Dockerfile

FROM java:8
ENV APP_PATH=/docker/docker_springboot
WORKDIR $APP_PATH
ADD ./docker_springboot-0.0.1-SNAPSHOT.jar $APP_PATH/app.jar
EXPOSE 8989
ENTRYPOINT ["java","-jar"]
CMD ["app.jar","-Dfile.encoding=GBK", "--server.port=8989"]

最后再把jar包传到这个文件夹里

（6）用dockerfile构建镜像

进入存放Dockerfile的目录下面

cd /root/docker/docker_springboot

#docker build –f （dockerfile文件路径） –t 镜像名称:版本  .
docker build -t apps:1.0 .

构建完毕
查看镜像，可以看到下面已经有镜像了

docker images

（7）使用镜像创建容器

暴露的端口号是8989

#这里可以使用【镜像id】，也可以使用名称+版本号【apps:1.0】
docker run -d -p 8989:8989 --name apps apps:1.0

这一步我们可以使用–network直接加入网络，也可以在后面再加入，先使用上面的创建命令
docker run -d -p 8989:8989 --name apps --network apps apps:1.0

下面开始加入网络

docker network connect apps 容器id

查看网络

docker inspect apps

查看运行的容器

docker ps

通过【docker logs 容器ID】来查看springboot的日志，看看是不是真的启动成功了

如果有报错，要删除容器和镜像，然后需要重新打包执行

docker ps
停止运行的容器：docker stop 容器id
删除容器：docker rm 容器id
docker images
删除镜像：docker rmi -f 镜像id

或者可以使用下面这个命令启动，不用后台启动了，可以直接查看启动日志

#docker run -p 8989:8989 镜像ID
docker run -p 8989:8989 镜像ID

看到下面的日志说明启动成功了

（8）本地测试

关闭所有防火墙
service firewalld status
service firewalld stop

然后访问地址：http://192.168.19.7:8989/docker_springboot/category/64

【3】使用Jenkins部署上面的Docker项目

上面的案例，我们想把项目打包发送到服务器部署，需要在本地idea里手动的package，然后把jar包发送到服务器里，然后手动构建Dockerfile文件进行启动。而现在我们要实现的是，改完代码以后，只需要点一下commit and push把代码提交到git，然后进入jenkins点一下构建，就可以了。Jenkins会自动去Gitlab拉取最新的代码，然后打成Jar包，然后把Jar包发送到服务器上，最后执行启动。太省事了。

（1）把项目发送到git

（2）Jenkins创建项目，Jenkins配置git，自动拉取代码
（3）Jenkins会把jar包发送到测试服务器

（1）在项目文件里加上Dockerfile

要包含Dockerfile文件，在springboot项目根目录新建一个名为Dockerfile的文件，注意没有后缀名，其内容如下:（大致就是使用jdk8，把jar包添加到docker然后运行prd配置文件）

FROM java:8
ENV APP_PATH=/docker/docker_springboot
WORKDIR $APP_PATH
ADD ./docker_springboot-0.0.1-SNAPSHOT.jar $APP_PATH/app.jar
EXPOSE 8989
ENTRYPOINT ["java","-jar"]
CMD ["app.jar","-Dfile.encoding=GBK", "--server.port=8989"]

Dockerfile文件和pom同级

（2）上传到git

看上面【三】Gitlab的使用

（3）修改全局配置（在上面helloworld项目已经配置过了）

目前是一台服务器都没有的，点击新增
1-Name：自己给服务器起个名字
2-HostName：服务器的ip地址
3-Username：登录用户名
4-点击高级，Passwor的：登录密码
5-port：端口默认22
最后点击Test Configuration测试连接，显示Success为连接成功

（4）Jenkins创建新项目

（5）修改项目的Pre Steps配置

然后修改Pre Steps，在Build构建之前把容器停掉，再把旧的容器和镜像都删除

（6）修改项目的Build配置

再往下就是配置Build，这里要注意，在打包的时候要跳过test单元测试，否则在打包的时候会启动测试，就会测试连接数据库，而我们在jenkins服务器上用项目里的数据源信息是连接不上数据库的，关闭启动测试的方式有两种，一种是在jenkins里配置，还有一种是在pom里加配置

如果不加的话，会有报错

（1）方式一

clean install -Dmaven.test.skip=true

（2）方式二

（7）修改项目的Post Steps配置

（8）立即构建

因为是第一次构建，maven的仓库里没有jar包，所以全部都要下载，有可能会在下载的过程中就失败，所以构建的过程中要观察一下控制台输出

（9）完全使用shell命令的方式

或者使用下面这种shell命令

再往下就是配置就是构建后的操作，这里使用shell命令，以前非docker部署的项目，直接把jar包生成并SSH发送，再执行一个java -jar命令就行了。现在是docker部署的项目了，需要把jar和Dockerfile都复制过去，并且停止删除以前的旧容器，使用新的dockerfile构建新的容器，命令很多，所以使用shell命令来执行

有了之前手动部署docker项目的案例，下面的参数就可以按照上面的案例来了，完整的shell命令如下

#!/bin/bash
# 服务名称
SERVER_NAME=jenkins

# 源jar名称，mvn打包之后，target目录下的jar包名称
JAR_NAME=docker_springboot-0.0.1-SNAPSHOT

# jar包的目录
JENKINS_HOME=/var/jenkins_home/workspace/docker_springboot

# 等待三秒
echo sleep 3s
sleep 1
echo sleep 2s
sleep 1
echo sleep 1s
sleep 1
      
echo "结束进程完成"

cd $JENKINS_HOME/target

cp $JENKINS_HOME/Dockerfile $JENKINS_HOME/target

# 修改文件权限
chmod 755 $JAR_NAME.jar

echo "看看docker能不能用"
docker -v

echo "停止容器"
# 停止容器
docker stop apps

echo "删除容器"
# 删除容器
docker rm apps
echo "删除镜像"
# 删除镜像
docker rmi apps
echo "打包镜像"
# 打包镜像
docker build -t apps:1.0 .
echo "运行镜像"
# 运行镜像，直接加入网络
docker run -d -p 8989:8989 --name apps --network apps apps:1.0

点击保存
我们看到打包成功了，就是在使用docker命令的时候出现权限问题，这是我们要给docker.sock权限就可以解决了！！

报错信息：

Got permission denied while trying to connect to the Docker daemon socket at
 unix:///var/run/docker.sock: Post 
 "http://%2Fvar%2Frun%2Fdocker.sock/v1.24/containers/springboot/stop": dial unix 
 /var/run/docker.sock: connect: permission denied

解决方案：

chmod a+rw /var/run/docker.sock

（10）再次构建

我们发现没有报错，也看到了容器的id

（11）查看Docker镜像是否启动

docker images
docker ps

文章来源地址https://www.toymoban.com/news/detail-674572.html

（12）本地接口访问测试

到了这里，关于【Jenkins】持续集成部署学习的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！