云原生系列 - Jenkins

前言

1. 学习视频：【尚硅谷】Jenkins教程（从配置到实战）
2. 本内容仅用于个人学习笔记，如有侵扰，联系删

0、Jenkins

Jenkins，原名 Hudson，2011 年改为现在的名字。它是一个开源的实现持续集成的软件工具。

• 官方网站（英文）：https://www.jenkins.io/
• 官方网站（中文）：https://www.jenkins.io/zh/

0.1、Jenkins + Git + Maven 自动化部署流程

0.2、环境准备

我们需要三台服务器

服务器名	ip	准备条件
Jenkins-GitLab-ssh	192.168.119.134	至少4C、5G
Jenkins-Server	192.168.119.135	安装jdk1.8、git、maven
TestServer	192.168.119.129	安装jdk1.8

1、GitLab安装使用

官方网站：https://about.gitlab.com/

安装所需最小配置

内存至少4G

https://docs.gitlab.cn/jh/install/requirements.html

1.1、在ssh下安装

官方安装文档：https://gitlab.cn/install/?version=ce

1.1.0、配置阿里云yum源

要配置阿里云的 Yum 源，以下是在 CentOS 7 上的具体步骤：

1. 备份现有的 Yum 配置（可选）：

   在修改 Yum 配置之前，建议备份当前的 Yum 配置文件，以防意外情况。

   sudo cp /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.backup
   

2. 下载阿里云的 Yum 配置文件：

   使用 curl 命令下载适合 CentOS 7 的阿里云 Yum 配置文件。

   sudo curl -o /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
   

   这将从阿里云下载 CentOS 7 的 Yum 配置文件并保存到 /etc/yum.repos.d/ 目录中。

3. 清理 Yum 缓存并生成缓存：

   下载完配置文件后，清理旧的 Yum 缓存并重新生成缓存。

   sudo yum clean all
   sudo yum makecache
   

   这将确保 Yum 使用新的阿里云镜像源。

4. 验证 Yum 配置是否生效：

   运行 yum repolist 命令来查看 Yum 配置是否正确生效，并列出可用的软件包仓库。

   yum repolist
   

   如果列表显示来自阿里云的镜像源，那么配置就生效了。
   

1.1.1、安装依赖

sudo yum install -y curl policycoreutils-python openssh-server perl
sudo systemctl enable sshd
sudo systemctl start sshd

1.1.2、配置镜像

curl -fsSL https://packages.gitlab.cn/repository/raw/scripts/setup.sh | /bin/bash

1.1.3、开始安装

sudo EXTERNAL_URL="http://192.168.119.134" yum install -y gitlab-jh

除非您在安装过程中指定了自定义密码，否则将随机生成一个密码并存储在 /etc/gitlab/initial_root_password 文件中(出于安全原因，24 小时后，此文件会被第一次 gitlab-ctl reconfigure 自动删除，因此若使用随机密码登录，建议安装成功初始登录成功之后，立即修改初始密码）。使用此密码和用户名 root 登录。

1.1.4、gitlab常用命令

gitlab-ctl start                  # 启动所有 gitlab 组件；
gitlab-ctl stop                   # 停止所有 gitlab 组件；
gitlab-ctl restart                # 重启所有 gitlab 组件；
gitlab-ctl status                 # 查看服务状态；
gitlab-ctl reconfigure            # 启动服务；
vi /etc/gitlab/gitlab.rb         # 修改默认的配置文件；
gitlab-ctl tail                   # 查看日志；

1.2、在docker下安装

https://docs.gitlab.cn/jh/install/docker.html

安装所需最小配置

• 内存至少4G
• 系统内核至少在3.10以上 uname -r 命令可查看系统内核版本

1.2.1、安装docker

1. 更新yum源

   yum update
   

2. 安装依赖

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

3. 添加镜像

   #国外镜像
   yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
   #阿里镜像
   https://mirrors.aliyun.com/docker-ce/linux/centos/gpg
   yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
   

4. 查看源中可使用版本

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

5. 安装指定版本

   yum install docker
   

6. 配置开机启动项

   systemctl start docker
   systemctl enable docker
   docker version
   

1.2.2、使用容器安装gitlab

1.添加容器

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

2.启动容器

docker start gitlab

3.查看已存在的容器

docker ps -a

4.进入容器

docker exec -it  gitlab /bin/bash

1.2.3、访问

http://192.168.119.134

当首次运行出现502错误的时候排查两个原因

1. 虚拟机内存至少需要4g
2. 稍微再等等刷新一下可能就好了

1.2.4、管理员账号登录

用户名：root

密码存在下面文件中，登录后需要改密码不然24小时之后会失效

cat /etc/gitlab/initial_root_password

登录成功之后

1. 修改root用户密码
   
   
2. 根据新的账号：root、密码：Wts123456 再次登录，然后把gitLab切换成中文
   
   

1.3、创建一个项目

1. 点击创建项目
   
   
2. 填写项目名称，选择项目URL、选择可见性级别，点击创建项目
   
3. 效果
   

2、Jenkins安装

官方文档介绍非常详细

• 官方网站（英文）：https://www.jenkins.io/
• 官方网站（中文）：https://www.jenkins.io/zh/

安装需求

机器要求：

256 MB 内存，建议大于 512 MB

10 GB 的硬盘空间（用于 Jenkins 和 Docker 镜像）

需要安装以下软件：

Java 8 ( JRE 或者 JDK 都可以)

Docker （导航到网站顶部的Get Docker链接以访问适合您平台的Docker下载）

2.1、安装JDK

2.1.1、安装JRE

1. 检索可用包

   yum search java|grep jdk
   

2. 安装

   yum install java-1.8.0-openjdk
   

3. 测试

   [root@localhost ~]# java -version
   openjdk version "1.8.0_412"
   OpenJDK Runtime Environment (build 1.8.0_412-b08)
   OpenJDK 64-Bit Server VM (build 25.412-b08, mixed mode)
   

   默认yum安装java的时候会显示安装的是openjdk1.8 实则实际上只安装了jre

2.1.2、安装JDK

1. 安装

   yum install -y java-devel
   

2. 结果
   
3. javahome配置(可选)

   • 配置profile文件
     编辑profile配置文件: vim /etc/profile

     [root@localhost ~]# vi /etc/profile
     

     我们当前jdk的路径在/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.412.b08-1.el7_9.x86_64
     输入i进入编辑模式,在最下面补充配置信息,补充完后按Esc退出编辑模式后,输入:wq进行保存并退出

     export JAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.412.b08-1.el7_9.x86_64
     export JRE_HOME=${JAVA_HOME}/jre
     export CLASSPATH=.:${JAVA_HOME}/lib:${JRE_HOME}/lib:$CLASSPATH
     export JAVA_PATH=${JAVA_HOME}/bin:${JRE_HOME}/bin
     export PATH=$PATH:${JAVA_PATH}	
     

   • 配置文件生效

     source /etc/profile
     

   • 查看JDK版本信息:

     java -version
     

2.2、Maven安装

官网：https://maven.apache.org/

2.2.1、安装

下载后复制到Jenkins所在服务器解压缩即可

[root@localhost ~]# tar -zxvf apache-maven-3.8.6-bin.tar.gz

[root@localhost ~]# mv apache-maven-3.8.6 /usr/local/maven

[root@localhost ~]# /usr/local/maven/bin/mvn

[root@localhost ~]# /usr/local/maven/bin/mvn -v
Apache Maven 3.8.6 (84538c9988a25aec085021c365c560670ad80f63)
Maven home: /usr/local/maven
Java version: 1.8.0_412, vendor: Red Hat, Inc., runtime: /usr/lib/jvm/java-1.8.0-openjdk-1.8.0.412.b08-1.el7_9.x86_64/jre
Default locale: zh_CN, platform encoding: UTF-8
OS name: "linux", version: "3.10.0-1160.el7.x86_64", arch: "amd64", family: "unix"

2.2.2、Maven阿里云镜像

修改/usr/local/maven/conf/settings.xml

<?xml version="1.0" encoding="UTF-8"?>

<!--
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements.  See the NOTICE file
distributed with this work for additional information
regarding copyright ownership.  The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License.  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied.  See the License for the
specific language governing permissions and limitations
under the License.
-->

<!--
 | This is the configuration file for Maven. It can be specified at two levels:
 |
 |  1. User Level. This settings.xml file provides configuration for a single user,
 |                 and is normally provided in ${user.home}/.m2/settings.xml.
 |
 |                 NOTE: This location can be overridden with the CLI option:
 |
 |                 -s /path/to/user/settings.xml
 |
 |  2. Global Level. This settings.xml file provides configuration for all Maven
 |                 users on a machine (assuming they're all using the same Maven
 |                 installation). It's normally provided in
 |                 ${maven.conf}/settings.xml.
 |
 |                 NOTE: This location can be overridden with the CLI option:
 |
 |                 -gs /path/to/global/settings.xml
 |
 | The sections in this sample file are intended to give you a running start at
 | getting the most out of your Maven installation. Where appropriate, the default
 | values (values used when the setting is not specified) are provided.
 |
 |-->
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">
  <!-- localRepository
   | The path to the local repository maven will use to store artifacts.
   |
   | Default: ${user.home}/.m2/repository
  <localRepository>/path/to/local/repo</localRepository>
  -->
  <localRepository>${user.home}/.m2/repository</localRepository>
  <!-- interactiveMode
   | This will determine whether maven prompts you when it needs input. If set to false,
   | maven will use a sensible default value, perhaps based on some other setting, for
   | the parameter in question.
   |
   | Default: true
  <interactiveMode>true</interactiveMode>
  -->

  <!-- offline
   | Determines whether maven should attempt to connect to the network when executing a build.
   | This will have an effect on artifact downloads, artifact deployment, and others.
   |
   | Default: false
  <offline>false</offline>
  -->

  <!-- pluginGroups
   | This is a list of additional group identifiers that will be searched when resolving plugins by their prefix, i.e.
   | when invoking a command line like "mvn prefix:goal". Maven will automatically add the group identifiers
   | "org.apache.maven.plugins" and "org.codehaus.mojo" if these are not already contained in the list.
   |-->
  <pluginGroups>
    <!-- pluginGroup
     | Specifies a further group identifier to use for plugin lookup.
    <pluginGroup>com.your.plugins</pluginGroup>
    -->
    <pluginGroup>org.mortbay.jetty</pluginGroup>
  </pluginGroups>

  <!-- proxies
   | This is a list of proxies which can be used on this machine to connect to the network.
   | Unless otherwise specified (by system property or command-line switch), the first proxy
   | specification in this list marked as active will be used.
   |-->
  <proxies>
    <!-- proxy
     | Specification for one proxy, to be used in connecting to the network.
     |
    <proxy>
      <id>optional</id>
      <active>true</active>
      <protocol>http</protocol>
      <username>proxyuser</username>
      <password>proxypass</password>
      <host>proxy.host.net</host>
      <port>80</port>
      <nonProxyHosts>local.net|some.host.com</nonProxyHosts>
    </proxy>
    -->
  </proxies>

  <!-- servers
   | This is a list of authentication profiles, keyed by the server-id used within the system.
   | Authentication profiles can be used whenever maven must make a connection to a remote server.
   |-->
  <servers>
    <!-- server
     | Specifies the authentication information to use when connecting to a particular server, identified by
     | a unique name within the system (referred to by the 'id' attribute below).
     | 
     | NOTE: You should either specify username/password OR privateKey/passphrase, since these pairings are 
     |       used together.
     |
    <server>
      <id>deploymentRepo</id>
      <username>repouser</username>
      <password>repopwd</password>
    </server>
    -->
    
    <!-- Another sample, using keys to authenticate.
    <server>
      <id>siteServer</id>
      <privateKey>/path/to/private/key</privateKey>
      <passphrase>optional; leave empty if not used.</passphrase>
    </server>
    -->
    <server>
        <id>releases</id>
        <username>ali</username>
        <password>ali</password>
      </server>
      <server>
        <id>Snapshots</id>
        <username>ali</username>
        <password>ali</password>
      </server>
  </servers>

  <!-- mirrors
   | This is a list of mirrors to be used in downloading artifacts from remote repositories.
   |
   | It works like this: a POM may declare a repository to use in resolving certain artifacts.
   | However, this repository may have problems with heavy traffic at times, so people have mirrored
   | it to several places.
   |
   | That repository definition will have a unique id, so we can create a mirror reference for that
   | repository, to be used as an alternate download site. The mirror site will be the preferred
   | server for that repository.
   |-->
  <mirrors>
    <!-- mirror
     | Specifies a repository mirror site to use instead of a given repository. The repository that
     | this mirror serves has an ID that matches the mirrorOf element of this mirror. IDs are used
     | for inheritance and direct lookup purposes, and must be unique across the set of mirrors.
     |
    <mirror>
      <id>mirrorId</id>
      <mirrorOf>repositoryId</mirrorOf>
      <name>Human Readable Name for this Mirror.</name>
      <url>http://my.repository.com/repo/path</url>
    </mirror>
     -->
    <mirror>
      <!--This sends everything else to /public -->
      <id>nexus</id>
      <mirrorOf>*</mirrorOf> 
      <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
    </mirror>
    <mirror>
      <!--This is used to direct the public snapshots repo in the 
          profile below over to a different nexus group -->
      <id>nexus-public-snapshots</id>
      <mirrorOf>public-snapshots</mirrorOf> 
      <url>http://maven.aliyun.com/nexus/content/repositories/snapshots/</url>
    </mirror>
    <mirror>
      <!--This is used to direct the public snapshots repo in the 
          profile below over to a different nexus group -->
      <id>nexus-public-snapshots1</id>
      <mirrorOf>public-snapshots1</mirrorOf> 
      <url>https://artifacts.alfresco.com/nexus/content/repositories/public/</url>
    </mirror>
  </mirrors>

  <!-- profiles
   | This is a list of profiles which can be activated in a variety of ways, and which can modify
   | the build process. Profiles provided in the settings.xml are intended to provide local machine-
   | specific paths and repository locations which allow the build to work in the local environment.
   |
   | For example, if you have an integration testing plugin - like cactus - that needs to know where
   | your Tomcat instance is installed, you can provide a variable here such that the variable is
   | dereferenced during the build process to configure the cactus plugin.
   |
   | As noted above, profiles can be activated in a variety of ways. One way - the activeProfiles
   | section of this document (settings.xml) - will be discussed later. Another way essentially
   | relies on the detection of a system property, either matching a particular value for the property,
   | or merely testing its existence. Profiles can also be activated by JDK version prefix, where a
   | value of '1.4' might activate a profile when the build is executed on a JDK version of '1.4.2_07'.
   | Finally, the list of active profiles can be specified directly from the command line.
   |
   | NOTE: For profiles defined in the settings.xml, you are restricted to specifying only artifact
   |       repositories, plugin repositories, and free-form properties to be used as configuration
   |       variables for plugins in the POM.
   |
   |-->
   <profiles> 
    <profile>
      <id>development</id>
      <repositories>
        <repository>
          <id>central</id>
          <url>http://central</url>
          <releases><enabled>true</enabled><updatePolicy>always</updatePolicy></releases>
          <snapshots><enabled>true</enabled><updatePolicy>always</updatePolicy></snapshots>
        </repository>
      </repositories>
     <pluginRepositories>
        <pluginRepository>
          <id>central</id>
          <url>http://central</url>
          <releases><enabled>true</enabled><updatePolicy>always</updatePolicy></releases>
          <snapshots><enabled>true</enabled><updatePolicy>always</updatePolicy></snapshots>
        </pluginRepository>
      </pluginRepositories>
    </profile>
    <profile>
      <!--this profile will allow snapshots to be searched when activated-->
      <id>public-snapshots</id>
      <repositories>
        <repository>
          <id>public-snapshots</id>
          <url>http://public-snapshots</url>
          <releases><enabled>false</enabled></releases>
          <snapshots><enabled>true</enabled><updatePolicy>always</updatePolicy></snapshots>
        </repository>
      </repositories>
     <pluginRepositories>
        <pluginRepository>
          <id>public-snapshots</id>
          <url>http://public-snapshots</url>
          <releases><enabled>false</enabled></releases>
          <snapshots><enabled>true</enabled><updatePolicy>always</updatePolicy></snapshots>
        </pluginRepository>
      </pluginRepositories>
    </profile>
  </profiles>
 
   <activeProfiles>
    <activeProfile>development</activeProfile>
    <activeProfile>public-snapshots</activeProfile>
   </activeProfiles>

  <!-- activeProfiles
   | List of profiles that are active for all builds.
   |
  <activeProfiles>
    <activeProfile>alwaysActiveProfile</activeProfile>
    <activeProfile>anotherAlwaysActiveProfile</activeProfile>
  </activeProfiles>
  -->
</settings>

2.3、安装Jenkins

2.3.1、安装

1. 下载war包

   下载地址：https://get.jenkins.io/war-stable/

   这里我们选择2.346.1版本
   
   
   

2. 运行

   java -jar jenkins.war
   

   首次启动war包会在/root/.jenkins生成配置文件

   待完全启动成功后 访问服务器8080端口完成配置

   初始化后的密码：

   Jenkins initial setup is required. An admin user has been created and a password generated.
   Please use the following password to proceed to installation:
   
   47cdd39226a34cafb684576a843159c0
   

   密码文件使用后会自动删除

3. 访问：http://192.168.119.135:8080/

   在游览器上展示页面如下，就可以进行初始化了，将 管理员账户密码 复制到对应的地方，点击 继续
   

4. 选择安装推荐的插件
   
   这里建议点击 选择插件来安装，在点击 无 ，不安装任何插件，再点击 安装，因为我们没有配置镜像，安装插件是从外网下载过来的，会比较慢，并且下载的插件可能会出现不兼容等状况，导致失败率很高
   

   注意： 我们发现安装推荐的插件失败，因为我们没有配置镜像，安装插件是从外网下载过来的，会比较慢，并且下载的插件可能会出现不兼容等状况，导致失败率很高。我们先继续，后面再配置镜像下载。参考文档：https://blog.csdn.net/xhmico/article/details/136535498

5. 进入到创建管理员页面，填写账户信息后 保存并完成

   • username：wts
   • password：Wts123456
     

6. 进入以下页面配置 jenkins 的 url ，一般使用默认的就行了，保存并完成
   

7. 初始化完成
   

8. 可以点击 开始使用 Jenkins 直接登录进入 Jenkins
   

2.3.2、配置镜像地址

之前启动 Jenkins 时会打印出管理员账户密码所在文件，例如：/root/.jenkins/secrets/initialAdminPassword，/root/.jenkins 就是 jenkins 的工作目录，在 jenkins 的工作目录 .jenkins 中，找到 hudson.model.UpdateCenter.xml 文件打开
将 https://updates.jenkins.io/update-center.json 替换成国内镜像网址并 保存

• 国内镜像网址：https://mirrors.tuna.tsinghua.edu.cn/jenkins/updates/update-center.json
• 国外镜像网址：https://mirror.xmission.com/jenkins/updates/update-center.json

再进入到 updates 目录下，编辑 default.json 文件，将该文件中国外的地址全部替换成国内的

• https://www.google.com 全部替换成 https://www.baidu.com
  
• https://updates.jenkins.io/download 全部替换成 https://mirrors.tuna.tsinghua.edu.cn/jenkins
  

2.3.3、常用插件的安装

Jenkins 相当于一个平台，它很多的功能都是通过对应的插件去实现的，所以插件安装对于使用 Jenkins 非常的重要

在 Jenkins 中常用的插件如下：

• Folders
• OWASP Markup Formatter
• Build Timeout
• Credentials Binding
• Timestamper
• Workspace Cleanup
• Ant
• Gradle
• Pipeline
• GitHub Branch Source
• Pipeline:GitHub Groovy Libraries
• Pipeline:Stage View
• Git
• SSH Build Agents
• Matrix Authorization Strategy
• PAM Authentication
• LDAP
• Email Extension
• Mailer
• Dark Theme
• Localization: Chinese (Simplified)
• Maven Integration

下面我以安装插件 Locale 为例，演示安装插件的大概步骤

访问 Jenkins ，选择 Manage Jenkins

选择 Manage Plugins

选择 Available

搜索栏中搜索 Locale

如果下载页面没有红色的警告，点击 Download now and install after restart 就会下载最新版本的插件，安装并重启。

如果有类似：Warning: This plugin is built for Jenkins 2.426.2 or newer. Jenkins will refuse to load this plugin if installed. 这样的提示，就表明当前插件的版本和你所下载的 Jenkins 的版本不兼容，很大概率会安装不成功，这个时候就需要去下载兼容该 Jenkins 版本的插件

点击插件的名称，打开该插件对应的网址

点击 Releases

再点击 checksums，就可以看到插件对应的版本了

比如说我下载的 Jenkins 版本是 2.346.1，那我下载 180.v207501dff9b_a_，点击即可

插件下载完成

回到 Jenkins 中，点击 Advanced

下拉找到 Deploy Plugin，这里可以上传本地下载好的插件，上传完之后点击 Deploy

就会开始安装该插件

可以在 Installed 中看到刚刚手动安装的插件了

搜索插件 Localization: Chinese

按照上述方式进行安装

安装好之后就重启 Jenkins 使该插件生效

重启方法：在 URL 的后面加上 restart，例如：http://192.168.119.135:8080/restart

点击 Yes 即可重启

重启完成，再次登录并选择 Manage Jenkins

选择 Configure System

找到 Locale 选项，输入 zh_CN 勾选下面的选项，点击 Apply 和 save

重启之后可以看到汉化完成

3、Jenkins + Git + Maven 自动化部署配置

3.1、新建Item

3.1.1、Git配置

1. git安装
   在Jenkins环境服务下安装git

   yum install git
   

2. git配置
   

3.1.2、Maven配置

3.1.3、Pom.xml配置

3.1.4、构建

点击按钮，就可以一键构建

我们可以看到构建成功，并且jar包存到到.jenkins/workspace/first/demo-01/target

我们查看是否有jar包，并且运行该jar包测试

3.2、publish over ssh 配置

3.2.1、安装插件

在 Manage Jenkins 菜单里 -> System Configuration -> Manage Plugins 安装插件 Publish Over SSH

3.2.2、添加一台目标服务器

1. Manage Jenkins -> System Configuration -> Configure System
2. 找到 Publish over SSH 位置，点击 新增
   
3. 填写服务器信息
   
4. 点击高级，输入目标服务器密码
   
5. 点击测试，显示success，则代表服务配置成功，最后点击保存即可。
   

3.2.3、配置

1. 点击任务列的first
   
2. 点击配置
3. 点击 Add post-build setp -> Send files or execute commands over SSH
   
4. 修改配置
   
   
   注意：我这里不知道是测试服务器TestServer的jdk环境变量配置的问题，还是权限问题，没法通过该方法直接运行java命令，只能指定jdk路径运行jar包，这里我的启动命令为
   nohup /usr/java/jdk1.8.0_341/bin/java -jar /root/xxoo/demo*.jar> nohup.out 2>&1 &

1)、超时机制

输出命令时一定要注意不要让窗口卡住，不然Jenkins会认为认为一直没完成

2)、shell的日志输出

nohup java -jar /root/xxoo/demo*.jar >nohup.out 2>&1 &

3)、数据流重定向

数据流重定向就是将某个命令执行后应该要出现在屏幕上的数据传输到其他地方

标准输入（stdin）：代码为0，使用<或<<;
标准输出（stdout）：代码为1，使用>或>>;
标准错误输出（stderr）：代码为2，使用2>或2>>

> 覆盖写
>> 追加写

3.3、运行前清理

1. 先在测试服务器TestServer编写一个脚本x.sh，jenkins在运行前会调用该脚本进行清理jar包和进程

   #!/bin/bash
   
   #删除历史数据
   rm -rf xxoo
   
   appname=$1
   #获取传入的参数
   echo "arg:$1"
   
   
   #获取正在运行的jar包pid
   pid=`ps -ef | grep $1 | grep 'java -jar' | awk '{printf $2}'`
   
   echo $pid
   
   #如果pid为空，提示一下，否则，执行kill命令
   if [ -z $pid ];
   #使用-z 做空值判断
           then
                   echo "$appname not started"
   
           else
                  kill -9 $pid
                   echo "$appname stoping...."
   
   check=`ps -ef | grep -w $pid | grep java`
   if [ -z $check ];
   
           then
                   echo "$appname pid:$pid is stop"
           else
                   echo "$appname stop failed"
   
   fi
   
   
   fi
   

2. 修改x.sh的权限，不然没法调用该脚本

   chmod 777 ./x.sh
   

   

3. jenkins配置杀死之前运行的进程
   

4. 修改代码内容，提交到git上，重新在构建部署，查看结果
   修改“com.wts.TestController”类，代码如下：

   @RestController
   public class TestController {
   
       @RequestMapping("/")
       public String test() {
           return "hello word，welcome";
       }
   }
   

构建部署之后，访问：http://192.168.119.128:8888

3.4、几种构建方式

• 快照依赖构建/Build whenever a SNAPSHOT dependency is built
  • 当依赖的快照被构建时执行本job
• 触发远程构建 (例如,使用脚本)
  • 远程调用本job的restapi时执行本job
• job依赖构建/Build after other projects are built
  • 当依赖的job被构建时执行本job
• 定时构建/Build periodically
  • 使用cron表达式定时构建本job
• 向GitHub提交代码时触发Jenkins自动构建/GitHub hook trigger for GITScm polling
  • Github-WebHook出发时构建本job
• 定期检查代码变更/Poll SCM
  • 使用cron表达式定时检查代码变更，变更后构建本job

3.4.1、触发远程构建/gitlab上改动自动构建

注意：工作中不建议使用

代码改动自动可以使用gitlab的webhook回调钩子调起Jenkins的启动任务接口

1. 在构建触发器中配置接口和token
   

2. 安装插件Build Authorization Token Root，这个插件作用就是启用token之后，可以免登录
   
   

3. postman调用url：http://192.168.119.135:8080/buildByToken/build?job=first&token=123123，就可以触发构建部署
   
   

4. 配置gitlab的webhook回调钩子
   
   
   
   

5. 注意：点击添加webhook我们发现报错，并不是url填错了，而是本地请求不允许
   
   解决办法：
   
   

6. 重新配置webhook，可以看的已创建
   

7. 测试，push一下代码
   

   可以看到自动构建部署了

   

   访问：http://192.168.119.128:8888/

   

3.4.2、定时构建

Jenkins cron表达式

标准cron

https://crontab.guru

Jenkins cron不是标准的cron表达式

第一个 * 表示每个小时的第几分钟，取值0~59

H * * * *
H：每小时执行一次

第二个 * 表示小时，取值0~23

* 15 * * * 表示每天下午3点
* 1 * * *  表示每天凌晨1点

第三个 * 表示一个月的第几天，取值1~31
* 1 5 * *  表示每月5日凌晨1点

第四个 * 表示第几月，取值1~12
* 15 5 1 *  表示每年几月执行

第五个 * 表示一周中的第几天，取值0~7，其中0和7代表的都是周日

“/”

表示每隔多长时间，比如 */10 * * * * 表示 每隔10分钟

“H”

hash散列值，以job名取值，获取到以job名为入参的唯一值，相同名称值也相同，这个偏移量会和实际时间相加，获得一个真实的运行时间

意义在于：不同的项目在不同的时间运行，即使配置的值是一样的，比如 都是15 * * * * ，表示每个小时的第15分钟开始执行任务，那么会造成同一时间内在Jenkins中启动很多job，换成H/15 * * * *,那么在首次启动任务时，会有随机值参与进来，有的会在17分钟启动 有的会在19分钟启动，随后的启动时间也是这个值。这样就能错开相同cron值的任务执行了。

H的值也可以设置范围

H * * * *表示一小时内的任意时间

*/10 * * * *每10分钟

H/10 * * * *每10分钟,可能是7,17,27，起始时间hash，步长不变

45 3 * * 1-6 每个周一至周六，凌晨3点45 执行1次

45 3-5 * * 1-6 每个周一至周六，凌晨3点45 ，凌晨4点45，凌晨5点45 各执行1次

H(40-48) 3-5 * * 1-6 在40~48之间取值 其他同上

45 3-5/2 * * 1-6 每个周一至周六，凌晨3点45 ，凌晨5点45 各执行1次

45 0-6/2 * * 1-6 * * 1-6 0点开始，每间隔2小时执行一次 0:45、2:45、4:45

3.4.3、源码变更构建

使用Poll SCM 方式与Build periodically一样

会主动定期检查代码托管服务器上是否有变化，一旦发生变化执行job构建

3.5、自动化部署到docker容器中

3.5.1、docker外挂目录

1)、手动命令启动docker外挂目录下的jar包

docker run -d -p 8080:8080 --name demo-out -v /root/jarfile/demo-1-0.0.1-SNAPSHOT.jar:/app.jar openjdk:11 java -jar app.jar

2)、jenkins修改publish over ssh 配置

我们修改publish over ssh 配置，让jenkins构建部署的时候直接可以运行在docker容器里。

1. 添加一台目标服务器
2. 运行前清理
   
3. 构建完之后配置
   
4. 点击保存，配置就修改好了，我们就可以正常使用了

3.5.2、打包到容器内

1)、手动命令启动docker容器内的jar包

1. 准备一台测试服务器 docker环境

2. 准备支持jdk的镜像

   FROM openjdk:11
   COPY . /usr/src/myapp
   WORKDIR /usr/src/myapp
   RUN javac Main.java
   CMD ["java", "Main"]
   

3. 把jar包打包到容器内

   配置国内镜像

   修改/etc/docker/daemon.json文件，没有的话创建一个

   写入

   {
       "registry-mirrors": [
           "https://ustc-edu-cn.mirror.aliyuncs.com",
           "http://hub-mirror.c.163.com",
           "https://registry.aliyuncs.com"
       ]
   }
   

   重启服务

   systemctl daemon-reload
   systemctl restart docker
   

   dockerfile

   FROM openjdk:11
   EXPOSE 8080
   
   WORKDIR /root
   
   ADD jarfile/demo*.jar /root/app.jar
   ENTRYPOINT ["java","-jar","/root/app.jar"]
   

   打包镜像

   docker build -t demo .
   

   运行容器

   docker run -d --name demo -p 8080:8080 demo 
   

   

2)、jenkins修改publish over ssh 配置

1. 添加一台目标服务器

2. 运行前配置
   

3. 项目代码里添加一个dockerfile文件
   

4. 构建后的配置
   
   
   

5. 点击保存，配置就修改好了，我们就可以正常使用了

4、Jenkins集群/并发构建

集群化构建可以有效提升构建效率，尤其是团队项目比较多或是子项目比较多的时候，可以并发在多台机器上执行构建。

4.1、Jenkins集群搭建

1. 首先搞3台服务器

   服务器名	ip	准备条件
   Jenkins-Server	192.168.119.135	jdk1.8、maven、git
   Jenkins-02	192.168.119.136	jdk1.8、maven、git
   Jenkins-03	192.168.119.137	jdk1.8、maven、git

2. 在主服务器配置其他节点 点击 ManageJenkins -> Manage nodes and clouds
   

3. 添加新节点
   

4. 填写新节点信息
   
   
   
   

5. 点击保存，我们就可以看到jenkins-02节点已经创建成功，状态为已同步。
   

6. jenkins-03节点添加如上操作。

4.2、流水线 pipeline

流水线既能作为任务的本身，也能作为Jenkinsfile

使用流水线可以让我们的任务从ui手动操作，转换为代码化，像docker的dockerfile一样，从shell命令到配置文件，更适合大型项目，可以让团队其他开发者同时参与进来，同时也可以编辑开发Jenkins-web-ui不能完成的更复杂的构建逻辑，作为开发者可读性也更好。

4.2.1、完整语法

5个必备的组成部分

pipeline：整条流水线
agent：指定执行器
stages：所有阶段
stage：某一阶段，可有多个
steps：阶段内的每一步，可执行命令

4.2.2、测试脚本

1)、基础框架

pipeline {
    agent any

    stages {
        stage('拉取代码') {
            steps {
            
                echo '拉取代码完成'
               
            }

        }
        stage('执行构建') {
            steps {
                echo '执行构建完成'


            }

        }
    }
    
    post {
        
        always {
            
            echo "完成"
            
        }
        
        failure {
            
            echo "失败"
        }
    }
}

2)、阶段视图 Stage View

点击构建

我们可以看到阶段视图

3)、blue ocean可视化界面

• 全新的流水线控制ui，可重复执行某阶段代码
  

2. 插件中心搜索blue ocean安装即可

4)、post

流水线完成后可执行的任务

• always 无论流水线或者阶段的完成状态。
• changed 只有当流水线或者阶段完成状态与之前不同时。
• failure 只有当流水线或者阶段状态为"failure"运行。
• success 只有当流水线或者阶段状态为"success"运行。
• unstable 只有当流水线或者阶段状态为"unstable"运行。例如：测试失败。
• aborted 只有当流水线或者阶段状态为"aborted "运行。例如：手动取消。

5)、agent

可以指定执行节点

label 指定运行job的节点标签

any 不指定，由Jenkins分配

pipeline {
    agent {
        node {
            label "jenkins-02"
        }
        
    }

    stages {
        stage('拉取代码') {
            steps {
          
                sh """
                    sleep 10
                            
                   """

                echo '拉取代码完成'
               
            }

        }
        stage('执行构建') {
            steps {
                echo '执行构建完成'


            }

        }
    }
    
    post {
        
        always {
            
            echo "完成"
            
        }
        
        failure {
            
            echo "失败"
        }
    }
}

4.2.3、pipeline中执行自动化构建

git拉取代码的脚本生成

1. 点击流水线语法
   

2. 选择git
   

3. 配置git的相关信息
   
   

4. 点击 生成流水线脚本
   

5. 可以看到生成的脚本代码

   git branch: 'main', credentialsId: 'gitlab', url: 'http://192.168.119.134/root/java-project.git'
   

publish over ssh脚本生成

1.选择 sshPublisher: Send build artifacts over SSH

2. 配置和原先publish over ssh 配置一样，这里就不贴图了。

把所有的操作通过流水线语法生成，最后完整的jenkinsfile脚本

pipeline {
    agent any

    tools {
        
        maven "maven3"
        
    }
    stages {
        stage("拉取代码") {
            steps {
                git branch: 'main', credentialsId: 'gitlab', url: 'http://192.168.119.134/root/java-project.git'
                echo '拉取成功'
            }
        }

        stage("执行构建") {
            steps {
                
            //    sh "mvn --version"
                sh """ 
                cd demo-1
                
                mvn clean package
                """
                
                echo '构建完成'
            }

        }
        
        
        stage("clean test server"){
            
            steps{
                
sshPublisher(publishers: [sshPublisherDesc(configName: 'testserver', transfers: [sshTransfer(cleanRemote: false, excludes: '', execCommand: '''rm -rf *

docker stop demo
docker rm demo
docker rmi demo
''', execTimeout: 120000, flatten: false, makeEmptyDirs: false, noDefaultExcludes: false, patternSeparator: '[, ]+', remoteDirectory: '', remoteDirectorySDF: false, removePrefix: '', sourceFiles: '/root')], usePromotionTimestamp: false, useWorkspaceInPromotion: false, verbose: false)])
            }
        }
        
        
        
        
        
        stage("发送jar包到测试服务器") {
            steps {
                
                sshPublisher(publishers: [sshPublisherDesc(configName: 'testserver', transfers: [sshTransfer(cleanRemote: false, excludes: '', execCommand: '', execTimeout: 120000, flatten: false, makeEmptyDirs: false, noDefaultExcludes: false, patternSeparator: '[, ]+', remoteDirectory: '/jarfile', remoteDirectorySDF: false, removePrefix: 'demo-1/target', sourceFiles: '**/demo*.jar'), sshTransfer(cleanRemote: false, excludes: '', execCommand: '''docker build -t demo .
docker run -d -p 8080:8080 --name demo demo''', execTimeout: 120000, flatten: false, makeEmptyDirs: false, noDefaultExcludes: false, patternSeparator: '[, ]+', remoteDirectory: '/', remoteDirectorySDF: false, removePrefix: 'demo-1/docker', sourceFiles: 'demo-1/docker/dockerfile')], usePromotionTimestamp: false, useWorkspaceInPromotion: false, verbose: false)])
                
                
                echo 'jar send over!'
            }

        }

    }
}

把流水线的代码粘贴到脚本里

1)、声明式流水线

好处

• 更像是在Jenkins web ui中的操作
• 可读性比较高
• 可以使用blue ocean自动生成
• 支持语法检查

坏处

• 代码逻辑能力比脚本式弱，不能完成特别复杂的任务

2)、脚本式流水线

好处

• 更少的代码和弱规范要求
• 更灵活的自定义代码操作
• 不受约束，可以构建特别复杂的工作流和流水线

坏处

• 读写对编程要求比较高
• 比声明式流水线代码更复杂