【一】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:latestgitlab/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) FOSSGitLab Shell: 13.22.2PostgreSQL:   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/extexport 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/extexport 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/bashgit --versionjava --versionecho $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/bashgit --versionjava --versionecho $JAVA_HOME

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

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

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

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

（3）配置git

使用默认的，不需要配

点击保存

【4】使用Jenkins部署springboot的helloworld项目（最易启动）

（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项目部署到远程测试服务器上

（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】配置参数化构建和自动构建

（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，接着会自动加载出项目的所有分支，可供选择

【7】把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文件

（2）Pre Steps

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

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

（6）流水线方式三：使用流水线部署

（7）shell方式三：使用shell脚本执行

（8）方式四：项目中使用自定义sh启动脚本

【8】准备一个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: 8989servlet:context-path: /docker_springboot
spring:datasource:type: com.alibaba.druid.pool.DruidDataSourcedriver-class-name: com.mysql.jdbc.Driverurl: jdbc:mysql://localhost:3306/tmall_springboot?characterEncoding=UTF-8&useSSL=falseusername: rootpassword: 123456
mybatis:mapper-locations: classpath:mapper/*.xmltype-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

【9】使用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）修改jenkins里docker_springboot项目的配置

再往下就是配置就是构建后的操作，这里使用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 1echo "结束进程完成"cd $JENKINS_HOME/targetcp $JENKINS_HOME/Dockerfile $JENKINS_HOME/target# 修改文件权限
chmod 755 $JAR_NAME.jarecho "看看docker能不能用"
docker -vecho "停止容器"
# 停止容器
docker stop appsecho "删除容器"
# 删除容器
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

点击保存

（6）搭建jenkins服务器的运行环境

虽然最终jar包是在远程测试服务器上启动运行的，但是要在jenkins服务器上打包，上面我们在远程测试服务器上安装了JDK和Mysql，现在我们在jenkins服务器上也要安装JDK和Mysql。

刚开始Docker安装Jenkins的时候已经自带JDK了，那么这里我们只要安装Mysql就行了，安装过程就把上面手动部署docker项目的过程复制一遍就可以了，保证在打包的时候yml里的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;

（14）docker创建网络并把mysql加进去

docker network create apps

然后查看容器

docker ps

然后把mysql加到网络中去

docker network connect apps e3

（5）立即构建

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

（6）控制台输出报错

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

报错信息：

Got permission denied while trying to connect to the Docker daemon socket atunix:///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

（7）再次构建

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

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

docker images
docker ps

（9）本地接口访问测试