1 Jenkins-Master-Slave架构图回顾
2 安装和配置NFS
3 在kubernetes中安装Jenkins-Master
- 3.1 安装NFS Client Provisior
- 3.2 安装Jenkins-Master
4 Jenkins和kubernetes的整合
- 4.1 安装kubernetes插件
- 4.2 实现Jenkins和kubernetes的整合
5 构建Jenkins-Slave自定义镜像
6 测试Jenkins-Slave是否可以创建
7 Jenkins+kubernetes+Docker完成微服务的持续集成
配置 eureka

1 Jenkins-Master-Slave架构图回顾

Jenkins-Master-Slave架构图回顾.png

2 安装和配置NFS

2.1 前提说明

NFS安装在k8s-master节点上，即192.168.18.100。

2.2 简介

NFS（Network File System），它最大的功能就是可以通过网络，让不同的机器、不同的操作系统可以共享彼此的文件。我们可以利用NFS共享Jenkins运行的配置文件、Maven的仓库依赖文件等。

2.3 NFS的安装

安装NFS服务：

yum install -y nfs-utils rpcbind

mkdir -pv /usr/local/jenkins

vim /etc/exports

# * 表示对所有的IP都开放，rw是读写权限
/usr/local/jenkins *(rw,no_root_squash)

chmod 777 -R /usr/local/jenkins

启动服务：

systemctl start rpcbind

systemctl enable rpcbind

systemctl start nfs

systemctl enable nfs

showmount -e 192.168.18.100

如果其他节点也需要使用NFS，需要安装NFS服务器。

yum install -y nfs-utils rpcbind

3 在kubernetes中安装Jenkins-Master

3.1 安装NFS Client Provisior

3.1.1 概述

NFS Client Provisior是一个kubernetes的简易NFS的外部provisior，本身不提供NFS，需要现有的NFS服务器提供存储。

3.1.2 上传nfs client provisior构建文件

本人是将这些资源文件上传到/root/nfs-client-provisior目录下（资源点这里nfs-client-provisior.zip）。

上传nfs client provisior构建文件.png

需要修改deployment.yaml文件，使用之前配置的NFS服务器和目录：

需要修改deployment.yaml文件，使用之前配置的NFS服务器和目录.png

3.1.3 构建nsf-client-provisior的Pod资源

cd /root/nfs-client-provisior

kubectl create -f .

3.1.4 查看Pod是否创建成功

kubectl get pod

查看nfs-client-provisior的Pod是否创建成功.png

3.2 安装Jenkins-Master

3.2.1 上传Jenkins-Master构建文件

本人是将这些资源文件上传到/root/jenkins-master目录下（资源点这里Jenkins-Master.zip）。

上传Jenkins-Master构建文件.png

需要注意：
- ①在Stateful.yaml文件中，声明利用了nfs-client-provisioner进行Jenkins-Master文件存储。

在Stateful.yaml文件中，声明利用了nfs-client-provisioner进行Jenkins-Master文件存储.png

②Service发布方法采用NodePort，会随机产生节点访问端口，当然你也可以自定指定端口。

Service发布方法采用NodePort，会随机产生节点访问端口.png

3.2.2 创建命名空间

kubectl create ns kube-ops

3.2.3 构建Jenkins-Master的Pod资源

cd /root/jenkins-master

kubectl create -f .

3.2.4 查看Pod是否创建成功

kubectl get pod -n kube-ops

安装Jenkins-Master之查看Pod是否创建成功.png

3.2.5 查看Service

kubectl get svc -n kube-ops

安装Jenkins-Master之查看Service.png

3.2.6 访问Jenkins

访问地址：http://192.168.18.100:30994。

安装Jenkins-Master之访问Jenkins.png

3.2.7 安装基本插件

Localization:Chinese。
Git。
Pipeline。
Extended Choice Parameter。
……

4 Jenkins和kubernetes的整合

4.1 安装kubernetes插件

Manage Jenkins—>插件管理—>可选插件。

安装kubernetes插件.png

4.2 实现Jenkins和kubernetes的整合

Manage Jenkins—>系统配置—>Cloud。

实现Jenkins和kubernetes的整合.png

Add a new Cloud—>kubernetes。

实现Jenkins和kubernetes的整合2.png

配置kubernetes的信息。

配置kubernetes的信息.png

kubernetes地址采用了kube的服务器发现：https://kubernetes.default.svc.cluster.local
namespace填写kube-ops，然后点击连接测试，如果出现Connected to Kubernetes v1.18.0的提示，就说明Jenkins已经可以和kubernetes系统正常通信了。
Jenkins的URL地址：http://jenkins.kube-ops.svc.cluster.local:8080。

5 构建Jenkins-Slave自定义镜像

5.1 概述

Jenkins-Master在构建Job的时候，kubernetes会创建Jenkins-Slave的Pod来完成Job的构建。我们选择运行Jenkins-Slave的镜像为官方推荐镜像：jenkins/jnlp-slave:latest，遗憾的是，这个镜像里面并没有Maven环境，为了方便使用，我们需要自定义一个新的镜像。
资源点这里jenkins-slave.zip。

5.2 准备工作

apache-maven-3.6.2-bin.tar.gz。
Dockerfile。
settings.xml。

构建Jenkins-Slave自定义镜像之准备工作.png

Dockerfile的内容如下：

# jenkins/jnlp-slave:latest # 这是基于JDK8的
#  这是基于JDK11的
FROM jenkins/jnlp-slave:latest-jdk11
MAINTAINER xudaxian
# 切换到 root 账户进行操作
USER root
# 安装 maven
COPY apache-maven-3.6.2-bin.tar.gz .
RUN tar -zxf apache-maven-3.6.2-bin.tar.gz && \
    mv apache-maven-3.6.2 /usr/local && \
    rm -f apache-maven-3.6.2-bin.tar.gz && \
    ln -s /usr/local/apache-maven-3.6.2/bin/mvn /usr/bin/mvn && \
    ln -s /usr/local/apache-maven-3.6.2 /usr/local/apache-maven && \
    mkdir -p /usr/local/apache-maven/repo
COPY settings.xml /usr/local/apache-maven/conf/settings.xml
USER jenkins

5.3 构建jenkins-slave-maven:latest镜像

docker build -t jenkins-slave-maven:latest .

5.4 将镜像上传到Harbor的公共库library中

docker tag jenkins-slave-maven:latest 192.168.18.104:85/library/jenkins-slave-maven:latest

docker login -u admin -p Harbor12345 192.168.18.104:85

docker push 192.168.18.104:85/library/jenkins-slave-maven:latest

6 测试Jenkins-Slave是否可以创建

6.1 创建一个Jenkins流水线项目

测试Jenkins-Slave是否可以创建之创建流水线项目.png

6.2 编写Pipeline，从Gitlab拉取代码

可以直接在项目中配置Pipeline脚本：

def git_address = "http://192.168.18.103/dev_group/jenkinscloud.git"
def git_auth = "3fd39bb6-c0dc-425f-9ce7-21341a4ea8a1"
//创建一个Pod的模板，label为jenkins-slave
podTemplate(label: 'jenkins-slave', cloud: 'kubernetes', containers: [
    containerTemplate(
        name: 'jnlp', 
        image: "192.168.18.104:85/library/jenkins-slave-maven:latest"
    )
  ]
) 
{
  //引用jenkins-slave的pod模块来构建Jenkins-Slave的pod
  node("jenkins-slave"){
      // 第一步
      stage('拉取代码'){
         checkout([$class: 'GitSCM', branches: [[name: 'master']], userRemoteConfigs: [[credentialsId: "${git_auth}", url: "${git_address}"]]])
      }
  }
}

测试Jenkins-Slave是否可以创建之编写Pipeline，从Gitlab拉取代码.png

6.3 查看构建日志

测试Jenkins-Slave是否可以创建之查看构建日志.png

7 Jenkins+kubernetes+Docker完成微服务的持续集成

7.1 前提说明

需要在Docker中信任Harbor仓库。
关闭防火墙。

7.2 拉取代码，构建镜像

7.2.1 创建NFS共享目录

让所有的Jenkins-Slave构建指向NFS的Maven共享仓库目录：

mkdir -pv /user/local/maven

chmod 777 -R /user/local/maven

vim /etc/exports

# 添加内容：
/user/local/jenkins   *(rw,no_root_squash) 
/user/local/maven     *(rw,no_root_squash)

# 重启NFS
systemctl daemon-reload
systemctl restart rpcbind.socket
systemctl restart nfs

7.2.2 创建项目，编写构建Pipeline

更改Docker命令的执行权限（注意 k8s所在的所有节点都必须执行下面的命令，因为你不知道k8s会指定那台机器上的Docker的命令）：

# 注意 k8s所在的所有节点都必须执行下面的命令
chmod 777 -R /var/run/docker.sock

在项目中添加Extended Choice Parameter：

拉取代码，构建镜像之添加Extended Choice Parameter.png

可以直接在项目中配置Pipeline脚本：

def git_address = "http://192.168.18.103/dev_group/jenkinscloud.git"
def git_auth = "3fd39bb6-c0dc-425f-9ce7-21341a4ea8a1"
//构建版本的名称
def tag = "1.0"
//Harbor私服地址
def harbor_url = "192.168.18.104:85"
//Harbor的项目名称
def harbor_project_name = "jenkinscloud"
//Harbor的凭证 
def harbor_auth = "5ecd7673-290f-4fab-b163-63bc98ff14ad"
//创建一个Pod的模板，label为jenkins-slave
podTemplate(label: 'jenkins-slave', cloud: 'kubernetes', containers: [
    containerTemplate(
        name: 'jnlp',
        image: "192.168.18.104:85/library/jenkins-slave-maven:latest"
    ),
     containerTemplate(
        name: 'docker',
        image: "docker:stable",
        ttyEnabled: true,
        command: 'cat'
    ),
  ],
  volumes: [
    hostPathVolume(mountPath: '/var/run/docker.sock', hostPath: '/var/run/docker.sock'),
    nfsVolume(mountPath: '/usr/local/apache-maven/repo', serverAddress: '192.168.18.100' , serverPath: '/usr/local/maven'),
  ],
)
{
  node("jenkins-slave"){
      // 第一步
      stage('拉取代码'){
         checkout([$class: 'GitSCM', branches: [[name: 'master']], userRemoteConfigs: [[credentialsId: "${git_auth}", url: "${git_address}"]]])
      }
      // 第二步
//       stage('代码编译'){
//         //编译并安装公共工程
//         sh "mvn -f jenkinscloud-common clean install"
//       }
      // 第三步
      stage('构建镜像，部署项目'){
         // 把选择的项目信息转为数组
         def selectedProjects = "${project_name}".split(',')
         for(int i=0;i<selectedProjects.size();i++){
            //取出每个项目的名称和端口
            def currentProject = selectedProjects[i];
            //项目名称
            def currentProjectName = currentProject.split('@')[0]
            //项目启动端口
            def currentProjectPort = currentProject.split('@')[1]
            //定义镜像名称
            def imageName = "${currentProjectName}:${tag}"
            //编译，构建本地镜像
            sh "mvn -f ${currentProjectName} clean package dockerfile:build"
            container('docker') {
                //给镜像打标签
                sh "docker tag ${imageName} ${harbor_url}/${harbor_project_name}/${imageName}"
                //登录Harbor，并上传镜像
                withCredentials([usernamePassword(credentialsId:"${harbor_auth}", passwordVariable: 'password', usernameVariable: 'username')]) {
                    //登录
                    sh "docker login -u ${username} -p ${password} ${harbor_url}"
                    //上传镜像
                    sh "docker push ${harbor_url}/${harbor_project_name}/${imageName}"
                }
                //删除本地镜像
                sh "docker rmi -f ${imageName}"
                sh "docker rmi -f ${harbor_url}/${harbor_project_name}/${imageName}"
              }
            }
         }
      }
}

7.3 微服务部署到k8s中

7.3.1 Jenkins安装Kubernetes Continuous Deploy插件

略。

7.3.2 查看kubernetes的kubeconfig文件的内容

cat /root/.kube/config

查看kubernetes的kubeconfig文件的内容.png

7.3.3 在Jenkins中新建kubernetes的凭证

在Jenkins中新建k8s的凭证信息.png

在Jenkins中新建k8s的凭证信息2.png

4a565527-cbb9-4fff-91ef-aefc03581f48

7.3.4 修改流水线脚本

def git_address = "http://192.168.18.103/dev_group/jenkinscloud.git"
def git_auth = "3fd39bb6-c0dc-425f-9ce7-21341a4ea8a1"
//构建版本的名称
def tag = "1.0"
//Harbor私服地址
def harbor_url = "192.168.18.104:85"
//Harbor的项目名称
def harbor_project_name = "jenkinscloud"
//Harbor的凭证 
def harbor_auth = "5ecd7673-290f-4fab-b163-63bc98ff14ad"
//k8s的凭证
def k8s_auth = "4a565527-cbb9-4fff-91ef-aefc03581f48"
// 定义k8s-harbor的凭证
def secret_name = "registry-auth-secret"
//创建一个Pod的模板，label为jenkins-slave
podTemplate(label: 'jenkins-slave', cloud: 'kubernetes', containers: [
    containerTemplate(
        name: 'jnlp',
        image: "192.168.18.104:85/library/jenkins-slave-maven:latest"
    ),
     containerTemplate(
        name: 'docker',
        image: "docker:stable",
        ttyEnabled: true,
        command: 'cat'
    ),
  ],
  volumes: [
    hostPathVolume(mountPath: '/var/run/docker.sock', hostPath: '/var/run/docker.sock'),
    nfsVolume(mountPath: '/usr/local/apache-maven/repo', serverAddress: '192.168.18.100' , serverPath: '/usr/local/maven'),
  ],
)
{
  node("jenkins-slave"){
      // 第一步
      stage('拉取代码'){
         checkout([$class: 'GitSCM', branches: [[name: 'master']], userRemoteConfigs: [[credentialsId: "${git_auth}", url: "${git_address}"]]])
      }
      // 第二步
//       stage('代码编译'){
//         //编译并安装公共工程
//         sh "mvn -f jenkinscloud-common clean install"
//       }
      // 第三步
      stage('构建镜像，部署项目'){
         // 把选择的项目信息转为数组
         def selectedProjects = "${project_name}".split(',')
         for(int i=0;i<selectedProjects.size();i++){
            //取出每个项目的名称和端口
            def currentProject = selectedProjects[i];
            //项目名称
            def currentProjectName = currentProject.split('@')[0]
            //项目启动端口
            def currentProjectPort = currentProject.split('@')[1]
            //定义镜像名称
            def imageName = "${currentProjectName}:${tag}"
            //编译，构建本地镜像
            sh "mvn -f ${currentProjectName} clean package dockerfile:build"
            container('docker') {
                //给镜像打标签
                sh "docker tag ${imageName} ${harbor_url}/${harbor_project_name}/${imageName}"
                //登录Harbor，并上传镜像
                withCredentials([usernamePassword(credentialsId:"${harbor_auth}", passwordVariable: 'password', usernameVariable: 'username')]) {
                    //登录
                    sh "docker login -u ${username} -p ${password} ${harbor_url}"
                    //上传镜像
                    sh "docker push ${harbor_url}/${harbor_project_name}/${imageName}"
                }
                //删除本地镜像
                sh "docker rmi -f ${imageName}"
                sh "docker rmi -f ${harbor_url}/${harbor_project_name}/${imageName}"
              }
              //部署到k8s中
              def deploy_image_name = "${harbor_url}/${harbor_project_name}/${imageName}"
              sh """
                 sed -i 's#\$IMAGE_NAME#${deploy_image_name}#' ${currentProjectName}/deploy.yml
                 sed -i 's#\$SECRET_NAME#${secret_name}#' ${currentProjectName}/deploy.yml  
              """
              kubernetesDeploy configs: "${currentProjectName}/deploy.yml", kubeconfigId: "${k8s_auth}"
            }
         }
      }
}

7.3.5 生成Docker的凭证

Docker的凭证，用于kubernetes到Docker的私服拉取镜像：

docker login -u admin -p Harbor12345 192.168.18.104:85

kubectl create secret docker-registry registry-auth-secret --docker-server=192.168.18.104:85 --docker-username='admin' --docker-password='Harbor12345' --docker-email='1900919313@qq.com'

查看密钥：

kubectl get secret

生成Docker的凭证之查看密钥.png

查看Secret中的内容：

kubectl get secrets registry-auth-secret --output="jsonpath={.data.\.dockerconfigjson}" | base64 -d

7.3.6 修改每个微服务的application.yaml，并在其根目录中添加deploy.yaml文件

jenkinscloud-eureka：
- application.yaml： ```yaml server: port: ${PORT:10086} spring: application: name: eureka

eureka: server:

# 续期时间，即扫描失效服务的间隔时间（缺省为60*1000ms）
eviction-interval-timer-in-ms: 5000
enable-self-preservation: false
use-read-only-response-cache: false

client:

# eureka client间隔多久去拉取服务注册信息 默认30s
registry-fetch-interval-seconds: 5
serviceUrl:
  defaultZone: ${EUREKA_SERVER:http://127.0.0.1:${server.port}/eureka/}

instance:

# 心跳间隔时间，即发送一次心跳之后，多久在发起下一次（缺省为30s）
lease-renewal-interval-in-seconds: 5
# 在收到一次心跳之后，等待下一次心跳的空档时间，大于心跳间隔即可，即服务续约到期时间（缺省为90s）
lease-expiration-duration-in-seconds: 10
instance-id: ${EUREKA_INSTANCE_HOSTNAME:${spring.application.name}}:${server.port}@${random.long(1000000,9999999)}
hostname: ${EUREKA_INSTANCE_HOSTNAME:${spring.application.name}}


   - deploy.yaml
```yaml
apiVersion: v1
kind: Service
metadata:
  name: eureka
  labels:
    app: eureka
spec:
  type: NodePort
  ports:
    - port: 10086
      name: eureka
      targetPort: 10086
  selector:
    app: eureka
---
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: eureka
spec:
  serviceName: "eureka"
  replicas: 2
  selector:
    matchLabels:
      app: eureka
  template:
    metadata:
      labels:
        app: eureka
    spec:
      imagePullSecrets:
        - name: $SECRET_NAME
      containers:
        - name: eureka
          image: $IMAGE_NAME
          ports:
            - containerPort: 10086
          env:
            - name: MY_POD_NAME
              valueFrom:
                fieldRef:
                  fieldPath: metadata.name
            - name: EUREKA_SERVER
              value: "http://eureka-0.eureka:10086/eureka/,http://eureka-1.eureka:10086/eureka/"
            - name: EUREKA_INSTANCE_HOSTNAME
              value: ${MY_POD_NAME}.eureka
  podManagementPolicy: "Parallel"

jenkinscloud-product：
- application.yaml ```yaml server: port: 9001 # 微服务的端口号

spring: application: name: service-product # 微服务的名称

配置 eureka

eureka: client: service-url: # Eureka Server的地址 defaultZone: http://eureka-0.eureka:10086/eureka/,http://eureka- 1.eureka:10086/eureka/ # Eureka访问地址 instance: instance-id: service-product prefer-ip-address: true


   - deploy.yaml
```yaml
apiVersion: v1
kind: Service
metadata:
  name: product
  labels:
    app: product
spec:
  type: NodePort
  ports:
    - port: 9001
      name: product
      targetPort: 9001
  selector:
    app: product
---
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: product
spec:
  serviceName: "product"
  replicas: 2
  selector:
    matchLabels:
      app: product
  template:
    metadata:
      labels:
        app: product
    spec:
      imagePullSecrets:
        - name: $SECRET_NAME
      containers:
        - name: product
          image: $IMAGE_NAME
          ports:
            - containerPort: 9001
  podManagementPolicy: "Parallel"

转载 https://www.yuque.com/fairy-era/yg511q/xo3bmu

基于kubernetes构建Jenkins持续集成平台（下）