CI_CD(jenkins)公司实战_未完成版

环境准备

#三台服务器,不同的ip
 centos    镜像时：CentOS Linux release 7.6.1810 (Core)
 gitlab-ce 版本是：11.11.3
 jenkins   版本是：2.176.1
 nginx     版本是：1.12.2
 git       版本是：2.21.0 
 mysql     版本是：5.6.44 MySQL Community Server (GPL)
 #在这三台服务器上，自己选定那个服务器安装哪个软件，安装好软件，并设置为开机自启动，启动。
 #git我在gitlab和jenkins上都安装了此次说的版本。

 #jenkins的服务器，把jenkins的配置文件/etc/sysconfig/jenkins这个里面的Jenkins_user设置为root为了省事，注意jenkins服务器上的jdk的版本，要和自己的版本相一致，具体的看官网：
 https://pkg.jenkins.io/redhat-stable/

 #在安装好gitlab-ce的服务器上修改，把这个服务器的ip和gitlab绑定下
 - 先复制一份
   cp /etc/gitlab/gilab.rb_$(date +%F)
 - 修改
  vim /etc/gitlab/gitlab.rb
  把里面的external_url'http://本服务器的IP'

参考网站：

​
http://www.eryajf.net/category/%E6%9C%AF%E4%B8%9A%E4%B8%93%E6%94%BB/%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4/jenkins
  
    http://wcmc.csu.edu.cn/doc/wcmc-GitLab%20User%20Guide.pdf
    https://www.cnblogs.com/linuxk/p/9454071.html
    https://www.cnblogs.com/zeq912/p/10013147.html
    https://docs.gitlab.com/ee/integration/jenkins.html
    https://www.youtube.com/playlist?list=PLOfJyn_hHwP9EMYiiqhEAHESNcgfQuPqG
    http://www.itmuch.com/work/git-repo-sync-with-gitlab-mirrors/
    http://www.itmuch.com/work/git-sum/
    http://www.itmuch.com/about/
    https://juejin.im/post/5c052323518825314143457c
    https://www.bboysoul.com/
    #git的替代工具
    https://www.cnblogs.com/xiuxingzhe/p/9312929.html
    https://www.cnblogs.com/xiuxingzhe/p/9312929.html

下载包地址：

#centos的镜像源：
    http://archive.kernel.org/centos-vault/

#centos的官方镜像：
    http://isoredirect.centos.org/centos/7/isos/x86_64/CentOS-7-x86_64-DVD-1810.iso

#此次的镜像源地址：
    https://archive.kernel.org/centos-vault/7.5.1804/isos/x86_64/CentOS-7-x86_64-DVD-1804.iso  #安装完之后在yum update一下，因为在这个网站找不到1810的源

#Centos下编译安装Mysql5.6.14
    https://www.cnblogs.com/xiongpq/p/3384681.html

#centos最小化安装后的初始化配置：
    https://www.cnblogs.com/tssc/p/11041464.html  #如果上个页面找不到，就找在这个csdn的这个用户  https://www.cnblogs.com/tssc

#git的tar地址：
    https://mirrors.edge.kernel.org/pub/software/scm/git/
  
#git的升级：
    https://www.cnblogs.com/kevingrace/p/8252517.html

#清华源 各个软件地址：
    https://mirrors.tuna.tsinghua.edu.cn/help/gitlab-ce/

#一小时学会git：
https://www.centos.bz/2017/09/%e4%b8%80%e4%b8%aa%e5%b0%8f%e6%97%b6%e5%ad%a6%e4%bc%9agit/
#Nginx的下载地址：
    http://nginx.org/en/download.html

#gitlab合并代码的几种情况：
    https://www.jianshu.com/p/ce9b22f06d56
​
#gitlab-ce的rpm包地址
    https://packages.gitlab.com/gitlab/gitlab-ce
​
#Gitlab使用教程：
    http://wcmc.csu.edu.cn/doc/wcmc-GitLab%20User%20Guide.pdf

#jenkins的rpm包地址：
    https://pkg.jenkins.io/redhat-stable/

#jenkins更新的war包地址，也就是更新了jenkins，注意选择自己的版本，插件的安装也要注意和版本的兼容。
    http://mirrors.jenkins.io/war/latest/jenkins.war

#jenkins插件的官方地址：
    http://updates.jenkins-ci.org/

#jenkins插件的国内源：
    https://mirrors.tuna.tsinghua.edu.cn/jenkins/plugins/
#需要注意的是选择下载对应版本的版本，否则有时候会出现兼容性错误。

#Mysql的tar包地址：
    https://dev.mysql.com/downloads/mysql/5.6.html

#Mysql的官方yum源
    https://dev.mysql.com/downloads/repo/yum/

Jenkins 和 gitlab关联

一、# 在安装有Gilab的服务器上的web页面
    - 1、创建所需的项目（也就是一个文件夹）
    - 2、在gitlab的服务器上用http的方式，找一个自己知道的路径进行克隆项目
        - git clone http://10.10.10.6/root/web1-cicd.git #输入root用户名和gitlab的root的密码
    - 3、把需要更新或者新提交的代码放到刚刚克隆下来的项目下面
    - 4、在这个项目里面进行
        - git add .
        - git commmit -m"本次提交的描述"
        - git push origin master 按照提示输入用户名和密码

二、#转到在安装有jenkins的服务器上的web页面
    - 1、新建一个任务，（任务名尽量写的一眼就能看的明白的）
    - 2、点开这个项目，然后进行项目的配置
    - 3、找到源码管理这个，然后点击git这个
    - 4、把URL填写为gitlab上自己想要那个项目的git方式,这是会有红色的报错信息，暂时不要管，先放在这里

三、#转到在安装有jenkins的服务器上
    - 1、在命令行下生成jenkins的密钥  ssh-keygen -t rsa
    - 2、找到密钥的存放位置ls /root/.ssh/id_rsa(公钥)，/root/.ssh/id_rsa。pub(私钥)
    - 3、把公钥复制一份

四、#转到在gitlab的web页面
    - 1、点击右上角的settings
    - 2、找到ssh密钥，点击进去
    - 3、把在jnekins下刚刚拷贝的 -公钥- 粘贴在这里，起一个名字，然后保存退出
    - 4、找到自己项目，点击进去，然后点击左边的setting，找到Repository也就是库
    - 5、在进去这个库后找到自己Deploy Keys，点击进去，看见下方有一个 Publicly acceccible deploy keys 点击它 Enable，这时在当前会看见左边的Enabled deploy keys 显示为1表示这个库启用这个密钥

五、#转到刚刚的jenkins服务器上的web页面，也就是上面的第二步
    - 1、点击ADD这个小钥匙的标识、点击jenkins进去
    - 2、在Kind的选项  选择：SSH USername with pricate key
    - 3、Username填写root
    - 4、Private Key 点击Enter directly 再次点击ADD
    - 5、然后把上面第三步的jenkins刚刚生成的 -私钥- 复制一份粘贴到这里
    - 6、保存退出
    - 7、在退出后的页面，点击ADD左边那个找到root,这时就不会爆红了

六、#转载在jenkins的服务器上使用linux命令
     - 1、找一个路径，测试是否可以通过密钥的方式去克隆gitlab上的项目  
        例子：
            git clone git@10.10.10.6:root/build-web.git
     - 2、可以克隆下来，然后删除这个项目

七、#转在jenkins的web页面
    - 1、找到刚刚自己创建的任务，点击进去
    - 2、点击Build NOW，会看到下面有一个表示正在输出的小圆球，如果是蓝色的就是正常了，红色就是出错了，需要去排查
    - 3、点击当前页面的Workspace进去，发现内容和Gitlab上的内容一样，则表示成功。

###gitlab对jenkins的关联

八、#转在jenkins的服务器上使用linux命令
    - 1、配置免密登录到指定的服务器，这里采用nginx的页面进行测试。
        - ssh-copy-id root@10.10.10.8(IP为nginx服务器的IP地址)，按照提示输入nginx服务器的root用户的密码。
    - 2、在jenkins服务器上测试免密登陆  ssh 10.10.10.8,可以免密登录到nginx的服务器
    - 3、退出登陆nginx服务器  exit

九、#转在jenkins的web页面
    - 1、选择自己的任务，点击进去，开始配置
    - 2、点击Build 选择 Execute shell
    - 3、填写shell脚本 测试: 例如：pwd ls
    - 4、在当前的jenkins服务器上，找到系统配置（Manage Jenkins）->插件管理(Manage Plugins)
    -> 可选插件（Available）搜索  Gitlab 、 Gitlab Authentication plugin 、 git plugin 、 publish over ssh 这几个插件，并安装
    - 5、在Jenkins的最开始页面，找到系统管理（Manage Jenkins）点击进去 -> 点击第一个系统配置（Configure System） -> 往下拉动页面会有一个Gitlab的出现 -> 填写: Connection： name 随便写这里写为gitlab -> Gilab host URL 写为http://gitlab服务器的ip -> Add添加密钥 -> Kind选择：Gitlab API token -> 在当前页面 保持不动

十、#转到GItlab的服务器的web页面
    - 1、点击右上角，选择settings
    - 2、进去后，点击选择左Access Tokens
    - 3、进去后，Name填写为自定义的，这里没啥要求
    - 4、勾选api这个
    - 5、点击出现的绿色部分，会生成一个数字夹杂字母的字符串，复制一份

十一、# 转到刚刚的jenkins的web页面
    - 1、 把这个字符串似得东西，粘贴到 API token 这里，点击左下角的Add
    - 2、 在跳转后的页面，点击Credentials 右边这个空的，选择当前，因为在上一步，没有定义一个名字，所以这里是选择当前的。 鼠标翻滚到当前页面最后面，保存退出。
    - 3、 新建一个任务，定义一个自己一看就知道是干什么用的名字，选择文件夹，看下面的copy from 填写自己在jenkins上最开始创建的任务，依据前一个任务复制创建一个新的任务
    - 4、在跳转到的页面 找到 Build Triggers 勾选上 Build when a change is pushed to GitLab. GitLab webhook
    - 5、找到 Rebuild open Merge Requests 选择 -> On push to source branch
    - 6、点击右下角的 Advanced... 跳动后， 选择 Filter branches by name Include填写master,点击右下角的 Generate, 会跳出一个字母夹杂这数字的字符串，先保持这个页面不动 继续以下操作。

十二、#在Gitlab的web页面
    - 1、 点击似扳手的图标，在右边，选择设置（setting） -> 选择网络(network) -> 选择外部请求（outbound requests） -> 勾选 Allow requests to the local network from hooks and services -> 保存退出
    - 2、选择并进去自己的项目，也就是第一步最开始在gitlab里新建的仓库（文件夹） -> 在左边选择setting ->选择Integrations
    - 3、在上述步骤选择后跳转的页面会看到有  URL 和 Secret Token这两个，此时保持这个页面不动 
    - 4、转到上述步骤的jenkins的web页面
    - 5、把生成的字符串的这个复制粘贴到gitlab的web页面的 Secret Token 下面，
    - 6、还在jenkins这个有字符串的这个页面，找到 Build when a change is pushed to GitLab. GitLab webhook URL:http://10.10.10.9:8080/project/1017 (这里这个是我的，每个人的都不相同，视自己的为准)，把这个http://10.10.10.9:8080/project/1017复制一份
    - 7、 转到刚刚的gitlab页面 把刚刚复制的粘贴在 URL下面的空白栏，保存退出。

构建测试结果

# 在gitlab的服务器上
    - 1、找一个路径，进行测试
        - git clone http://10.10.10.6/root/build-web.git 按照提示输入用户名和密码，这里我直接用gitlab的root用户名和密码
        - 进入到克隆下来的文件夹，添加或者修改一些东西，主要是为了做个标记
        - git add .
        - git commit -m"本次提交的描述语"
        - git push origin master  按照提示输入用户名和密码，这里我直接用gitlab的root用户名和密码

    - 2、进入到gitlab的web页面，看看自己克隆下来的项目的里面有没有自己刚添加或者修改的文件，
    
 # 转到jenkins的web页面
    - 1、克隆一个已经存在的任务的，并把这个任务起一个自己知道这个任务是用来干什么的名字
    - 2、在上述步骤，跳转后的页面进行修改
    - 3、找到 Source Code Management（源码管理）下面的这个Git
    - 4、看到Repositories（库）右边的 Repository URL:填写上自己在gitlab上创建的库的ssh方式的复制地址  例子: git@10.10.10.6:root/build-web.git
    # 解释一下，因为这里已经配置好了gitlab和jenkins的双向互联，而Gitlab本身就是一个大仓库，在gitlab里面新建的各种的仓库（也就是一个文件夹） 是有很多个的，在这里的 URL 是可以随意变动的，都可以设置成gitlab里面所有自己已经创建好的仓库的ssh方式例如： git@10.10.10.6:root/build-web-111.git，但必须保证这个仓库的下面是自己本次CI/CD想要的东西。
    - 5、在当前页面 找到Build 选择Execute shell
    - 6、在里面定义shell
        这里给出两种的方式：
            6.1 
            如：
             #!/bin/bash
             #源目录为jenkins存放任务文件的目录
             SOURCE_DIR=/var/lib/jenkins/workspace/$JOB_NAME/
             #目标目录为nginx服务器的家目录
             DEST_DIR=/usr/share/nginx/html
             #使用rsync同步源到nginx服务器家目录(需要免密登录)，IP为nginx服务器IP
            /usr/bin/rsync -av --delete $SOURCE_DIR root@10.1.1.14:$DEST_DIR
            #这里注意上面的代码是加了注释的，为了理解，但是在这个页面进行shell定义的时候，尽量不要显示出来，看个人习惯了。
            6.2 
            如：
            echo $BUILD_NUMBER
            tar czvf web-$BUILD_NUMBER.tar.gz ./*
            scp web-$BUILD_NUMBER.tar.gz 10.10.10.67:/usr/share/nginx/html/
            ssh root@10.10.10.67 "cd /usr/share/nginx/html/ ; tar -xf       web-$BUILD_NUMBER.tar.gz"

            #千万注意！！！！！  这个脚本的空格，此处的ip10.10.10.67是自己要把jenkins从gitlab上拉取下来的代码放到制定的目标服务器的IP地址，这里的路径，自己视情况进行修改
            
    - 7、在jenkins的web页面，进行本次任务的构建，如果构建的时候没有出现红色的输出就是正确的，可以在构建后进行输出的查看，查看输出了什么内容，报错也是根据输出的内容进行排错。

回滚和构建，以及在目标主机执行脚本

#进行到这里，只是测试了可以让jenkins从gitlab上拉取代码并根据自己在jenkins设置的简单shell脚本去放到目标主机的指定路径下。但是万一业务有回滚的话，还得继续改造脚本内容。
​
#参考网站：  
https://blog.csdn.net/leo15561050003/article/details/79818176
https://www.jianshu.com/p/35a2c423682b
https://www.jianshu.com/p/00bdc87cd3ee
​
#所谓回滚操作，就是把你之前每次构建时候压缩的包（我这里用了这样的压缩方式：任务名-版本号-年月日-时分秒），根据你需要回滚的版本号（因为构建的时候的压缩方式比较精确，你可以在回滚的时候，清楚你要回滚到哪一步，然后根据构建压缩的方式精确的去回滚），再次覆盖到目标服务器的制定路径下。
​
#在这里是根据当前公司的业务需求，而写的shell脚本，具体情况还得具体分析。
​
#jenkins需要安装的插件如下：
Send build artifacts over SSH
SSH Plugin
Git Plugin
Publish Over SSH
ThinBackup
Gitlab Authentication
GitLab
extended choice parameter
Build Name and Description Setter
Job Configuration History
Build with Parameters
​
# ！！！---在jenkins上自己创建的任务里面进行配置---！！！
​
     1、General -> 勾选 This project is parameterized -> 勾选后显示出来的页面进行如下填写：         Choice Parameter下填写：
        Name:Status   
        Choices:上下两行,一个Deploy,一个Rollback  
        Description: Deploy:发布  RollBack:回滚  
        String Parameter下填写：
        Name：Version
        Default Value: 0 （这里是数字零 0）
        Description:为了回滚时，要选择的版本号（我这里构建时采用了这样的压缩方式：任务名-版本号-年月日-时分秒）
​
    2、在Build里选择Execute shell
#shell脚本内容如下：有scp和rsync两种。
    ##！！！---使用scp---！！！
case $Status in 
    Deploy)
        echo "Status: $Status"        
     
     scp ./*   lewu@192.168.1.133:/data/home/lewu/update/       
     path="/var/lib/jenkins/workspace/${JOB_NAME}_backup/" 
     path1="/var/lib/jenkins/workspace/${JOB_NAME}_backup/buffer/"
     path2="/var/lib/jenkins/workspace/${JOB_NAME}_backup/tar-backup/"  
     
     if [ -d $path || -d $path1 ||  -d $path2 ];then
            echo "The file is already exists!!!"
        else
            mkdir -p $path & mkdir -p $path1 & mkdir -p $path2
        fi        
        echo "Completion!!!" 
     
     cd $path1
     if [ `ls | wc -l` == 2  ];then
            echo "The Buffer1 and buffer2 is already exists!!!"
        else
            mkdir -p $path1/buffer{1..2}
     fi   
     
     cd ${WORKSPACE}
     tar -czvf ${JOB_NAME}-${BUILD_NUMBER}.tar.gz  ./* 
     mv ${JOB_NAME}-${BUILD_NUMBER}.tar.gz  $path2/${JOB_NAME}-${BUILD_NUMBER}-$(date +%Y%m%d-%H-%M-%S).tar.gz
     ssh lewu@192.168.1.133 "sh /data/home/lewu/shell/deploy.sh" 
     echo "Completion!!!"    
        ;;
    Rollback)
        echo "Status: $Status"
        echo "version: $Version"
     path1="/var/lib/jenkins/workspace/${JOB_NAME}_backup/buffer"
     path2="/var/lib/jenkins/workspace/${JOB_NAME}_backup/tar-backup"        
     cd $path2
        find  `ls` | grep $Version | xargs -i cp {}  $path1/buffer1/
     cd $path1/buffer1/
     tar -xvf ./*  -C  $path1/buffer2/ 
     rm -rf ./*          
     cd $path1/buffer2/ 
     scp ./* lewu@192.168.1.133:/data/home/lewu/update/  
     rm -rf ./*  
     ssh lewu@192.168.1.133 "sh /data/home/lewu/shell/deploy.sh" 
     echo "Completion!!!"
        ;;
 *)
    exit
     ;;    
esac
​
##！！！---使用rsync---！！！
case $Status in 
    Deploy)
        echo "Status: $Status"
        rsync -av ./*   -e ssh --exclude='dist' --exclude='buffer'  lewu@192.168.1.133:/data/home/lewu/update/ 
        path="${WORKSPACE}/dist"   
        path1="${WORKSPACE}/buffer/"
        if [ -d $path   || -d $path1 ];then
            echo "The file is already exists!!!"
        else
            mkdir -p $path & mkdir -p $path1
        fi  
        cd $path1 
         if [ `ls | wc -l` == 2  ];then
            echo "The Buffer1 and buffer2 is already exists!!!"
        else
            mkdir -p $path1/buffer{1..2}
        fi  
        cd ${WORKSPACE}
        tar -czf dist/${JOB_NAME}-${BUILD_NUMBER}-$(date +%Y%m%d-%H-%M-%S).tar.gz  *  --exclude=dist   --exclude=buffer
        ssh lewu@192.168.1.133 "sh /data/home/lewu/shell/deploy.sh"    
        echo "Completion!!!"
        ;;
    Rollback)
        echo "Status: $Status"
        echo "version: $Version"
        cd ${WORKSPACE}/dist 
        find  `ls` | grep $Version | xargs -i cp {}  ${WORKSPACE}/buffer/buffer1/
        cd ${WORKSPACE}/buffer/buffer1/
        ls -la
        tar -xf ./*  -C  ${WORKSPACE}/buffer/buffer2/  && rm -rf ./*
        cd ${WORKSPACE}/buffer/buffer2/  
        scp ./* lewu@192.168.1.133:/data/home/lewu/update/  && rm -rf ./*
        ssh lewu@192.168.1.133 "sh /data/home/lewu/shell/deploy.sh"
        ;;
  *)
    exit
        ;;    
esac
​
​
    #脚本解读：
    选择你的动作是构建还是回滚。
        - 构建的时候：
            1、先把jenkins从gitlab指定的仓库拉取过来的东西，远程传输到目标服务器的指定目录下，这里的  --execlude='dist'  --execlude='buffer'是不包含当前的这两个目录。
            2、定义两个变量path和path1
            3、判断path和path是否存在，这两个变量下的目录是不会删除的，所以要判断，而不能用mkdir
            4、进入到变量path1也就是buffer下面
5、判断当前的数量是否是2，如果不是在当前的buffer目录下创建buffer1和buffer2这两个目录
6、进去到workspace
7、进行每次jenkins从gitlab上拉取过来的文档进行压缩，我这里是压缩当前路径下拉取过来的文档到dist的目录下，压缩的文件名例如: www-8-2019-06-26-10:13:45.tar.gz 但是不包含当前路径下的dist和buffer目录。
8、去执行目标服务器的脚本。
- 回滚的时候：
1、进入到workspace的dist目录下
2、寻找你要回滚时在jenkins的web页面输入的要回滚到哪个版本，这里是根据你输入的内容，去之前在构建的时候创建的dist的备份目录里寻找你需要的，然后把这个包复制到/buffer/buffer1/下面
3、进入到buffer1的目录
4、解压缩当前的压缩包，也就是刚刚复制过来的包到/buffer/buffer2/下面，并且删除这个buffer2下面的所有内容
5、进入到buffer2下面
6、把刚从buffer1解压到当前目录下的所有文档，scp到目标服务器的制定路径下，并且清空当前buffer2这个目录下的所有内容。

#在jenkins上每次新建任务的时候，/var/lib/jenkins/workspace/这个默认的路径下，出现你所新建的任务
- 例：
    [root@jenkins workspace]# ll
    total 0
    drwxr-xr-x 4 root root 64 Jun 21 17:29 11111
    drwxr-xr-x 2 root root  6 Jun 24 10:15 11111@tmp
    drwxr-xr-x 5 root root 78 Jun 24 16:52 22222
    drwxr-xr-x 2 root root  6 Jun 25 09:16 22222@tmp
    drwxr-xr-x 5 root root 89 Jun 26 09:37 qqq
    drwxr-xr-x 2 root root  6 Jun 26 09:53 qqq@tmp
    drwxr-xr-x 5 root root 89 Jun 26 09:55 www
    drwxr-xr-x 2 root root  6 Jun 26 10:13 www@tmp
#在这里拿qqq为例，进入到qqq目录下，如下：
    [root@jenkins qqq]# pwd
    /var/lib/jenkins/workspace/qqq
    [root@jenkins qqq]# ll
    total 8
-rw-r--r-- 1 root root  977 Jun 26 09:37 3-Mysql.tar.gz
-rw-r--r-- 1 root root 1306 Jun 26 09:37 3-Public.tar.gz
    drwxr-xr-x 4 root root   36 Jun 26 09:24 buffer
    drwxr-xr-x 2 root root   86 Jun 26 09:51 dist
#这里的 3-Mysql.tar.gz 3-Public.tar.gz 就是每次jenkins从gitlab上拉取过来的文档
#buffer目录就是一个缓冲的目录，用来进行回滚时的操作，上面的脚本有解释作用。

#buffer目录下的内容：
    [root@jenkins buffer]# pwd
    /var/lib/jenkins/workspace/qqq/buffer
    [root@jenkins buffer]# ll
    total 0
    drwxr-xr-x 2 root root 6 Jun 26 09:53 buffer1
    drwxr-xr-x 2 root root 6 Jun 26 09:53 buffer2
#dist目录下的内容：
    [root@jenkins dist]# pwd
    /var/lib/jenkins/workspace/qqq/dist
    [root@jenkins dist]# ll
    total 16
-rw-r--r-- 1 root root 2480 Jun 26 09:24  www-1-2019-06-26-10:10:23.tar.gz
-rw-r--r-- 1 root root 2479 Jun 26 09:28  www-2-2019-06-26-10:10:40.tar.gz
-rw-r--r-- 1 root root 2481 Jun 26 09:37  www-3-2019-06-26-10:11:12.tar.gz
-rw-r--r-- 1 root root 2481 Jun 26 09:51  www-4-2019-06-26-10:11:45.tar.gz
#dist目录下是每次构建完的时候，重新把jenkins从gitlab上拉取来的文档压缩的tar包，就是个备份目录。
​
​
​
​
#！！！---在目标主机上的操作，这里拿的是目标主机安装一个一个nginx和mysql5.6的版本---！！！

# 在nginx上的操作
1、在/root/目录下创建以下这三个目录如下内容：
    [root@nginx ~]# pwd
    /root
    [root@nginx ~]# ll
    total 0
    drwxr-xr-x 2 root root 137 Jun 26 09:53 backup
    drwxr-xr-x 2 root root  23 Jun 26 08:53 shell
    drwxr-xr-x 2 root root   6 Jun 26 10:14 update
#因为jenkins和目标服务器nginx是两台服务器，所以backup是个备份目录，shell是存放shell脚本的目录，下面会有对此次脚本内容并解读，update是jenkins发送过来的文档所在目录。
2、shell目录内容：
    [root@nginx shell]# pwd
    /root/shell
    [root@nginx shell]# ll
    total 4
-rw-r--r-x 1 root root 1298 Jun 26 08:48 deploy.sh （注意这个脚本要有执行权限）

#shell脚本内容：
#!/bin/bash
#定义在/root/update/这个目录下过滤出来的public的tar包（因为我们这里是名为Public.tar.gz的包,具体的视情况而定）。
Public=`ls /root/update/ | grep Public`
​
#定义在/root/update/这个目录下过滤出来的mysql的tar包（因为我们这里是名为Mysql.tar.gz的包，具体的视情况而定）。
Mysql=`ls /root/update/ | grep  Mysql`
​
#定义当前数据库的数据库密码
passwdb='111111'
​
# 定义在/root/update/下面包的数量为多少个
number=`ls /root/update/`
​
cd /root/update/
​
#进行判断选择
#如果这个ls /roo/update/下面的数量为2，就去解压
if [ `ls /root/update/ | wc -l `  == 2 ]; then
tar -zxf $Public
tar -zxf $Mysql
#这里的Mysql.tzr.gz的包里面还有一个起到缓冲作用的game目录，这个game目录下才是真正的sql语句。
for sql_f in `ls /root/update/game/`
do
mysql -uroot -p${passwdb} game < ./game/$sql_f #把数据文件导入库内，这里没有在sql语句中写当导入的时候，删除原来的库或者某一张表，实际上可以写一下，所以测试的时候，每一次都需要自己去删了game库下的game1表。
done
cp -rf  index.html  /usr/share/nginx/html/ #把解压public.tar.gz的文件，也就是index.html，强制覆盖到nginx的测试页面的目录下。
rm -rf  /root/update/game/     #删除刚Mysql.tar.gz解压出来的game目录
rm -rf  /root/update/index.html    #删除index.html
​
mv $Public /root/backup/     #把update目录下的Public.tar.gz的包移动到备份目录update下
mv $Mysql  /root/backup/     #把update目录下的Mysql.tar.gz的包移动到备份目录update下
elif [ `ls /root/update/ | wc -l`  == 1 ]; then   # 如果这个update目录下的数量为1
tar -zxf $number   # 解压这个包
if [ `echo  | ls /root/update/  | grep game | wc -l` == 1 ]; then
for sql_f in `ls /root/update/game/`
do
mysql -uroot -p${passwdb} game < ./game/$sql_f
done
rm -rf game/
elif [ `echo | ls /root/update/  | grep index | wc -l` == 1 ]; then
cp -rf index.html /usr/share/nginx/html/
rm -rf index.html
fi
mv $number /root/backup/
else
echo "需要带更新文件名作为参数！！"
​
fi

问题：

# 版本库的 .git 过于太大，导致克隆仓库的代码时，速度很慢
    - 解决：
            https://rtyley.github.io/bfg-repo-cleaner/   
     - 注意：上述解决办法，需要下载这个工具，然后按照步骤一步步来。
     - 还有下面这个
            https://www.cnblogs.com/lout/p/6111739.html