基于jenkins、k8s、docker 实现自动部署服务

学习完k8s 之后，简单研究下，基于jenkins、gitlab、docker、k8s 实现自动部署微服务。

1. 机器规划

 后来机器扛不住，就将gitlab 镜像给停掉了，采用了gitee 。不过便于学习，还是学习了下其搭建过程。

2. 组件搭建

1. 安装gitlab

1. 拉取镜像并且启动

docker pull gitlab/gitlab-ce

mkdir -p /mnt/gitlab/config && mkdir -p /mnt/gitlab/logs && mkdir -p /mnt/gitlab/data

sudo docker run --detach \
--publish 443:443 --publish 80:80 --publish 2222:22 \
--name gitlab \
--restart always \
--volume /mnt/gitlab/config:/etc/gitlab \
--volume /mnt/gitlab/logs:/var/log/gitlab \
--volume /mnt/gitlab/data:/var/opt/gitlab \
gitlab/gitlab-ce

因为我在启动的时候报错22 端口已经被占用，所以我映射到了2222 端口。 查看gitlab 服务状态如下

[root@k8smaster01 ~]# docker ps -a | grep git
e37f4c46caf6        gitlab/gitlab-ce                                      "/assets/wrapper"        About an hour ago   Up 23 seconds (health: starting)   0.0.0.0:80->80/tcp, 0.0.0.0:443->443/tcp, 0.0.0.0:2222->22/tcp   gitlab

接下来有的需要修改配置文件， 对应于宿主机 /mnt/gitlab/config/gitlab.rb, 不修改可以访问git 但是新建仓库之后的http 地址和ssh 地址不正确:

# 配置http协议所使用的访问地址,不加端口号默认为80
external_url 'http://192.168.13.107/'

# 配置ssh协议所使用的访问地址和端口
gitlab_rails['gitlab_ssh_host'] = '192.168.13.107'
# 此端口是run时22端口映射的222端口
gitlab_rails['gitlab_shell_ssh_port'] = 2222 

接下来正常访问宿主机的80 端口即可访问到gitlab 服务器。

启动成功之后，查看初始的账号和密码， 被挂载到宿主机的如下目录: (第一次登录之后需要修改账号密码, 修改为: qwe123123)

[root@k8smaster01 config]# cat /mnt/gitlab/config/initial_root_password 
# WARNING: This value is valid only in the following conditions
#          1. If provided manually (either via `GITLAB_ROOT_PASSWORD` environment variable or via `gitlab_rails['initial_root_password']` setting in `gitlab.rb`, it was provided before database was seeded for the first time (usually, the first reconfigure run).
#          2. Password hasn't been changed manually, either via UI or via command line.
#
#          If the password shown here doesn't work, you must reset the admin password following https://docs.gitlab.com/ee/security/reset_user_password.html#reset-your-root-password.

Password: 7RLbaj2e0NSIcM6UfcQJQJRGW3xJ2J2C6b9MbqXJGVs=

# NOTE: This file will be automatically deleted in the first reconfigure run after 24 hours.

我们进入到容器查看相关的进程，可以看到一个gitlab 服务器安装的相关进程如下:

root@e37f4c46caf6:/# gitlab-ctl status
run: alertmanager: (pid 361) 724s; run: log: (pid 359) 724s
run: gitaly: (pid 260) 729s; run: log: (pid 259) 729s
run: gitlab-exporter: (pid 355) 724s; run: log: (pid 354) 724s
run: gitlab-workhorse: (pid 316) 727s; run: log: (pid 313) 727s
run: grafana: (pid 679) 585s; run: log: (pid 674) 586s
run: logrotate: (pid 264) 729s; run: log: (pid 263) 729s
run: nginx: (pid 336) 726s; run: log: (pid 335) 726s
run: postgres-exporter: (pid 362) 724s; run: log: (pid 360) 724s
run: postgresql: (pid 314) 727s; run: log: (pid 310) 727s
run: prometheus: (pid 364) 724s; run: log: (pid 363) 724s
run: puma: (pid 315) 727s; run: log: (pid 312) 727s
run: redis: (pid 262) 729s; run: log: (pid 261) 729s
run: redis-exporter: (pid 358) 724s; run: log: (pid 357) 724s
run: sidekiq: (pid 317) 727s; run: log: (pid 311) 727s
run: sshd: (pid 30) 749s; run: log: (pid 29) 749s

2. 安装jenkins

docker search jenkins

docker pull jenkins/jenkins:lts

[root@k8smaster02 ~]# docker images | grep jenk
jenkins/jenkins                                                   lts                 2a4bbe50c40b        2 months ago        441MB
[root@k8smaster02 ~]# docker inspect 2a4bbe50c40b # 查看拉取的镜像版本， 是2.319.1

mkdir -p /mnt/jenkins/

docker run -d --name jenkins -p 8080:8080 -v /mnt/jenkins:/home/jenkins_01 jenkins/jenkins:lts

# 启动后查看日志获取密码
[root@k8smaster02 jenkins]# docker logs d0f44023a64d
...
Jenkins initial setup is required. An admin user has been created and a password generated.
Please use the following password to proceed to installation:

e0b480871a42480b876e7e18af6432b7

This may also be found at: /var/jenkins_home/secrets/initialAdminPassword

*************************************************************
*************************************************************
*************************************************************

2022-02-18 06:24:29.402+0000 [id=49]    INFO    h.m.DownloadService$Downloadable#load: Obtained the updated data file for hudson.tasks.Maven.MavenInstaller
2022-02-18 06:24:29.403+0000 [id=49]    INFO    hudson.util.Retrier#start: Performed the action check updates server successfully at the attempt #1
2022-02-18 06:24:29.406+0000 [id=49]    INFO    hudson.model.AsyncPeriodicWork#lambda$doRun$1: Finished Download metadata. 401,840 ms

然后我访问8080 端口即可。第一次登录需要输入密码，密码是日志窗口提示的日志信息。

登录之后需要选择插件安装，我们选择手动安装的插件，然后清掉所有的插件即可。 然后确认后会进入创建默认用户的界面，创建一个用户 root/qwe123123

接下来安装必要的插件:

Jenkins >> Manage Jenkins >> Manage Plugins （插件管理也是在这个选项卡）

这里可以看见已经安装的plugin以及可以安装的plugin。这里我们安装：

　　Maven项目插件：Maven Integration plugin，这个插件可以让我们创建一个maven构建任务。

　　ssh传输工具插件：Publish Over SSH 项目打包完成后，使用这个插件，通过ssh的方式传输到远程服务器。

　　Gitlab插件：允许Jenkins访问gitlab服务器，拉取代码

        Pipeline: 流水线插件，用于构建流水线任务。基于流水线语法构造任务，也可以基于jenkins 的自由风格的项目进行构建。

一般简单的项目是基于自由风格，自己编写； 复杂的项目用pipeline 流水线。

补充： 由于后来发现挂载的目录缺少了data目录，jenkins 自动挂载了data 目录， 这个最好是启动时候自己挂载下

查看其挂载如下：

        "Mounts": [
            {
                "Type": "bind",
                "Source": "/mnt/jenkins",
                "Destination": "/home/jenkins_01",
                "Mode": "",
                "RW": true,
                "Propagation": "rprivate"
            },
            {
                "Type": "volume",
                "Name": "8d16c47f96e4ad0729f1c713a14d35863efb4bccec1d3799887edd332c4b5410",
                "Source": "/var/lib/docker/volumes/8d16c47f96e4ad0729f1c713a14d35863efb4bccec1d3799887edd332c4b5410/_data",
                "Destination": "/var/jenkins_home",
                "Driver": "local",
                "Mode": "",
                "RW": true,
                "Propagation": ""
            }
        ]

 0. 容器内部安装maven以及查看git、java

1. 宿主机下载执行包安装maven

[root@k8smaster02 jenkins]# curl -O http://mirrors.cnnic.cn/apache/maven/maven-3/3.3.9/binaries/apache-maven-3.3.9-bin.tar.gz
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100 8292k  100 8292k    0     0  3876k      0  0:00:02  0:00:02 --:--:-- 3876k
[root@k8smaster02 jenkins]# ll
total 8296
-rw-r--r-- 1 root root 8491533 Feb 19 06:15 apache-maven-3.3.9-bin.tar.gz

然后解压：

tar xvf apache-maven-3.3.9-bin.tar.gz

因为是目录挂载的关系，我们进入容器内部查看mvn 所在命令如下: (mvn 命令自动挂载到容器内部)

jenkins@d0f44023a64d:/$ /home/jenkins_01/apache-maven-3.3.9/bin/mvn -v
Apache Maven 3.3.9 (bb52d8502b132ec0a5a3f4c09453c07478323dc5; 2015-11-10T16:41:47+00:00)
Maven home: /home/jenkins_01/apache-maven-3.3.9
Java version: 11.0.13, vendor: Eclipse Adoptium
Java home: /opt/java/openjdk
Default locale: en, platform encoding: UTF-8
OS name: "linux", version: "3.10.0-1160.49.1.el7.x86_64", arch: "amd64", family: "unix"

2. 容器内部查看git、java

jenkins@d0f44023a64d:/$ whereis git
git: /usr/bin/git /usr/share/man/man1/git.1.gz
jenkins@d0f44023a64d:/$ java -version
openjdk version "11.0.13" 2021-10-19
OpenJDK Runtime Environment Temurin-11.0.13+8 (build 11.0.13+8)
OpenJDK 64-Bit Server VM Temurin-11.0.13+8 (build 11.0.13+8, mixed mode)
jenkins@d0f44023a64d:/$ whereis java
java: /opt/java/openjdk/bin/java

1. 流水线语法测试

　　如果了解可以跳过这一步。

1. 新建一个流水线项目

2. 编写流水线脚本

流水线脚本有下面两种方式：

(1) 自己在webui 界面编写pileline 脚本。 这种又有几种脚本模板，如下：

简单说就是有两种， 一种是Declarative声明式； 另一种是 Scripted脚本式， 可以编写一些groovy脚本语言。

(2) 将pipeline 脚本存放在scm ， 常见的就是放在git项目的根目录下面。

下面先研究第一种的Declarative声明式，用helloworld 模板修改之后进行测下； 第二种scm 下面的在后面进行测试。

2. pipeline 内容如下：(这个脚本模仿着写就好了， 生成的时候也有个helloworld 模板。 用stage 代表多个阶段。)

pipeline {
    agent any

    stages {
        stage('Hello') {
            steps {
                echo 'Hello World'
            }
        }
        
        stage('Hello1') {
            steps {
                echo 'Hello World1'
            }
        }
        
        stage('Hello2') {
            steps {
                echo 'Hello World2'
            }
        }
        
        stage('Hello3') {
            steps {
                echo 'Hello World3'
            }
        }        
    }
}

3. 最后保存后点击build now 运行即可。

补充： pipeline 脚本也可以定义变量，也可以获取jenkins 一些内置的变量，比如获取凭据账号密码和自定义的版本

pipeline {
    agent any

    environment {
        REDISTRY_ALIYUN = credentials('registry-aliyun')
        TEST_STR="1.0.0"
    }

    stages {
        stage('Hello') {
            steps {
                echo 'Hello World'
                echo "version:${TEST_STR}"
                echo "${REDISTRY_ALIYUN_USR}"
                echo "${REDISTRY_ALIYUN_PSW}"
            }
        }
    }
}

注意: pipeline 语法不需要记忆，可以点击流水线任务左侧的流水线语法会到流水线语法帮助界面。 可以用片段生成器或者Declarative 生命式语法，选择相应的任务然后生成阶段的语法。

3. 编写流水线部署java 项目: jenkins、maven、git

　　这里实现的效果就是通过git 拉取代码，拉取完用mvn 打包，打包之后将jar 包传输到应用服务器，并调用shell 脚本启动应用。这里需要理解，针对jenkins 的执行， 其资源的路径都是在容器内部的路径，不是宿主机的路径。

1. jenkins 设置， 如果设置好可以跳过这一步

(1) Manage Jenkins -> Manage Credentials -> jenkins -> 全局凭据 -> Add Credentials  这里实际上相当于管理一些账号密码

添加git 的凭据

(2) 配置账号：Jenkins >> Manage Jenkins >> System Configuration >> Configure System 中设置：

 

2. 编写pipeline 脚本: 下面的脚本都是基于流水线语法的片段生成器生成。 如果测试最终的脚本可以点击项目build now 进行测试

　　这里需要清楚，相关的脚本是跑在jenkins 容器内部的，所以相关的指令以及最后的产物都是基于容器的路径进行的。

(1) 编写拉取代码的git 脚本:

 拷贝到项目后如下：

pipeline {
    agent any

    stages {
        stage('checkout code') {
            steps {
                checkout([$class: 'GitSCM', branches: [[name: '*/master']], extensions: [], userRemoteConfigs: [[credentialsId: 'gitee', url: 'https://gitee.com/Qiao-Zhi/bs-school-navigation.git']]])
            }
        }             
    }
}

执行一次后到容器内部以及到宿主机查看相关的产物如下：

### 容器内部如下
jenkins@d0f44023a64d:~/workspace$ ls
bs-school-devops  bs-school-devops@tmp
jenkins@d0f44023a64d:~/workspace$ pwd
/var/jenkins_home/workspace
jenkins@d0f44023a64d:~/workspace$ du -h --max-depth=1
12M     ./bs-school-devops
0       ./bs-school-devops@tmp
12M     .

###宿主机如下
[root@k8smaster02 workspace]# ls
bs-school-devops  bs-school-devops@tmp
[root@k8smaster02 workspace]# pwd
/var/lib/docker/volumes/8d16c47f96e4ad0729f1c713a14d35863efb4bccec1d3799887edd332c4b5410/_data/workspace
[root@k8smaster02 workspace]# du -h --max-depth=1
12M     ./bs-school-devops
0       ./bs-school-devops@tmp
12M     .

(2) 执行mvn 打包

1》 到容器内部执行测试：

jenkins@d0f44023a64d:~/workspace/bs-school-devops$ cd /var/jenkins_home/workspace/bs-school-devops
jenkins@d0f44023a64d:~/workspace/bs-school-devops$ /home/jenkins_01/apache-maven-3.3.9/bin/mvn clean package -DskipTests

2》到jenkins 界面的流水线语法-》片段生成器 生成相关语法:

 和上面合并之后的脚本如下：

pipeline {
    agent any

    stages {
        stage('checkout code') {
            steps {
                checkout([$class: 'GitSCM', branches: [[name: '*/master']], extensions: [], userRemoteConfigs: [[credentialsId: 'gitee', url: 'https://gitee.com/Qiao-Zhi/bs-school-navigation.git']]])
            }
        }
        
        stage('mvn package') {
            steps {
                sh '''cd /var/jenkins_home/workspace/bs-school-devops
                /home/jenkins_01/apache-maven-3.3.9/bin/mvn clean package -DskipTests'''                
            }
        }        

    }
}

也可以格式化为：

pipeline {
    agent any

    stages {
        stage('checkout code') {
            steps {
                checkout([$class: 'GitSCM', branches: [[name: '*/master']], extensions: [], userRemoteConfigs: [[credentialsId: 'gitee', url: 'https://gitee.com/Qiao-Zhi/bs-school-navigation.git']]])
            }
        }
        
        stage('mvn package') {
            steps {
                sh '''
                    cd /var/jenkins_home/workspace/bs-school-devops
                    /home/jenkins_01/apache-maven-3.3.9/bin/mvn clean package -DskipTests
                '''                
            }
        }   
        
    }
}

　　可以点击build now 进行测试。

(3) 编写将package 后的jar 包传输到k8snode01 节点并且启动应用的pipeline 脚本

第一种就是自己配饰jenkins 和 各个主机的ssh 秘钥，然后用ssh 执行命令、scp 传输文件。第二种就是借助于插件。下面研究第二种借助于插件。

安装Publish Over ssh 插件， 之前版本可以搜索到，但是现在的版本好像从界面搜索不到。需要离线下载。 到 https://mirrors.tuna.tsinghua.edu.cn/jenkins/plugins/ 下载。

搜索到之后下载最新版本的 .hpi 文件， 需要如下三个hpi， publish over ssh 依赖另外两个:

publish-over-ssh.hpi
jsch.hpi
publish-over.hpi

　　下载后放到 /var/lib/docker/volumes/8d16c47f96e4ad0729f1c713a14d35863efb4bccec1d3799887edd332c4b5410/_data/plugins 目录， 会自动映射到容器内部 /var/jenkins_home/plugins 中,然后重启jenkins容器即可。

1》 配置SSHserver：Jenkins -》Configure System  -》 SSH Servers 点击add可以添加多个

 2》在k8snode1 节点创建目录 /home/bs-school ， 并且该目录下新建 deploy.sh, 内容如下：

#!/bin/bash
#这里可替换为你自己的执行程序，其他代码无需更改
APP_NAME=$2.jar

#使用说明，用来提示输入参数
usage() {
    echo "Usage: sh 脚本名.sh [start|stop|restart|status]"
    exit 1
}

#检查程序是否在运行
is_exist(){
    pid=`ps -ef|grep $APP_NAME|grep -v grep|awk '{print $2}' `
    #如果不存在返回1，存在返回0
    if [ -z "${pid}" ]; then
        return 1
    else
        return 0
    fi
}

#启动方法
start(){
    is_exist
    if [ $? -eq "0" ]; then
        echo "${APP_NAME} is already running. pid=${pid} ."
    else
        nohup java -jar $APP_NAME &
        echo "${APP_NAME} start success"
    fi
}

#停止方法
stop(){
    is_exist
    if [ $? -eq "0" ]; then
        kill -9 $pid
        echo "kill pid ${pid}"
    else
        echo "${APP_NAME} is not running"
    fi
}

#输出运行状态
status(){
    is_exist
    if [ $? -eq "0" ]; then
        echo "${APP_NAME} is running. Pid is ${pid}"
    else
        echo "${APP_NAME} is NOT running."
    fi
}

#重启
restart(){
    stop
    start
}

#根据输入参数，选择执行对应方法，不输入则执行使用说明
case "$1" in
    "start")
        start
    ;;
    "stop")
        stop
    ;;
    "status")
        status
    ;;
    "restart")
        restart
    ;;
    *)
    usage
    ;;
esac

3》到流水线语法用片段生成器生成，如下:

　　 sshpublisher 用于传输文件或者链接到远程主机执行shell 脚本，Transfers中的Transfer Set 可以包含多个。 每个必须包含传输文件或者shell 脚本，可以同时有。如果还需要在传输文件之前将已经存在的文件进行备份或者其他操作，可以在第一个Transfer set 执行shell 脚本进行备份。第二个transfer set 传输文件，然后启动应用。

　　上面只是将打包后的jar 包传输到109 服务器，然后执行对应的重启脚本。

关于上面的参数解释如下：

Source files: 是上传的文件，可以用通配符的形式。 该路径是以该项目路径为开始的相对路径。
remove prefix：删除的目录，如果不填，会在目录下创建一个target目录。官方解释如下:
　　if Source files were target/deployment/images/**/ then you may want Remove prefix to be target/deployment This would create the images folder under the remote directory, and not target/deployment Jenkins environment variables can be used in this path.
Remote directory：是上传的位置(远程应用服务器位置)，是一个相对路径。相对于上面SSHserver设置的路径。比如我上面设置的是/opt/jar，并且这个属性设置为/ssm。则文件上传后位于/opt/jar/ssm/ 目录
Exec command： 是上传后执行的远程命令。在上面我也是启动服务，注意默认路径是当前登录用户的根目录。我是root用户，所以默认在/root

最终生成的pipeline script 脚本如下:

sshPublisher(publishers: [sshPublisherDesc(configName: '192.168.13.109', transfers: [sshTransfer(cleanRemote: false, excludes: '', execCommand: '''cd /root/bs-school
sh deploy.sh restart springboot-ssm-0.0.1-SNAPSHOT''', execTimeout: 120000, flatten: false, makeEmptyDirs: false, noDefaultExcludes: false, patternSeparator: '[, ]+', remoteDirectory: '/root/bs-school', remoteDirectorySDF: false, removePrefix: 'target', sourceFiles: 'target/*.jar')], usePromotionTimestamp: false, useWorkspaceInPromotion: false, verbose: false)])

4》 和上面最终合成新的pipeline script 如下:

pipeline {
    agent any

    stages {
        stage('checkout code') {
            steps {
                checkout([$class: 'GitSCM', branches: [[name: '*/master']], extensions: [], userRemoteConfigs: [[credentialsId: 'gitee', url: 'https://gitee.com/Qiao-Zhi/bs-school-navigation.git']]])
            }
        }
        
        stage('mvn package') {
            steps {
                sh '''
                    /home/jenkins_01/apache-maven-3.3.9/bin/mvn clean package -DskipTests
                '''                
            }
        }   
        
        stage('ssh transper & start app') {
            steps {
                sshPublisher(publishers: [sshPublisherDesc(configName: '192.168.13.109', transfers: [sshTransfer(cleanRemote: false, excludes: '', execCommand: '''
                    cd /root/bs-school
                    sh deploy.sh restart springboot-ssm-0.0.1-SNAPSHOT
                ''', execTimeout: 120000, flatten: false, makeEmptyDirs: false, noDefaultExcludes: false, patternSeparator: '[, ]+', remoteDirectory: '/root/bs-school', remoteDirectorySDF: false, removePrefix: 'target', sourceFiles: 'target/*.jar')], usePromotionTimestamp: false, useWorkspaceInPromotion: false, verbose: false)])            
            }
        }
        
    }
}

5》 保存后点击build now， 即可以实现， 通过jenkins、git、mvn 实现打包，并通过jar 包的方式启动应用。

4. 基于jenkins、git、kubernetes、docker 实现基于容器的部署方式

　　上面3 中编写的pipeline 实际上是存在jenkins 服务端，有个弊端就是服务端宕机后造成脚本丢失，下面研究脚本存放在项目路径，然后实现从jenkins 通过git 拉取代码之后，通过mvn 打包，然后构造成镜像上传到镜像服务器(阿里镜像服务器)，再通过kubectl 开启应用。

其中：

(1) pipeline 脚本存放在项目根目录

(2) pipeline 脚本分为如下步骤:

1》拉取代码

2》mvn 打包

3》传输到107 kubernetes 主机(包括jar包、Dockerfile、kubernetes的yaml文件)，并且执行docker 打包、传送到镜像仓库、用kubectl 更新deployment 

(3) kubernetes 机子登录docker 镜像服务器的时候密码是明文的，如果想密文可以用jenkins的凭据和全局函数获取。

1.  前期准备：

1. 服务器在jenkins 上面的维护，方法同上面一样。

2. 108 kubernetes 创建一个dev namespace，用于存放新的任务

kubectl create namespace dev

3.107 kubernetes 服务器新建一个secret ， 用于拉取私有镜像

kubectl create secret docker-registry registry-aliyun --namespace=dev \
    --docker-server=registry.cn-hangzhou.aliyuncs.com --docker-username=username
--docker-password=pwd --docker-email=xxx@163.com

4. 107 上面新建目录

mkdir -p /root/bs-school

2. 搭建环境

1. 新建项目 bs-school, pipeline 选择from scm

2. 项目主要文件如下：

(1) 目录结构

 

(2) Jenkinsfile 内容如下，其实就是pipeline 脚本

pipeline {
    agent any

    stages {
        stage('checkout code') {
            steps {
                checkout([$class: 'GitSCM', branches: [[name: '*/devops-test']], extensions: [], userRemoteConfigs: [[credentialsId: 'gitee', url: 'https://gitee.com/Qiao-Zhi/bs-school-navigation.git']]])
            }
        }

        stage('mvn package') {
            steps {
                sh '''
                    /home/jenkins_01/apache-maven-3.3.9/bin/mvn clean package -DskipTests
                '''
            }
        }

        stage('ssh transper') {
            steps {
                sshPublisher(publishers: [sshPublisherDesc(configName: '192.168.13.107', transfers: [sshTransfer(cleanRemote: false, excludes: '', execCommand: '''cd /root/bs-school
docker images | grep bs-school-navigation | awk \'{print $3}\' | xargs docker rmi 2>>./rmi.log
docker build -t bs-school-navigation:1.0.0 .
docker tag bs-school-navigation:1.0.0 registry.cn-hangzhou.aliyuncs.com/qlq_repository/bs-school-navigation:1.0.0
docker login --username=username -p=pwd registry.cn-hangzhou.aliyuncs.com
docker push registry.cn-hangzhou.aliyuncs.com/qlq_repository/bs-school-navigation:1.0.0
kubectl delete -f bs-school-k8s.yaml
kubectl apply -f bs-school-k8s.yaml''', execTimeout: 120000, flatten: false, makeEmptyDirs: false, noDefaultExcludes: false, patternSeparator: '[, ]+', remoteDirectory: '/root/bs-school/', remoteDirectorySDF: false, removePrefix: '', sourceFiles: 'Dockerfile,bs-school-k8s.yaml,target/*.jar')], usePromotionTimestamp: false, useWorkspaceInPromotion: false, verbose: false)])
            }
        }

    }
}

(3) Dockerfile 内容如下

FROM openjdk:8-jdk-alpine
VOLUME /tmp
ADD ./target/bs-school-navigation.jar /bs-school-navigation.jar
ENTRYPOINT ["java", "-jar", "/bs-school-navigation.jar", "&"]

(4) bs-school-k8s.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: bs-school-navigation
  namespace: dev
  labels:
    app: bs-school-navigation
spec:
  replicas: 1
  selector:
    matchLabels:
      app: bs-school-navigation
  template:
    metadata:
      labels:
        app: bs-school-navigation
    spec:
      containers:
        - name: bs-school-navigation
          image: registry.cn-hangzhou.aliyuncs.com/qlq_repository/bs-school-navigation:1.0.0
          imagePullPolicy: Always
          ports:
            - containerPort: 8088
      imagePullSecrets:
        - name: registry-aliyun

---
apiVersion: v1
kind: Service
metadata:
  name: bs-school-navigation
  namespace: dev
  labels:
    app: bs-school-navigation
spec:
  type: NodePort
  ports:
    - port: 8088
      nodePort: 30002
  selector:
    app: bs-school-navigation

3. 保存后进行测试, 然后代码更新controller 后用jenkins 构建进行测试。 Controller 修改后，可以通过构建将最新的代码发布到kubernetes 环境中。

4. 上面还有许多可以改进的，比如发布的版本问题，每次构建的时候镜像什么的版本重新构造； 还有就是登录镜像仓库的时候，密码可以改为用jenkins的凭据管理；最后在107 服务器执行发布到kubernetes 环境中的一系列命令也可以编写为shell脚本，以sh脚本的形式进行调用。

　　至此实现了jenkins流水线，结合git、maven、docker、k8s 实现自动部署。接下来研究在kubesphere 环境中的构建。