常用编程环境与开发工具安装手册

安装目录示分区大小而定，不可盲目复制命令进行安装！

安装 Docker 容器服务

CentOS 安装

BASH

# 1. 卸载旧的版本
sudo yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine

# 2. 安装yum-utils包（提供 yum-config-manager 程序）
sudo yum install -y yum-utils

# 3. 设置镜像的仓库
yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo # 默认是国外的，十分慢！
# 建议使用阿里云的镜像地址
yum-config-manager \
    --add-repo \
    https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

# 更新yum软件包索引
yum makecache fast

# 4. 安装docker相关的 docker-ce docker-compose （默认为最新版）
sudo yum install docker-ce docker-ce-cli containerd.io docker-compose-plugin

# 5. 安装指定版本
sudo yum install docker-ce-<VERSION_STRING> docker-ce-cli-<VERSION_STRING> containerd.io docker-compose-plugin
sudo yum install docker-ce-20.10.13 docker-ce-cli-20.10.13 containerd.io docker-compose-plugin

# 6. 启动docker
systemctl start docker
systemctl enable docker

# 7. 使用docker version查看是否安装成功

Ubuntu 安装

BASH

# 1. 卸载旧的版本
sudo apt-get remove docker docker-engine docker.io containerd runc

# 2. 更新软件包索引并安装软件包，以允许通过 HTTPS 使用存储库：aptapt
sudo apt-get update

sudo apt-get install \
    ca-certificates \
    curl \
    gnupg \
    lsb-release

# 3. 添加 Docker 的官方 GPG 密钥：
sudo mkdir -p /etc/apt/keyrings

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

# 4. 设置存储库
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# 5. 更新包索引，并安装最新版本的 Docker 引擎、容器和 Docker Compose
sudo apt-get update

sudo apt-get install docker-ce docker-ce-cli containerd.io docker-compose-plugin

# 安装指定版本
sudo apt-get install docker-ce=<VERSION_STRING> docker-ce-cli=<VERSION_STRING> containerd.io docker-compose-plugin

# 先列出存储库中的可用版本
apt-cache madison docker-ce
 docker-ce | 5:20.10.18~3-0~ubuntu-focal | https://download.docker.com/linux/ubuntu focal/stable amd64 Packages
 docker-ce | 5:20.10.17~3-0~ubuntu-focal | https://download.docker.com/linux/ubuntu focal/stable amd64 Packages
 docker-ce | 5:20.10.16~3-0~ubuntu-focal | https://download.docker.com/linux/ubuntu focal/stable amd64 Packages

# 取出其中的版本号，例如：5:20.10.17~3-0~ubuntu-focal
sudo apt-get install docker-ce=5:20.10.17~3-0~ubuntu-focal docker-ce-cli=5:20.10.17~3-0~ubuntu-focal containerd.io docker-compose-plugin


# 6. 启动docker
systemctl start docker
systemctl enable docker

# 7. 使用docker version查看是否安装成功

Redis 缓存安装部署

这里下载的是redis-5.0.8.tar.gz安装包，并将其直接放在了opt⽬录下

解压安装包

1、在/usr/local/下创建redis⽂件夹并进⼊

BASH
cd /usr/local/
mkdir redis
cd redis

2、将Redis安装包解压到/usr/local/redis中即可

1 2	BASH tar zxvf /opt/redis-5.0.8.tar.gz -C ./

解压完之后， /usr/local/redis⽬录中会出现⼀个 redis-5.0.8.tar.gz 的⽬录

编译并安装

1
2
3

BASH
cd redis-5.0.8/
make && make install

将 Redis 安装为系统服务并后台启动

进入utils目录，并执行如下脚本即可：

1
2
3

BASH
cd utils/
./install_server.sh

此处我全部选择默认配置，有需要可以按需选择

查看 Redis 服务启动情况

直接执行如下命令来查看 Redis 的启动结果：

BASH
systemctl status redis_6379.service

# 扩展
启动：systemctl start redis_6379.service
停止：systemctl stop redis_6379.service
重启：systemctl restart redis_6379.service

启动 Redis 客户端并测试

启动自带的redis-cli客户端，测试通过：

但是此时只能在本地访问，无法远程连接，因此还需要做部分设置

运行远程连接

编辑redis配置文件

1 2	AWK vim /etc/redis/6379.conf

将bind 127.0.0.1修改为0.0.0.0

保存然后重启Redis服务即可：

1 2	BASH systemctl restart redis_6379.service

设置访问密码

编辑redis配置文件

1 2	AWK vim /etc/redis/6379.conf

找到如下内容：

1 2	1C #requirepass foobared

去掉注释，将foobared修改为自己想要的密码，保存即可。

1 2	APACHE requirepass 123456

保存然后重启Redis服务即可：

1 2	BASH systemctl restart redis_6379.service

这样后续的访问需要先输入密码认证通过：

WEB 服务器 Nginx 安装部署

这⾥下载的是nginx-1.17.10.tar.gz安装包，并将其直接放在了opt⽬录下

解压安装包

1、在/usr/local/下创建nginx⽂件夹并进⼊

BASH
cd /usr/local/
mkdir nginx
cd nginx

2、将Nginx安装包解压到/usr/local/nginx中即可

1 2	APACHE tar zxvf /opt/nginx-1.17.10.tar.gz -C ./

解压完之后， /usr/local/nginx ⽬录中会出现⼀个 nginx-1.17.10 的⽬录

预先安装额外的依赖

1 2	BASH yum -y install pcre-devel openssl openssl-devel gcc gcc-c++ autoconf automake make

编译安装 Nginx

BASH
cd nginx-1.17.10
# 使用 --prefix= 可以指定目录安装
./configure
make && make install

安装完成后，Nginx 的可执⾏⽂件位置位于

1 2	BASH /usr/local/nginx/sbin/nginx

启动 Nginx

直接执⾏如下命令即可：

1 2	AWK /usr/local/nginx/sbin/nginx

如果想停⽌ Nginx 服务，可执⾏：

1 2	AWK /usr/local/nginx/sbin/nginx -s stop

如果修改了配置⽂件后想重新加载 Nginx，可执⾏：

1 2	AWK /usr/local/nginx/sbin/nginx -s reload

注意其配置⽂件位于：

1 2	AWK /usr/local/nginx/conf/nginx.conf

Centos6.9 注册为系统服务，并开机自启

首先，在 linux 系统的/etc/init.d/目录下创建 nginx 文件，使用如下命令：

vi /etc/init.d/nginx
SH

#!/bin/sh
#
# nginx - this script starts and stops the nginx daemon
#
# chkconfig:   - 85 15
# description:  NGINX is an HTTP(S) server, HTTP(S) reverse \
#               proxy and IMAP/POP3 proxy server
# processname: nginx
# config:      /etc/nginx/nginx.conf
# config:      /etc/sysconfig/nginx
# pidfile:     /var/run/nginx.pid
# Source function library.
. /etc/rc.d/init.d/functions
# Source networking configuration.
. /etc/sysconfig/network
# Check that networking is up.
[ "$NETWORKING" = "no" ] && exit 0
# 这里根据实际安装位置修改
nginx="/usr/local/nginx/sbin/nginx"
prog=$(basename $nginx)
# 这里根据实际配置文件位置修改
NGINX_CONF_FILE="/usr/local/nginx/conf"
[ -f /etc/sysconfig/nginx ] && . /etc/sysconfig/nginx
lockfile=/var/lock/subsys/nginx
make_dirs() {
   # make required directories
   user=`$nginx -V 2>&1 | grep "configure arguments:" | sed 's/[^*]*--user=\([^ ]*\).*/\1/g' -`
   if [ -z "`grep $user /etc/passwd`" ]; then
       useradd -M -s /bin/nologin $user
   fi
   options=`$nginx -V 2>&1 | grep 'configure arguments:'`
   for opt in $options; do
       if [ `echo $opt | grep '.*-temp-path'` ]; then
           value=`echo $opt | cut -d "=" -f 2`
           if [ ! -d "$value" ]; then
               # echo "creating" $value
               mkdir -p $value && chown -R $user $value
           fi
       fi
   done
}
start() {
    [ -x $nginx ] || exit 5
    [ -f $NGINX_CONF_FILE ] || exit 6
    make_dirs
    echo -n $"Starting $prog: "
    daemon $nginx -c $NGINX_CONF_FILE
    retval=$?
    echo
    [ $retval -eq 0 ] && touch $lockfile
    return $retval
}
stop() {
    echo -n $"Stopping $prog: "
    killproc $prog -QUIT
    retval=$?
    echo
    [ $retval -eq 0 ] && rm -f $lockfile
    return $retval
}
restart() {
    configtest || return $?
    stop
    sleep 1
    start
}
reload() {
    configtest || return $?
    echo -n $"Reloading $prog: "
    killproc $nginx -HUP
    RETVAL=$?
    echo
}
force_reload() {
    restart
}
configtest() {
  $nginx -t -c $NGINX_CONF_FILE
}
rh_status() {
    status $prog
}
rh_status_q() {
    rh_status >/dev/null 2>&1
}
case "$1" in
    start)
        rh_status_q && exit 0
        $1
        ;;
    stop)
        rh_status_q || exit 0
        $1
        ;;
    restart|configtest)
        $1
        ;;
    reload)
        rh_status_q || exit 7
        $1
        ;;
    force-reload)
        force_reload
        ;;
    status)
        rh_status
        ;;
    condrestart|try-restart)
        rh_status_q || exit 0
            ;;
    *)
        echo $"Usage: $0 {start|stop|status|restart|condrestart|try-restart|reload|force-reload|configtest}"
        exit 2
esac

保存脚本文件，并修改权限：

BASH
# 修改文件权限
chmod a+x /etc/init.d/nginx
# 添加为系统服务
chkconfig --add /etc/init.d/nginx
# 服务启动/停止命令
service nginx start
service nginx stop
# 设置终端模式开机启动
chkconfig nginx on

CentOS7 注册为系统服务，并开机自启

在系统中创建服务脚本，命令如下：

vi /usr/lib/systemd/system/nginx.service
GRADLE

[Unit]
Description=nginx - web server
After=network.target remote-fs.target nss-lookup.target
[Service]
Type=forking
PIDFile=/usr/local/nginx/logs/nginx.pid
ExecStartPre=/usr/local/nginx/sbin/nginx -t -c /usr/local/nginx/conf/nginx.conf
ExecStart=/usr/local/nginx/sbin/nginx -c /usr/local/nginx/conf/nginx.conf
ExecReload=/usr/local/nginx/sbin/nginx -s reload
ExecStop=/usr/local/nginx/sbin/nginx -s stop
ExecQuit=/usr/local/nginx/sbin/nginx -s quit
PrivateTmp=true
[Install]
WantedBy=multi-user.target

重新加载系统服务，并设置开机自启

BASH
# 重新加载系统服务
systemctl daemon-reload
# 启动服务
systemctl start nginx.service
# 开机自启
systemctl enable nginx.service

JDK（Java 环境）安装

注意：这⾥安装的是 Oracle JDK

准备 JDK 安装包

我这里下载的是jdk-8u251-linux-x64.tar.gz安装包，并将其放在了/opt目录下

卸载已有的 OPENJDK（如果有）

如果系统⾃带有OpenJDK，可以按照如下步骤提前卸载之。

1 2	BASH rpm -qa \| grep java

接下来可以将java开头的安装包均卸载即可：

BASH
yum -y remove java-1.7.0-openjdk-1.7.0.141-2.6.10.5.el7.x86_64
yum -y remove java-1.8.0-openjdk-1.8.0.131-11.b12.el7.x86_64
... 省略 ...

创建目录并解压

1、在/usr/local/下创建java文件夹并进入

BASH
cd /usr/local/
mkdir java
cd java

2、将上⾯准备好的 JDK 安装包解压到 /usr/local/java 中即可

1 2	AWK tar -zxvf /opt/jdk-8u251-linux-x64.tar.gz -C ./

解压完之后， /usr/local/java ⽬录中会出现⼀个 jdk1.8.0_251 的⽬录

配置 JDK 环境变量

编辑/etc/profile文件，在文件尾部加入如下JDK环境配置即可

ROUTEROS
JAVA_HOME=/usr/local/java/jdk1.8.0_251
CLASSPATH=$JAVA_HOME/lib/
PATH=$PATH:$JAVA_HOME/bin
export PATH JAVA_HOME CLASSPATH

然后执⾏如下命令让环境变量⽣效

1 2	GRADLE source /etc/profile

验证 JDK 安装结果

输入如下命令即可检查安装结果：

APPLESCRIPT
java -version

javac

Maven 项目构建和管理工具安装

准备 MAVEN 安装包并解压

这⾥下载的是apache-maven-3.6.3-bin.tar.gz安装包，并将其放置于提前创建好的/usr/local/maven⽬录下。

执⾏命令解压之：

1 2	BASH tar -zxvf /opt/apache-maven-3.6.3-bin.tar.gz -C ./

即可在当前⽬录得到 /usr/local/maven/apache-maven-3.6.3 ⽬录

配置 MAVEN 加速镜像源

这⾥配置的是阿⾥云的 maven 镜像源。

编辑修改/usr/local/maven/apache-maven-3.6.3/conf/settings.xml⽂件，在<mirrors></mirrors>标签对⾥添加如下内容即可：

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

配置环境变量

因为下载的是⼆进制版安装包，所以解压完，配置好环境变量即可使用了。

编辑修改 /etc/profile ⽂件，在⽂件尾部添加如下内容，配置 maven 的安装路径

1
2
3

ROUTEROS
export MAVEN_HOME=/usr/local/maven/apache-maven-3.6.3
export PATH=$MAVEN_HOME/bin:$PATH

接下来执行 source /etc/profile 来刷新环境变量，让 maven 环境的路径配置生效

检验安装结果

执⾏ mvn –v ，能打印出 maven 版本信息说明安装、配置成功：

Jenkins 安装与配置

安装 Jenkins Master

Jenkins 官方安装文档

Docker 安装 Jenkins（推荐）

使用 Docker 安装 Jenkins

AWK

# 使用命令直接安装（包含构建工具）
docker run -d --name jenkins --restart always \
--user root -p 8080:8080 -p 50000:50000 \
-v /var/jenkins_home:/var/jenkins_home \
-v /usr/local/maven/apache-maven-3.6.3:/usr/local/maven/apache-maven-3.6.3 \
-v /usr/local/java/jdk1.8.0_251:/usr/local/java/jdk1.8.0_251 \
-v /usr/local/sonar-scanner/sonar-scanner-4.6.0.2311-linux:/usr/local/sonar-scanner/sonar-scanner-4.6.0.2311-linux \
-v /var/run/docker.sock:/var/run/docker.sock \
jenkinsci/blueocean

# 简易安装
docker run -d --name jenkins --restart always \
--user root -p 8080:8080 -p 50000:50000 \
-v /u01/jenkins_home:/var/jenkins_home \
-v /var/run/docker.sock:/var/run/docker.sock \
jenkinsci/blueocean

War 安装 Jenkins

获取 Jenkins 安装包

下载页面：https://jenkins.io/zh/download/

安装文件：jenkins.war

ARDUINO
1、将最新的稳定Jenkins WAR包 下载到您计算机上的相应目录。

2、在下载的目录内打开一个终端/命令提示符窗口到。

3、运行命令java -jar jenkins.war

4、浏览http://localhost:8080并等到*Unlock Jenkins*页面出现。

5、继续使用Post-installation setup wizard后面步骤设置向导。

解锁 Jenkins

获取并输入 admin 账户密码（我这里是 docker 安装的，目录是映射到指定位置的，密码实际存放路径以提示为主）

1	cat /var/jenkins_home/secrets/initialAdminPassword

跳过插件安装

因为 Jenkins 插件需要连接默认官网下载，速度非常慢，而且容易安装失败，所以我们暂时先跳过插件安装。

添加一个管理员账户，并进入 Jenkins 后台

保存并完成

开始使用 Jenkins

安装 Jenkins Slave

1	系统设置 > 节点管理 > 新建节点

下载agent.jar

BASH

## 创建agent目录

mkdir -p /dev/jenkinsagent
cd /dev/jenkinsagent
wget http://192.168.88.230:8080/jnlpJars/agent.jar


## 编写启动脚本
#!/bin/bash

echo 0bdf5bac23b7d4e66880934b25bda0f353509529b7f843ebb688614ba389680e > secret-file

nohup java -jar agent.jar -jnlpUrl http://192.168.88.230:8080/computer/build/jenkins-agent.jnlp -secret @secret-file -workDir "/u01/jenkins-agent" 2>&1 &

## 启动agent
sh -x start.sh
ps aux | grep agent

Jenkins 插件管理

Jenkins 本身不提供很多功能，我们可以通过使用插件来满足我们的使用。例如从 Gitlab 拉取代码，使用 Maven 构建项目等功能需要依靠插件完成。接下来演示如何下载插件。

修改 Jenkins 插件下载地址

Jenkins 国外官方插件地址下载速度非常慢，所以可以修改为国内插件地址：

1	Jenkins -> Manage Jenkins -> Manage Plugins，点击Available

这样做是为了把 Jenkins 官方的插件列表下载到本地，接着修改地址文件，替换为国内插件地址：

JBOSS-CLI
# 进入配置目录 （目录视情况而定，安装的jenkins_home下）
cd /var/jenkins_home/updates

# 执行命令
sed -i 's/http:\/\/updates.jenkinsci.org\/download/https:\/\/mirrors.tuna.tsinghua.edu.cn\/jenkins/g' default.json && sed -i 's/http:\/\/www.google.com/https:\/\/www.baidu.com/g' default.json

最后，Manage Plugins 点击 Advanced，把 Update Site 改为国内插件下载地址

Sumbit 后，在浏览器输入： http://120.78.204.65:8180/restart ，重启 Jenkins。

下载中文汉化插件

1	Jenkins -> Manage Jenkins -> Manage Plugins，点击Available，搜索"Chinese"

完成后如下图所示：

重启 Jenkins 之后，就看到 Jenkins 汉化了！（PS：某些菜单可能会汉化失败）

Jenkins 用户权限管理

我们可以利用Role-based Authorization Strategy插件来管理 Jenkins 用户权限

安装 Role-based Authorization Strategy 插件

开启权限全局安全配置

授权策略切换为”Role-Based Strategy”，保存

创建角色

在系统管理页面进入 Manage and Assign Roles

点击”Manage Roles”

Global roles（全局角色）：管理员等高级用户可以创建基于全局的角色

Item roles（项目角色）：针对某个或者某些项目的角色

Node roles（节点角色）：节点相关的权限

我们添加以下三个角色：

baseRole：该角色为全局角色。这个角色需要绑定 Overall 下面的 Read 权限，是为了给所有用户绑定最基本的 Jenkins 访问权限。注意：如果不给后续用户绑定这个角色，会报错误：用户名 is missing the Overall/Read permission
role1：该角色为项目角色。使用正则表达式绑定 .vx-chx.\*，意思是只能操作 vx-chx 开头的项目。
role2：该角色为项目角色。使用正则表达式绑定 .vx-phm.\*，意思是只能操作 vx-phm 开头的项目。

保存

创建用户

在系统管理页面进入 Manage Users

分别创建两个用户：vxchx 和 vxphm

给用户分配角色

系统管理页面进入 Manage and Assign Roles，点击 Assign Roles

绑定规则如下：

vxchx 用户分别绑定 baseRole 和 role1 角色
vxphm 用户分别绑定 baseRole 和 role2 角色

保存

创建项目测试权限

以 admin 管理员账户创建两个项目，分别为 vx-chx-test 和 vx-phm-test

结果为： vxchx 用户登录，只能看到 vx-chx-test 项目 vxphm 用户登录，只能看到 vx-phm-test 项目

Jenkins 凭证管理

凭据可以用来存储需要密文保护的数据库密码、Gitlab 密码信息、Docker 私有仓库密码等，以便 Jenkins 可以和这些第三方的应用进行交互。

安装 Credentials Binding 插件

要在 Jenkins 使用凭证管理功能，需要安装Credentials Binding插件

注：新版本已经默认安装了此插件，这里无需另外再安装了

系统管理中选择 Manage Credentials

可以添加的凭证有 5 种：

Username with password：用户名和密码
SSH Username with private key：使用 SSH 用户和密钥
Secret file：需要保密的文本文件，使用时 Jenkins 会将文件复制到一个临时目录中，再将文件路径设置到一个变量中，等构建结束后，所复制的 Secret file 就会被删除。
GitHub App：GitHub 的 API 令牌
Secret text：需要保存的一个加密的文本串，如钉钉机器人或 Github 的 api token
Certificate：通过上传证书文件的方式

常用的凭证类型有：Username with password（用户密码）和 SSH Username with private key（SSH 密钥）

接下来以使用 Git 工具到 Gitlab 拉取项目源码为例，演示 Jenkins 的如何管理 Gitlab 的凭证。

安装 Git 插件和 Git 工具

为了让 Jenkins 支持从 Gitlab 拉取源码，需要安装 Git 插件以及在服务器上安装 Git 工具。

Git 插件安装：

服务器上安装 Git 工具（以 CentOS7 为例）：

BASH
# 安装
yum install git -y
# 安装后查看版本
git --version

用户密码类型

1）创建凭据

1	Jenkins -> 凭证 -> 系统 -> 全局凭据 -> 添加凭据

选择”Username with password”，输入 Gitlab 的用户名和密码，点击”确定”。

SSH 密钥类型

SSH 免密登录示意图

1）使用 root 用户生成公钥和私钥

1	ssh-keygen -t rsa

在/root/.ssh/目录保存了公钥和使用

id_rsa：私钥文件

id_rsa.pub：公钥文件

2）把生成的公钥放在 Gitlab 中

1	登录gitlab -> 点击头像 -> Settings -> SSH Keys

复制刚才 id_rsa.pub 文件的内容到这里，点击”Add Key”

3）在 Jenkins 中添加凭证，配置私钥

在 Jenkins 添加一个新的凭证，类型为”SSH Username with private key”，把刚才生成私有文件内容复制过来

Jenkins 关联 JDK 和 Maven

关联 JDK

1	Jenkins -> 系统管理 -> 全局工具配置 -> JDK -> 新增JDK，配置如下：

关联 Maven

1	Jenkins -> 系统管理 -> 全局工具配置 -> Maven -> 新增Maven，配置如下：

Jenkins 关闭跨站请求伪造保护

Docker 容器运行

APPLESCRIPT
# 1、进入运行的容器
docker exec -u root -it 你的Jenkins容器名称或者容器id bash

# 2、输入命令，编辑jenkins启动配置文件
vi /usr/local/bin/jenkins.sh

# 3、在图中标记处，加入以下配置
-Dhudson.security.csrf.GlobalCrumbIssuerConfiguration.DISABLE_CSRF_PROTECTION=true

# 4、重启容器
docker restart jenkins

添加 Jenkins 全局变量

1	Jenkins -> 系统管理 -> 全局属性 -> 添加三个环境变量，配置如下：

Jenkins 数据迁移和备份

将安装 Jenkins 的机器上的 jenkins_home 目录下的 config.xml 文件，jobs 文件夹，users 文件夹和 plugins 文件夹打包

config.xml 是存放配置信息的
jobs 是存放创建的工程项目的
users 是存放用户账信息的
plugins 是存放插件的

Jenkins 删除构建历史

GROOVY
//项目名称
def jobName = "xxx"
//删除小于等于maxNumber的构建历史
def maxNumber = xxx

Jenkins.instance.getItemByFullName(jobName).builds.findAll {
  it.number <= maxNumber
}.each {
  it.delete()
}

Jenkins 构建 Maven 项目

构建方式均采用 Jar 包方式，War 方式参考WAR 部署方案 · JeecgBoot 开发文档

Jenkins 项目构建类型

Jenkins 中自动构建项目的类型有很多，常用的有以下三种：

自由风格软件项目（FreeStyle Project）
Maven 项目（Maven Project）
流水线项目（Pipeline Project）

每种类型的构建其实都可以完成一样的构建过程与结果，只是在操作方式、灵活度等方面有所区别，在实际开发中可以根据自己的需求和习惯来选择。（PS：个人推荐使用流水线类型，因为灵活度非常高）

自由风格项目构建

下面演示创建一个自由风格项目来完成项目的集成过程：

1	拉取代码 -> 编译 -> 打包 -> 部署

拉取代码

1）创建项目

2）源码管理，从 Gitlab 拉取代码

编译打包

构建 -> 添加构建步骤 -> 执行shell
BASH
echo "开始编译和打包"
mvn clean package
echo "编译和打包结束"

部署

把项目部署到远程的服务器上，并启动

1）安装Publish Over SSH插件

Jenkins 本身无法实现远程部署到服务器上的功能，需要安装Publish Over SSH插件实现

2）配置Publish over SSH，添加 SSH 服务器

1	打开系统管理 -> 系统配置 -> 拉到底部，选择Publish over SSH区域选择新增

点击高级 -> 填写服务器密码（也可选择 ssh 验证，在 Jenkins 中配置本机私钥，将公钥发送到目标机器，即可完成无密码登录）

1	发送命令：ssh-copy-id -i /root/.ssh/id_rsa.pub root@192.168.xxx.xxx

Passphrase：密码（目标机器的密码）
Path to key：key 文件（私钥）的路径
SSH Server Name：标识的名字（随便你取什么）
Hostname：需要连接 ssh 的主机名或 ip 地址，此处填写应用服务器 IP（建议 ip）
Username：用户名
Remote Directory：远程目录(要发布的目录,比如/usr/local/tomcat/webapps/)

3）添加构建步骤

APACHE
# 脚本参考
source /etc/profile

cd /apps
ps -ef|grep jeecg-boot-module-system-3.1.0.jar|grep -v grep|awk '{print $2}'|xargs kill -s 9
BUILD_ID=dontKillMe
nohup java -jar jeecg-boot-module-system-3.1.0.jar > jeecg-boot-module-system-3.1.0.log 2>&1 &

4）点击”立即构建”，开始构建过程

5）构建成功，并自动化部署，访问测试！

Maven 项目构建

1）安装 Maven Integration Plugin（高版本的 Jenkins 已预装了此插件）

2）创建 Maven 项目

3）配置项目

拉取代码和远程部署的过程和自由风格项目一样，只是”构建”部分不同

Pipeline 流水线项目构建(*)

Pipeline 简介

1）概念

Pipeline，简单来说，就是一套运行在 Jenkins 上的工作流框架，将原来独立运行于单个或者多个节点的任务连接起来，实现单个任务难以完成的复杂流程编排和可视化的工作。

2）使用 Pipeline 有以下好处（来自翻译自官方文档）：

代码：Pipeline 以代码的形式实现，通常被检入源代码控制，使团队能够编辑，审查和迭代其传送流程。持久：无论是计划内的还是计划外的服务器重启。Pipeline 都是可恢复的。可停止：Pipeline 可接收交互式输入，以确定是否继续执行 Pipeline。多功能：Pipeline 支持现实世界中复杂的持续交付要求。它支持 fork/join、循环执行，并行执行任务的功能。可扩展：Pipeline 插件支持其 DSL 的自定义扩展，以及与其他插件集成的多个选项。

3）如何创建 Jenkins Pipeline 呢？

Pipeline 脚本是由Groovy语言实现的，但是我们没必要单独去学习 Groovy
Pipeline 支持两种语法：Declarative(声明式)和Scripted Pipeline(脚本式)语法
Pipeline 也有两种创建方法：可以直接在 Jenkins 的 Web UI 界面中输入脚本；也可以通过创建一个 Jenkinsfile 脚本文件放入项目源码库中（一般我们都推荐在 Jenkins 中直接从源代码控制(SCM)中直接载入 Jenkinsfile Pipeline 这种方法）。

Pipeline 语法快速入门

1）Declarative 声明式-Pipeline

创建一个流水线项目

1	流水线 -> 选择HelloWorld模板

生成的内容如下：

GROOVY
pipeline {
    agent any

    stages {
        stage('Hello') {
            steps {
                echo 'Hello World'
            }
        }
    }
}

stages：代表整个流水线的所有执行阶段。通常 stages 只有 1 个，里面包含多个 stage
stage：代表流水线中的某个阶段，可能出现 n 个。一般分为拉取代码，编译构建，部署等阶段。
steps：代表一个阶段内需要执行的逻辑。steps 里面是 shell 脚本，git 拉取代码，ssh 远程发布等任意内容。

编写一个简单声明式的 Pipeline：

GROOVY

pipeline {
    agent any
    stages {
        stage('拉取代码') {
            steps {
            	echo '拉取代码'
            }
        }
        stage('编译构建') {
            steps {
            	echo '编译构建'
            }
        }
        stage('项目部署') {
            steps {
            	echo '项目部署'
            }
        }
    }
}

点击构建，进入Blue Ocean可以看到整个构建过程

2）Scripted Pipeline 脚本式-Pipeline

创建项目

选择 Scripted Pipeline"

GROOVY
node {
    def mvnHome
    stage('Preparation') { // for display purposes

    }
    stage('Build') {

    }
    stage('Results') {

    }
}

Node：节点，一个 Node 就是一个 Jenkins 节点，Master 或者 Agent，是执行 Step 的具体运行环境，后续讲到 Jenkins 的 Master-Slave 架构的时候用到。
Stage：阶段，一个 Pipeline 可以划分为若干个 Stage，每个 Stage 代表一组操作，比如： Build、Test、Deploy，Stage 是一个逻辑分组的概念。
Step：步骤，Step 是最基本的操作单元，可以是打印一句话，也可以是构建一个 Docker 镜像，由各类 Jenkins 插件提供，比如命令：sh ‘make’，就相当于我们平时 shell 终端中执行 make 命令一样。

编写一个简单的脚本式 Pipeline

JAVASCRIPT
node {
    def mvnHome
    stage('拉取代码') { // for display purposes
    	echo '拉取代码'
    }
    stage('编译构建') {
    	echo '编译构建'
    }
    stage('项目部署') {
    	echo '项目部署'
    }
}

构建结果和声明式一样！

Pipeline Script from SCM

刚才我们都是直接在 Jenkins 的 UI 界面编写 Pipeline 代码，这样不方便脚本维护，建议把 Pipeline 脚本放在项目中（一起进行版本控制）

1）在项目根目录建立 Jenkinsfile 文件，把内容复制到该文件中

把 Jenkinsfile 上传到 Gitlab

2）在项目中引用该文件

Jenkinsfile

Jenkinsfile 环境变量

环境变量	说明
BRANCH_NAME	在 multibranch 项目中，BRANCH_NAME 用于标明构建分支的名称。
CHANGE_ID	在 multibranch 的项目中，相较于特定的变更请求，用于标明变更 ID，比如 Pull Request
CHANGE_URL	在 multibranch 的项目中，相较于特定的变更请求，用于标明变更的 URL
CHANGE_TITLE	在 multibranch 的项目中，相较于特定的变更请求，用于标明变更的标题
CHANGE_AUTHOR	在 multibranch 的项目中，相较于特定的变更请求，用于标明提交变更的人员的名称
CHANGE_AUTHOR_DISPLAY_NAME	在 multibranch 的项目中，相较于特定的变更请求，用于标明提交变更的人员的显示名称
CHANGE_AUTHOR_EMAIL	在 multibranch 的项目中，相较于特定的变更请求，用于标明提交变更的人员的邮件地址
CHANGE_TARGET	在 multibranch 的项目中，相较于特定的变更请求，用于合并后的分支信息等
BUILD_NUMBER	当前的构建编号
BUILD_ID	在 1.597 版本后引进，表示当前构建 ID
BUILD_DISPLAY_NAME	当前构建的显示信息
JOB_NAME	构建 Job 的全称，包含项目信息
JOB_BASE_NAME	除去项目信息的 Job 名称
BUILD_TAG	构建标签
EXECUTOR_NUMBER	执行器编号，用于标识构建器的不同编号
NODE_NAME	构建节点的名称
NODE_LABELS	节点标签
WORKSPACE	构建时使用的工作空间的绝对路径
JENKINS_HOME	JENKINS 根目录的绝对路径
JENKINS_URL	Jenkins 的 URL 信息
BUILD_URL	构建的 URL 信息
JOB_URL	构建 Job 的 URL 信息
GIT_COMMIT	git 提交的 hash 码
GIT_PREVIOUS_COMMIT	当前分支上次提交的 hash 码
GIT_PREVIOUS_SUCCESSFUL_COMMIT	当前分支上次成功构建时提交的 hash 码
GIT_BRANCH	远程分支名称
GIT_LOCAL_BRANCH	本地分支名称
GIT_URL	远程 URL 地址
GIT_COMMITTER_NAME	Git 提交者的名称
GIT_AUTHOR_NAME	Git Author 的名称
GIT_COMMITTER_EMAIL	Git 提交者的 email 地址
GIT_AUTHOR_EMAIL	Git Author 的 email 地址
MERCURIAL_REVISION	Mercurial 的版本 ID 信息
MERCURIAL_REVISION_SHORT	Mercurial 的版本 ID 缩写
MERCURIAL_REVISION_NUMBER	Mercurial 的版本号信息
MERCURIAL_REVISION_BRANCH	分支版本信息
MERCURIAL_REPOSITORY_URL	仓库 URL 信息
SVN_REVISION	Subversion 的当前版本信息
SVN_URL	当前工作空间中被 checkout 的 Subversion 工程的 URL 地址信息

常用的构建触发器

Jenkins 内置 4 种构建触发器：

触发远程构建
其他工程构建后触发（Build after other projects are build）
定时构建（Build periodically）
轮询 SCM（Poll SCM）
GitHub 钩子触发的 GIT SCM 轮询（GitHub hook trigger for GITScm polling）

触发远程构建

触发构建 url：http://192.168.88.86:8180/job/vx-phm/build?token=abcabc

其他工程构建后触发

1）创建 pre_job 流水线工程

2）配置需要触发的工程

定时构建

定时字符串从左往右分别为：分时日月周

一些定时表达式的例子：

MARKDOWN

每30分钟构建一次：H代表形参 H/30 * * * * 10:02 10:32

每2个小时构建一次: H H/2 * * *

每天的8点，12点，22点，一天构建3次： (多个时间点中间用逗号隔开) 0 8,12,22 * * *

每天中午12点定时构建一次 H 12 * * *

每天下午18点定时构建一次 H 18 * * *

在每个小时的前半个小时内的每10分钟 H(0-29)/10 * * * *

每两小时一次，每个工作日上午9点到下午5点(也许是上午10:38，下午12:38，下午2:38，下午
4:38) H H(9-16)/2 * * 1-5

轮询 SCM

轮询 SCM，是指定时扫描本地代码仓库的代码是否有变更，如果代码有变更就触发项目构建。

注意：此构建触发器，Jenkins 会定时扫描本地整个项目的代码，增大系统的开销，不建议使用。

Git Hook 自动触发构建(*)

刚才我们看到在 Jenkins 的内置构建触发器中，轮询 SCM 可以实现 Gitlab 代码更新，项目自动构建，但是该方案的性能不佳。那有没有更好的方案呢？有的。就是利用 Gitlab 的 webhook 实现代码 push 到仓库，立即触发项目自动构建。

安装 Gitlab Hook 插件

需要安装两个插件：

Gitlab Hook 和 Gitlab

Jenkins 设置自动构建

等会需要把生成的 webhook URL 配置到 Gitlab 中。

Gitlab 配置 webhook

1）开启 webhook 功能

1 2	使用root账户登录到后台，点击Admin Area -> Settings -> Network 勾选"Allow requests to the local network from web hooks and services"

2）在项目中添加 webhook

1	点击项目 -> Settings -> Webhooks

注意：以下设置必须完成，否则会报错！

1	系统管理 -> 系统配置

SonarQube 平台安装与配置

认识 SonarQube

SonarQube 是一款用于代码质量管理的开源工具，是静态代码检查工具，采用 B/S 架构它主要用于管理源代码的质量，可以支持众多计算机语言，比如 php，java, C#, go，C/C++, Cobol, JavaScrip, Groovy 等。sonar 可以通过 PMD，CheckStyle，Findbugs 等等代码规则检测工具来检测你的代码，帮助你发现代码的漏洞，Bug，异味等信息。

架构

一台 SonarQube Server 启动 3 个主要过程：
- Web 服务器，供开发人员，管理人员浏览高质量的快照并配置 SonarQube 实例
- 基于 Elasticsearch 的 Search Server 从 UI 进行后退搜索
- Compute Engine 服务器，负责处理代码分析报告并将其保存在 SonarQube 数据库中
一个 SonarQube 数据库要存储：
- SonarQube 实例的配置（安全性，插件设置等）
- 项目，视图等的质量快照。
服务器上安装了多个 SonarQube 插件，可能包括语言，SCM，集成，身份验证和管理插件
在构建/持续集成服务器上运行一个或多个 SonarScanner，以分析项目

工作原理

开发人员在 IDE 开发代码，可以安装 SonarLint 插件进行提交前代码扫描当开发人员提交代码到版本控制系统中，自动触发 jenkins 进行代码扫描

版本

开源社区版、开发版、企业版、数据中心版

Docker 安装 SonarQube

这里采用 docker 容器进行安装，简单快捷

BASH

## 创建数据目录
mkdir -p /u01/sonarqube/{data,extensions,logs}
chmod 777 -R /u01/cicd/sonarqube/

## 调整
sysctl -w vm.max_map_count=262144

## 运行
docker run -d -p 9000:9000 -p 9092:9092 --name sonarqube \
	-v /u01/sonarqube/data:/opt/sonarqube/data \
	-v /u01/sonarqube/extensions:/opt/sonarqube/extensions \
	-v /u01/sonarqube/logs:/opt/sonarqube/logs \
	-e SONAR_JDBC_USERNAME=sonar \
	-e SONAR_JDBC_PASSWORD=sonar \
	-e SONAR_JDBC_URL="jdbc:postgresql://192.168.88.236:5432/sonar" \
	--restart=always \
	--privileged=true \
    sonarqube:8.9.9-community

## 验证
docker logs -f sonarqube

访问：http://192.168.88.235:9000/

默认账号：admin/admin

配置 Scanner

安装

AWK

# 获取安装包
wget https://binaries.sonarsource.com/Distribution/sonar-scanner-cli/sonar-scanner-cli-4.6.0.2311-linux.zip

# 解压到指定目录
unzip -o -d  /usr/local/sonar-scanner /opt/sonar-scanner-cli-4.6.0.2311-linux.zip

# 编辑环境变量
vim /etc/profile
export SCANNER_HOME=/usr/local/sonar-scanner/sonar-scanner-4.6.0.2311-linux
export PATH=$PATH:$SCANNER_HOME/bin

# 使环境变量生效
source /etc/profile

# 查看版本
sonar-scanner -v
INFO: Scanner configuration file: /usr/local/sonar-scanner-4.6.0.2311-linux/conf/sonar-scanner.properties
INFO: Project root configuration file: NONE
INFO: SonarScanner 4.6.0.2311
INFO: Java 11.0.3 AdoptOpenJDK (64-bit)
INFO: Linux 4.18.0-80.el8.x86_64 amd64

# 修改使用的jdk
vim /usr/local/sonar-scanner/sonar-scanner-4.6.0.2311-linux/bin/sonar-scanner

SonarQube 平台配置管理

安装中文插件

在线安装：操作如下图

配置强制登录

默认所有的项目都可以公开的查看，在企业内肯定要配置成私有的。只有登录后才能查看

Jenkins 配置 SonarScanner

创建 SonarQube 账户 token

将 token 保存到 Jenkins 凭据中

在 Jenkins 中安装SonarQube Scanner插件

1	系统管理 -> 系统配置 -> 往下翻找到SonarQube servers -> Add SonarQube -> 添加服务器，选择凭据

IDEA 配置 SonarLint 插件

Token：a3268ff16b2d08b4582ff6a97342cc9d11b4e456

Nexus 制品库安装与配置

Docker 安装部署 Nexus 制品库

BASH

## 拉取镜像
docker pull sonatype/nexus3:3.30.0

## 创建数据目录
mkdir -p /u01/cicd/nexus3/data
chmod 777 -R /u01/cicd/nexus3/

## 启动容器
docker run -itd \
--privileged=true --name=nexus3 \
-p 8081:8081 \
-v /u01/cicd/nexus3/data:/nexus-data \
sonatype/nexus3:3.30.0

## 验证
docker logs nexus3 -f

## 日志中出现 “Started Sonatype Nexus OSS 3.30.0-01” 为启动成功
## http://your-ip-addr:8081 访问测试

安装完成后，默认的 admin 密码存储在了数据目录，获取初始化密码

1	docker exec -i nexus3 cat /nexus-data/admin.password

登录后更新密码

Nexus 制品库搭建

搭建 Maven 私服（代理仓库）

默认安装 nexus 后会自动创建的

私服：将外网仓库代理到企业内部本地仓库中。图中的地址可以自定义修改

搭建制品库（本地仓库）

新建 raw 类型的仓库

设置仓库的信息

上传制品

在 nexus 中新建一个maven-hostd仓库，同时在 maven 的配置文件settings.xml中配置 maven-hostd 认证。具体配置如下：

XML
<server>
    <id>maven-hosted</id>
    <username>admin</username>
    <password>wx123!@#</password>
</server>

注意使用mvn deploy发布时，server.id=repository.id

BASH
mvn deploy:deploy-file
-DgroupId=xxxxxx pom中的groupId
-DartifactId=xxxxxx pom中的artifactId
-Dversion=xxxxxx pom中的版本号version
-Dpackaging=xxxxxx pom中打包方式
-Dfile=xxxxxx 本地文件
-Durl=xxxxxx 仓库url
-DrepositoryId=xxxxxx 对应的是setting.xml（认证）

直接读取 pom 文件（方便）

BASH
mvn deploy:deploy-file \
-DgeneratePom=false \
-DrepositoryId=maven-hosted \
-Durl=http://192.168.1.200:8081/repository/maven-hosted/ \
-DpomFile=pom.xml \
-Dfile=target/demo-0.0.1-SNAPSHOT.jar

自定义 pom 信息（灵活）

BASH
mvn deploy:deploy-file -Dmaven.test.skip=true  \
-Dfile=target/demo-0.0.1-SNAPSHOT.jar \
-DgroupId=com.example \
-DartifactId=demo \
-Dversion=1.1.1  \
-Dpackaging=jar \
-DrepositoryId=maven-hosted \
-Durl=http://192.168.1.200:8081/repository/maven-hosted/

Jenkins 安装 Nexus 插件

安装Nexus Artifact Upload插件，使用片段生成器生成 DSL

发布制品

安装Maven Artifact ChoiceListProvider (Nexus)插件

images

用户选择制品，在应用服务器通过 salt、ansible 下载制品并部署

Ansible 安装与配置

基于 centos7.6 安装

APPLESCRIPT
# 直接使用yum在线安装
yum install ansible -y
# 检查ansible版本
ansible --version

添加 Ansible 主机列表

编辑 `/etc/ansible/hosts` 文件

BASH
vim /etc/hosts
61.171.72.190 chxapp01.vansys.com
61.171.72.190 chxapp02.vansys.com
61.171.72.190 chxapp03.vansys.com

vim /etc/ansible/hosts
chxapp01.vansys.com ansible_ssh_user=root ansible_ssh_port=51722
chxapp02.vansys.com ansible_ssh_user=root ansible_ssh_port=51822
chxapp03.vansys.com ansible_ssh_user=root ansible_ssh_port=51522

发送公钥到目标主机

BASH
# 生成私钥和公钥（已有则忽略）
cd ~/.ssh && ssh-keygen -t rsa

ssh-copy-id -i ~/.ssh/id_rsa.pub -p SSH端口 IP

测试连通性

1 2	BASH ansible host01,host02 -m ping -o

安装 Npm 包管理器

AWK

# 下载node安装包
wget https://nodejs.org/dist/v14.16.1/node-v14.16.1-linux-x64.tar.xz
mkdir -p /usr/local/node
tar xf node-v14.16.1-linux-x64.tar.xz -C /usr/local/node/

# 编辑环境变量
vim /etc/profile
export NODE_HOME=/usr/local/node/node-v14.16.1-linux-x64
export PATH=$NODE_HOME/bin:$PATH
# 生效
source /etc/profile
# 查看是否安装成功
node -v
npm -v

# 设置镜像
npm config set registry https://registry.npm.taobao.org --global
npm config set disturl https://npm.taobao.org/dist --global

# 设置软链接
unlink /usr/bin/node
whereis node
ln -s /usr/local/node/node-v14.16.1-linux-x64/bin/node /usr/bin/node

Centos6 配置 yum

AWK
# centos6配置yum
sed -i “s|enabled=1|enabled=0|g” /etc/yum/pluginconf.d/fastestmirror.conf
mv /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.backup
curl -o /etc/yum.repos.d/CentOS-Base.repo https://www.xmpan.com/Centos-6-Vault-Aliyun.repo
yum clean all
yum makecache

Minio 文件服务安装与配置

AWK

# 二进制安装
wget https://dl.min.io/server/minio/release/linux-amd64/minio
chmod +x minio
MINIO_ROOT_USER=admin MINIO_ROOT_PASSWORD=password ./minio server /mnt/data --console-address ":9001"

# 后台启动
MINIO_ROOT_USER=admin MINIO_ROOT_PASSWORD='wx123!@#' nohup /u01/minio-server/minio server /u01/minio-server/data --console-address ":9001" > /u01/minio-server/minio.log 2>&1 &

# docker安装
mkdir -p /u01/minio/data

docker run -d \
  -p 9000:9000 \
  -p 9001:9001 \
  --name minio \
  -v /u01/minio/data:/data \
  -v /u01/minio/config:/root/.minio \
  -e "MINIO_ROOT_USER=q5H0EO1pbv" \
  -e "MINIO_ROOT_PASSWORD=Wyk1dkn4Xp" \
  -e MINIO_SERVER_URL=http://192.168.88.200:9000 \
  -e MINIO_BROWSER_REDIRECT_URL=http://192.168.88.200:9001 \
  quay.io/minio/minio server /data \
  --address ":9000" --console-address ":9001"

GitStats 代码统计工具安装与配置

安装 Ruby 环境

GitStats 需要 ruby-2.5 以上环境

BASH

# 下载：
wget https://cache.ruby-lang.org/pub/ruby/2.5/ruby-2.5.0.tar.gz
# 解压：
tar -zxvf ruby-2.5.0.tar.gz
# 进入目录：
cd ruby-2.5.0
# 创建安装目录：
mkdir -p /usr/local/ruby
# 安装必备依赖
yum -y install gcc openssl-devel make
# 配置并制定安装位置：
./configure --prefix=/usr/local/ruby
# 编译安装
make  && make install

安装完成输入  ruby -v 提示/usr/bin/ruby: No such file or directory

解决问题之前，先确认一个情况，输入命令 /usr/local/ruby/bin/ruby --version

如果有版本信息，那说明ruby被装到了该目录下，而非系统认为的 /usr/bin/ruby

解决方法是在系统默认运行ruby的位置[/usr/bin/ruby]创建一个symlink（相当于win下的快捷方式），指向ruby的实际位置[/usr/local/ruby/bin/ruby]

建立软链接
命令是  ln -s /usr/local/ruby/bin/ruby /usr/bin/ruby
再输入   ruby -v           OK完成


附赠：要是安装gem也出现这种情况[-bash: /usr/bin/gem: No such file or directory]也是同理

ln -s /usr/local/ruby/bin/gem /usr/bin/gem

#查看当前仓库地址
gem sources -l
#配置阿里云仓库源
gem sources -a http://mirrors.aliyun.com/rubygems/ --remove https://rubygems.org/

安装 GitStats

AWK

# 安装 git_stats
gem install git_stats
# 安装locate
yum install mlocate -y
updatedb
# find 命令查找 git_stats 目录
find / -name 'git_stats'
# 进入到配置目录
cd /usr/local/ruby/lib/ruby/gems/2.5.0/gems/git_stats-1.0.17/config/locales/
cp zh_tw_default.yml zh_default.yml
#修改以下2个yml,将最上边的zh_tw调整为zh_cn，其余不变
vim zh_default.yml
vim zh.yml


# 若报以下错误
ERROR:  Error installing git_stats:
	The last version of nokogiri (~> 1.6) to support your Ruby & RubyGems was 1.12.5. Try installing it with `gem install nokogiri -v 1.12.5` and then running the current command again

# 运行
gem install nokogiri -v 1.12.5

# 配置环境变量，放到末尾
vim /etc/profile
PATH=/usr/local/ruby/bin:$PATH
export PATH

# 使之生效
source /etc/profile

使用 GitStats 生成报告

AWK
# 创建一个项目文件夹
mkdir -p /u01/git-project
# 创建一个报告生成文件夹
mkdir -p /var/www/git-report

# 使用 git 将项目 clone 到项目文件夹中
git clone xxx.git
# 切换到项目根目录，使用 git_stats 生成报告
git_stats generate -o /var/www/git-report/xxx --language zh_cn

配置 nginx 访问

NGINX
server {
        listen       8098;
        server_name  192.168.88.235;

	    location /vansysboot {
            alias   /var/www/git-report/vansysboot;
            index  index.html index.htm;
        }
}

安装 Prometheus + Grafana 监控平台

官网：https://prometheus.io/

下载地址：https://prometheus.io/download/

安装 Prometheus Server

Prometheus 基于 Golang 编写，编译后的软件包，不依赖于任何的第三方依赖。只需要下载对应平台的二进制包，解压并且添加基本的配置即可正常启动 Prometheus Server。

上传安装包

上传 prometheus-2.29.1.linux-amd64.tar.gz 到虚拟机的 /opt 目录

解压安装包

解压到 /u01/module 目录下

1 2	BASH tar -zxvf prometheus-2.37.0.linux-amd64.tar.gz -C /u01/module

1
2
3

BASH
cd /u01/module
mv prometheus-2.37.0.linux-amd64.tar.gz prometheus-2.37.0

修改配置文件 prometheus.yml

1
2
3

BASH
cd prometheus-2.37.0
vim prometheus.yml

在 scrape_configs 配置项下添加配置：

YAML
# 添加 PushGateway 监控配置
- job_name: 'pushgateway'
  static_configs:
  - targets: ['192.168.88.231:9091']
    labels:
      instance: pushgateway

# 添加 Node Exporter 监控配置
- job_name: 'node exporter'
  static_configs:
  - targets: ['192.168.88.230:9100', '192.168.88.231:9100', '192.168.88.232:9100']

配置说明：

global 配置块：控制 Prometheus 服务器的全局配置
- scrape_interval：配置拉取数据的时间间隔，默认为 1 分钟。
- evaluation_interval：规则验证（生成 alert）的时间间隔，默认为 1 分钟。
rule_files 配置块：规则配置文件
scrape_configs 配置块：配置采集目标相关， prometheus 监视的目标。Prometheus 自身的运行信息可以通过 HTTP 访问，所以 Prometheus 可以监控自己的运行数据。
- job_name：监控作业的名称
- static_configs：表示静态目标配置，就是固定从某个 target 拉取数据
- targets ：指定监控的目标，其实就是从哪儿拉取数据。 Prometheus 会从 http://ip:9090/metrics 上拉取数据。

Prometheus 是可以在运行时自动加载配置的。启动时需要添加：–web.enable-lifecycle

重载配置命令：curl -X POST http://127.0.0.1:9090/-/reload

安装 Node Exporter

在 Prometheus 的架构设计中，Prometheus Server 主要负责数据的收集，存储并且对外提供数据查询支持，而实际的监控样本数据的收集则是由 Exporter 完成。因此为了能够监控到某些东西，如主机的 CPU 使用率，我们需要使用到 Exporter。Prometheus 周期性的从 Exporter 暴露的 HTTP 服务地址（通常是 /metrics ）拉取监控样本数据。

Exporter 可以是一个相对开放的概念，其可以是一个独立运行的程序独立于监控目标以外，也可以是直接内置在监控目标中。只要能够向 Prometheus 提供标准格式的监控样本数据即可。

为了能够采集到主机的运行指标如 CPU, 内存，磁盘等信息。我们可以使用 Node Exporter。Node Exporter 同样采用 Golang 编写，并且不存在任何的第三方依赖，只需要下载，解压即可运行。

上传安装包

上传 node_exporter-1.4.0-rc.0.linux-amd64.tar.gz 到虚拟机的 /opt 目录

解压安装包

解压到 /u01/module 目录下

1 2	BASH tar -zxvf node_exporter-1.4.0-rc.0.linux-amd64.tar.gz -C /u01/module

1
2
3

BASH
cd /u01/module
mv node_exporter-1.4.0-rc.0.linux-amd64.tar.gz node_exporter-1.4.0-rc

启动并访问端点查看是否成功

1
2
3

BASH
# 执行启动命令
./node_exporter

浏览器输入：http://ip:9100/metrics，可以看到当前 node exporter 获取到的当前主机的所有监控数据。

节点分发

将解压的目录分发到要监控的节点

1 2	BASH xsync node_exporter-1.4.0-rc

添加文件分发脚本

创建脚本文件：

1 2	BASH vim /usr/bin/xsync

脚本内容：

SHELL

#!/bin/bash
# 判断参数是否足够
if [ $# -lt 1 ]
then
 echo Not Enounh Arguement!
 exit;
fi

# 遍历所有的机器
for host in 192.168.88.230 192.168.88.231 192.168.88.232
do
 echo ============  $host ============
 for file in $@
 do
  # 判断文件是否存在
  if [ -e $file ]
  then
   # 获取父目录
   pdir=$(cd -P $(dirname $file); pwd)

   # 获取当前目录的名称
   fname=$(basename $file)
   ssh $host "mkdir -p $pdir"
   rsync -av $pdir/$fname $host:$pdir
  else
   echo $file does not exists!
  fi
 done
done

若报错 bash: rsync: command not found，请在目标机器上安装

1
2
3

BASH
# Centos
yum install rsync -y

赋予执行权限

1 2	BASH chmod +x /usr/bin/xsync

运行条件

使用 ssh 密钥验证登录，这样在传输文件时就不需要进行二次验证

BASH
# 生成ssh私钥（若有这忽略）
ssh-keygen -f ~/.ssh/id_rsa -N ''
# 循环把公钥传递到服务器上，免密登录
for i in 192.168.88.230 192.168.88.231 192.168.88.232
do
  ssh-copy-id $i
done

# 根据提示输入密码

设置开机自启

centos6

创建自启动脚本

BASH

vim /etc/init.d/node_exporter
#!/bin/bash
#	/etc/rc.d/init.d/node_exporter
# chkconfig: 2345 80 80
#
# config: /etc/prometheus/node_exporter.conf
# pidfile: /var/run/prometheus/node_exporter.pid

# Source function library.
. /etc/init.d/functions


RETVAL=0
PROG="node_exporter"
DAEMON_SYSCONFIG=/etc/sysconfig/${PROG}
DAEMON=/usr/bin/${PROG} #要把安装目录下/u01/module/node_exporter/node_exporter可执行文件拷贝到/usr/bin目录下
PID_FILE=/var/run/prometheus/${PROG}.pid
LOCK_FILE=/var/lock/subsys/${PROG}
LOG_FILE=/var/log/prometheus/node_exporter.log
DAEMON_USER="prometheus"
FQDN=$(hostname)
GOMAXPROCS=$(grep -c ^processor /proc/cpuinfo)

. ${DAEMON_SYSCONFIG}

start() {
  if check_status > /dev/null; then
    echo "node_exporter is already running"
    exit 0
  fi

  echo -n $"Starting node_exporter: "
  daemonize -u ${DAEMON_USER} -p ${PID_FILE} -l ${LOCK_FILE} -a -e ${LOG_FILE} -o ${LOG_FILE} ${DAEMON} ${ARGS}
  RETVAL=$?
  echo ""
  return $RETVAL
}

stop() {
    echo -n $"Stopping node_exporter: "
    killproc -p ${PID_FILE} -d 10 ${DAEMON}
    RETVAL=$?
    echo
    [ $RETVAL = 0 ] && rm -f ${LOCK_FILE} ${PID_FILE}
    return $RETVAL
}

check_status() {
    status -p ${PID_FILE} ${DAEMON}
    RETVAL=$?
    return $RETVAL
}

case "$1" in
    start)
        start
        ;;
    stop)
        stop
        ;;
    status)
	check_status
        ;;
    reload|force-reload)
        reload
        ;;
    restart)
        stop
        start
        ;;
    *)
        N=/etc/init.d/${NAME}
        echo "Usage: $N {start|stop|status|restart|force-reload}" >&2
        RETVAL=2
        ;;
esac

exit ${RETVAL}

编辑 etc/sysconfig/node_exporter

AWK
vim /etc/sysconfig/node_exporter
##添加如下内容
ARGS=""

BASH

##开机脚本赋权
chmod 777 /etc/init.d/node_exporter

##拷贝可执行文件到/usr/bin/
cp /u01/node_exporter-1.4.0-rc/node_exporter /usr/bin/node_exporter

## 添加用户组
groupadd -r prometheus

## 创建目录
mkdir -p /usr/hostonnet/prometheus/
useradd -r -g prometheus -s /sbin/nologin -d /usr/hostonnet/prometheus/ -c "prometheus Daemons" prometheus

## 家目录修改属主
chown -R prometheus:prometheus /usr/hostonnet/prometheus/

## 创建运行目录
mkdir -p /var/run/prometheus/
chmod 777 /var/run/prometheus/

## 创建pid文件，并赋权
touch /var/run/prometheus/node_exporter.pid
chmod 777 /var/run/prometheus/node_exporter.pid

## 创建日志目录，并创建日志文件，赋权，修改属主
mkdir -p /var/log/prometheus/
touch /var/log/prometheus/node_exporter.log
chmod 777 /var/log/prometheus
chmod 777 /var/log/prometheus/node_exporter.log
chown prometheus:prometheus /var/log/prometheus/node_exporter.log

# 批量执行语句
chmod 777 /etc/init.d/node_exporter && cp /u01/node_exporter-1.4.0-rc/node_exporter /usr/bin/node_exporter && groupadd -r prometheus && mkdir -p /usr/hostonnet/prometheus/ && useradd -r -g prometheus -s /sbin/nologin -d /usr/hostonnet/prometheus/ -c "prometheus Daemons" prometheus && chown -R prometheus:prometheus /usr/hostonnet/prometheus/ && mkdir -p /var/run/prometheus/ && chmod 777 /var/run/prometheus/ && touch /var/run/prometheus/node_exporter.pid && chmod 777 /var/run/prometheus/node_exporter.pid && mkdir -p /var/log/prometheus/ && touch /var/log/prometheus/node_exporter.log && chmod 777 /var/log/prometheus && chmod 777 /var/log/prometheus/node_exporter.log && chown prometheus:prometheus /var/log/prometheus/node_exporter.log

安装 daemonize

1 2	BASH rpm -ivh daemonize-1.6.0-1.el6.rf.x86_64.rpm

运行 node_exporter

1
2
3

AWK
#启动 node_exporter 并设置开机自启动
cd /etc/init.d/ && ./node_exporter start && chkconfig node_exporter on

centos7

创建 service 文件

1 2	BASH sudo vim /usr/lib/systemd/system/node_exporter.service

文件内容：

INI

[Unit]
Description=node_export
Documentation=https://github.com/prometheus/node_exporter
After=network.target

[Service]
Type=simple
User=root
ExecStart= /u01/node_exporter-1.4.0-rc/node_exporter
Restart=on-failure

[Install]
WantedBy=multi-user.target

分发文件

1 2	BASH xsync /usr/lib/systemd/system/node_exporter.service

设置开机自启并启动（所有机器都执行）

BASH
# 开机自启
sudo systemctl enable node_exporter.service

# 启动服务
sudo systemctl start node_exporter.service

安装 Alertmanager

上传安装包

上传 alertmanager-0.24.0.linux-amd64.tar.gz 到虚拟机的 /opt 目录

解压安装包

解压到 /u01/module 目录下

1 2	BASH tar -zxvf alertmanager-0.24.0.linux-amd64.tar.gz -C /u01/module

1
2
3

BASH
cd /u01/module
mv alertmanager-0.24.0.linux-amd64.tar.gz alertmanager-0.24.0

启动 Prometheus Server 和 Alertmanager

在 Prometheus Server 目录下执行启动命令

1 2	BASH nohup ./prometheus --config.file=prometheus.yml --web.enable-lifecycle > ./prometheus.log 2>&1 &

在 Alertmanager 目录下启动

1 2	BASH nohup ./alertmanager --config.file=alertmanager.yml > ./alertmanager.log 2>&1 &

安装 Grafana 数据展示

grafana 是一款采用 Go 语言编写的开源应用，主要用于大规模指标数据的可视化展现，是网络架构和应用分析中最流行的时序数据展示工具，目前已经支持绝大部分常用的时序数据库。

下载地址：https://grafana.com/grafana/download

上传安装包

将 grafana-enterprise-9.0.6.linux-amd64.tar.gz 上传至 /opt 目录下

解压安装包

解压到 /u01/module 目录下

1 2	BASH tar -zxvf grafana-enterprise-9.0.6.linux-amd64.tar.gz -C /u01/module

1
2
3

BASH
cd /u01/module
mv grafana-enterprise-9.0.6.linux-amd64.tar.gz grafana-enterprise-9.0.6

启动 grafana 服务

1 2	BASH nohup ./bin/grafana-server web > ./grafana.log 2>&1 &

打开浏览器，访问：http://ip:3000，默认用户名/密码：admin

Grafana 与 Prometheus 数据对接

添加 Prometheus 数据源

配置 -> 数据源 -> 添加数据源

选择 Prometheus 数据源

配置 Prometheus Server 地址

点击下方的 Save&Test

点击 Back 返回即可，可以看到 Data Sources 页面，出现了添加的 Prometheus：

添加仪表盘 Dashboard

手动一个个添加 Dashboard 比较繁琐，Grafana 社区鼓励用户分享 Dashboard，通过 https://grafana.com/grafana/dashboards 网站，可以找到大量可直接使用的 Dashboard 模板。

Grafana 中所有的 Dashboard 通过 JSON 进行共享，下载并且导入这些 JSON 文件，就可以直接使用这些已经定义好的 Dashboard。

选择一款中文版本的 Node Exporter 仪表板

下载模板 json 文件

在 Grafana 中导入模板

导入之后选择 Prometheus 数据源即可

导入成功之后就能看到炫酷的仪表板

安装 OracleDB Exporter 监控 Oracle 数据库

GitHub 仓库：iamseth/oracledb_exporter: Prometheus Oracle database exporter. (github.com)

Grafana 面板：Oracledb 监控-性能与表空间 | Grafana Labs

以下步骤是采用 Docker 进行安装

BASH

# 1、拉取最新版本镜像
docker pull ghcr.io/iamseth/oracledb_exporter:0.5.0
# 2、使用 docker run 命令启动
# 注意：1、--link 连接 oracle 数据库容器，这样在 oracledb_exporter 容器中可以直接使用容器名字代替 IP 地址进行通信
# 	   2、若密码中含有 !@#$ 等特殊字符，可以使用 URLEncode 进行转义
docker run -d --name oracledb_exporter --link=oracle11g -p 9161:9161 -e 'DATA_SOURCE_NAME=oracle://sys:123456@oracle11g:1521/orcl' ghcr.io/iamseth/oracledb_exporter:0.5.0
# 3、使用 culr 访问指标情况
curl -l http://127.0.0.1:9161/metric
# 4、接入 Prometheus
在 prometheus.yml 中添加一段配置：
  - job_name: oracledb_exporter
    metrics_path: /metrics
    static_configs:
      - targets: ['chxdb21.vansys.com:15090']

Docker 安装 ClickHouse 数据库 a

前提：请先安装好 Docker 容器服务（安装 Docker 容器服务）

BASH
mkdir -p /u01/clickhouse/{data,config,log}

chmod -R 777 /u01/clickhouse/{data,config,log}

拉取镜像

1 2	BASH docker pull yandex/clickhouse-server

创建临时容器

BASH
docker run --rm -d --name=clickhouse-server \
--ulimit nofile=262144:262144 \
-p 8123:8123 -p 9009:9009 -p 9000:9000 \
yandex/clickhouse-server:latest

复制临时容器内配置文件到宿主机

BASH
docker cp clickhouse-server:/etc/clickhouse-server/config.xml /u01/clickhouse/config/config.xml

docker cp clickhouse-server:/etc/clickhouse-server/users.xml /u01/clickhouse/config/users.xml

停掉临时容器

1 2	BASH docker rm -f clickhouse-server

default 用户配置

BASH

# 生成sha256sum密码

# 随机生成密码
PASSWORD=$(base64 < /dev/urandom | head -c8); echo "$PASSWORD"; echo -n "$PASSWORD" | sha256sum | tr -d '-'

会输出明码和SHA256密码（每个人生成的不一样）
jQ+72k17
a70b3173bfef01aff0d2472fd1f86a4be647aed4e0624f1b6c867a69072e1273

# 生成指定密码wx123456
echo "wx123456"; echo -n "wx123456" | sha256sum | tr -d '-'
wx123456
37acf78e288b1323fae2115749edcf696b6190d8c8ca1cbc66e39b10e22f2a86

# 打开users.xml文件 default用户设置密码为123456
vim /u01/clickhouse/config/users.xml

# 将文件中<password></password>改为以下内容
<password_sha256_hex>37acf78e288b1323fae2115749edcf696b6190d8c8ca1cbc66e39b10e22f2a86</password_sha256_hex>

# 将default用户改为只读
# 将<profile>default</profile>改为以下内容
<profile>readonly</profile>

新增 root 用户

BASH

# 生成root用户密码wx123456
echo "wx123456"; echo -n "wx123456" | sha256sum | tr -d '-'
wx123456
37acf78e288b1323fae2115749edcf696b6190d8c8ca1cbc66e39b10e22f2a86

# 打开users.xml文件
vim /u01/clickhouse/config/users.xml
# 在</default>下一行添加以下内容
<root>
<password_sha256_hex>37acf78e288b1323fae2115749edcf696b6190d8c8ca1cbc66e39b10e22f2a86</password_sha256_hex>
    <networks incl="networks" replace="replace">
            <ip>::/0</ip>
    </networks>
    <profile>default</profile>
    <quota>default</quota>
</root>

部署 clickhouse-server

BASH
docker run -d \
--name clickhouse-server \
--privileged=true --restart=always \
--ulimit nofile=262144:262144 \
-p 8123:8123 \
-p 9000:9000 \
-p 9009:9009 \
-v /u01/clickhouse/data:/var/lib/clickhouse:rw \
-v /u01/clickhouse/log:/var/log/clickhouse-server:rw \
-v /u01/clickhouse/config/config.xml:/etc/clickhouse-server/config.xml \
-v /u01/clickhouse/config/users.xml:/etc/clickhouse-server/users.xml \
yandex/clickhouse-server:latest

Docker 安装 ElasticSearch 搜索引擎

前提：请先安装好 Docker 容器服务（安装 Docker 容器服务）

BASH

# 创建es 相关挂载目录
mkdir -p /hd/docker/es/{config,data,plugins}
# 创建文件
vi /hd/docker/es/config/elasticsearch.yml
http.host: 0.0.0.0
http.cors.enabled: true
http.cors.allow-origin: "*"
http.cors.allow-headers: Authorization
xpack.security.enabled: true
xpack.security.transport.ssl.enabled: true

# 设置目录权限，否则会报错
chmod +x ./config/elasticsearch.yml
# 设置为目录 777 权限
chmod -R 777 /hd/docker/es

拉取镜像

1 2	BASH docker pull elasticsearch:7.17.4

启动容器

BASH
docker run --name es --restart=always -p 9200:9200 -p 9300:9300 \
-e "ES_JAVA_OPTS=-Xms512m -Xmx1024m" \
-v /hd/docker/es/config/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml \
-v /hd/docker/es/data:/usr/share/elasticsearch/data \
-v /hd/docker/es/plugins:/usr/share/elasticsearch/plugins \
-d elasticsearch:7.17.4

配置 es 访问密码

BASH
# 进入容器内部
docker exec -it es /bin/bash

# 配置密码命令
./bin/elasticsearch-setup-passwords interactive

访问网页 http://localhost:9200（账号密码：`elastic`/`123456`）

Docker 安装 Nginx Proxy Manager 代理管理平台

前提：请先安装好 Docker 容器服务（安装 Docker 容器服务）

创建 docker-compose.yml

使用 network_mode: host 与宿主机共享网络

YML
version: '3'
services:
  app:
    image: 'chishin/nginx-proxy-manager-zh:latest'
    restart: always
    network_mode: host
    volumes:
      - ./data:/data
      - ./letsencrypt:/etc/letsencrypt

部署运行

1 2	SHELL docker compose up -d

登录管理平台

容器运行成功后，使用浏览器访问 81 端口。

http://127.0.0.1:81

默认管理员信息：

1
2
3

AVRASM
Email:    admin@example.com
Password: changeme

登录之后系统会要求修改详细信息和密码

快速升级

SHELL
docker-compose down
docker-compose pull
docker-compose up -d

Docker 安装 Redis 服务

拉取 Redis 镜像

SHELL
# 拉取最新版本
docker pull redis
# 指定版本号
docker pull redis:5.0.8

启动 Redis 容器

建议使用配置文件启动，先从 Redis 官网下载标准配置文件（也可以自己准备一个）

SHELL

# 创建配置文件存放目录
mkdir -p /u01/software/redis/conf
cd /u01/software/redis/conf

# 下载 redis.conf 配置文件
wget http://download.redis.io/redis-stable/redis.conf

# 给配置文件授权
chmod 777 redis.conf

# 修改配置文件

常用编程环境与开发工具安装手册

安装 Docker 容器服务

CentOS 安装

Ubuntu 安装

Redis 缓存安装部署

解压安装包

编译并安装

将 Redis 安装为系统服务并后台启动

查看 Redis 服务启动情况

启动 Redis 客户端并测试

运行远程连接

设置访问密码

WEB 服务器 Nginx 安装部署

解压安装包

预先安装额外的依赖

编译安装 Nginx

启动 Nginx

Centos6.9 注册为系统服务，并开机自启

CentOS7 注册为系统服务，并开机自启

JDK（Java 环境）安装

准备 JDK 安装包

卸载已有的 OPENJDK（如果有）

创建目录并解压

配置 JDK 环境变量

验证 JDK 安装结果

Maven 项目构建和管理工具安装

准备 MAVEN 安装包并解压

配置 MAVEN 加速镜像源

配置环境变量

检验安装结果

Jenkins 安装与配置

安装 Jenkins Master

安装 Jenkins Slave

Jenkins 插件管理

Jenkins 用户权限管理

Jenkins 凭证管理

Jenkins 关联 JDK 和 Maven

Jenkins 关闭跨站请求伪造保护

添加 Jenkins 全局变量

Jenkins 数据迁移和备份

Jenkins 删除构建历史

Jenkins 构建 Maven 项目

Jenkins 项目构建类型

自由风格项目构建

Maven 项目构建

Pipeline 流水线项目构建(*)

Pipeline 简介

Pipeline 语法快速入门

Jenkinsfile

Jenkinsfile 环境变量

常用的构建触发器

Git Hook 自动触发构建(*)

SonarQube 平台安装与配置

认识 SonarQube

架构

工作原理

版本

Docker 安装 SonarQube

配置 Scanner

SonarQube 平台配置管理

安装中文插件

配置强制登录

Jenkins 配置 SonarScanner

IDEA 配置 SonarLint 插件

Nexus 制品库安装与配置

Docker 安装部署 Nexus 制品库

Nexus 制品库搭建

搭建 Maven 私服（代理仓库）

搭建制品库（本地仓库）

上传制品

Jenkins 安装 Nexus 插件

Ansible 安装与配置

基于 centos7.6 安装

添加 Ansible 主机列表

编辑 /etc/ansible/hosts 文件

发送公钥到目标主机

测试连通性

安装 Npm 包管理器

Centos6 配置 yum

Minio 文件服务安装与配置

编辑 `/etc/ansible/hosts` 文件