基于Kubernetes构建企业Jenkins master/slave CI/CD平台

搭建平台目的：
　　k8s中搭建jenkins master/slave架构，解决单jenkins执行效率低，资源不足等问题（jenkins master 调度任务到 slave上，并发执行任务，提升任务执行的效率）

CI/CD环境特点：
　　Slave弹性伸缩
　　基于镜像隔离构建环境
　　流水线发布，易维护

 

 

 一、环境准备 服务名 地址 版本 k8s-master 10.48.14.100 v1.22.3 k8s-node1 10.48.14.50 v1.22.3 k8s-node2 10.48.14.51 v1.22.3 gogs代码仓库 10.48.14.50:30080   harbor镜像仓库 10.48.14.50:8888 v1.8.1

 

K8S集群搭建参考：https://www.cnblogs.com/cfzy/p/16145576.html
使用gogs作为代码仓库，harbor作为镜像仓库：搭建参考（https://www.cnblogs.com/cfzy/p/16049885.html）

 二、了解发布流程

1.蓝绿发布
    项目逻辑上分为AB组，在项目升级时，首先把A组从负 载均衡中摘除，进行新版本的部署。
    B组仍然继续提供 服务。A组升级完成上线，B组从负载均衡中摘除。

    特点：
        策略简单
        升级/回滚速度快
        用户无感知，平滑过渡
    缺点：
        需要两倍以上服务器资源
        短时间内浪费一定资源成本
    

2.灰度发布
    灰度发布：
　　　　只升级部分服务，即让一部分用户继续用 老版本，一部分用户开始用新版本，如果用户对新版 本没有什么意见，那么逐步扩大范围，把所有用户都 迁移到新版本上面来。
    特点：
        保证整体系统稳定性
        用户无感知，平滑过渡
    缺点：
        自动化要求高
    

    k8s中的落地方式
     

3.滚动发布
    滚动发布：
        每次只升级一个或多个服务，升级完成 后加入生产环境，不断执行这个过程，直到集群中 的全部旧版升级新版本。 
    特点：
        用户无感知，平滑过渡
        
    缺点：
        部署周期长
        发布策略较复杂
        不易回滚
　　

 三、在Kubernetes中部署Jenkins  3.1 部署jenkins

　创建动态PVC：为Jenkins提供持久化存储（因为之前创建了NFS作为后端存储的PVC"managed-nfs-storage"，所以直接拿来用了）

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: jenkins
spec:
  storageClassName: "managed-nfs-storage"
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 5Gi

     kubectl apply -f pvc.yml 
  创建deploy资源运行Jenkins服务：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: jenkins
  labels:
    name: jenkins
spec:
  replicas: 1
  selector:
    matchLabels:
      name: jenkins 
  template:
    metadata:
      name: jenkins
      labels:
        name: jenkins
    spec:
      serviceAccountName: jenkins
      containers:
        - name: jenkins
          image: jenkins/jenkins:lts-jdk11
          ports:
            - containerPort: 8080
            - containerPort: 50000
          resources:
            limits:
              cpu: 2
              memory: 2Gi
            requests:
              cpu: 1
              memory: 1Gi
          env:
            - name: TZ
              value: Asia/Shanghai
            - name: LIMITS_MEMORY
              valueFrom:
                resourceFieldRef:
                  resource: limits.memory
                  divisor: 1Mi
          volumeMounts:
            - name: jenkins-home
              mountPath: /var/jenkins_home
      securityContext:
        fsGroup: 1000
      volumes:
      - name: jenkins-home
        persistentVolumeClaim:
          claimName: jenkins

　　 kubectl apply -f deployment.yml
  创建名为Jenkins的SA，并授权：

# 创建名为jenkins的ServiceAccount
apiVersion: v1
kind: ServiceAccount
metadata:
  name: jenkins

---
# 创建名为jenkins的Role，授予允许管理API组的资源Pod
kind: Role
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: jenkins
rules:
- apiGroups: [""]
  resources: ["pods"]
  verbs: ["create","delete","get","list","patch","update","watch"]
- apiGroups: [""]
  resources: ["pods/exec"]
  verbs: ["create","delete","get","list","patch","update","watch"]
- apiGroups: [""]
  resources: ["pods/log"]
  verbs: ["get","list","watch"]
- apiGroups: [""]
  resources: ["secrets"]
  verbs: ["get"]

---
# 将名为jenkins的Role绑定到名为jenkins的ServiceAccount
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: jenkins
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: Role
  name: jenkins
subjects:
- kind: ServiceAccount
  name: jenkins

　　 kubectl apply -f rbac.yaml
  暴露Jenkins服务端口：

apiVersion: v1
kind: Service
metadata:
  name: jenkins
spec:
  selector:
    name: jenkins
  type: NodePort
  ports:
    -
      name: http
      port: 80
      targetPort: 8080
      protocol: TCP
      nodePort: 30006
    -
      name: agent
      port: 50000
      protocol: TCP
      targetPort: 50000

    kubectl apply -f service.yml 
 为Jenkins的URL设置域名访问：

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: jenkins
  annotations:
    kubernetes.io/ingress.class: "nginx"
    nginx.ingress.kubernetes.io/ssl-redirect: "true"
    kubernetes.io/tls-acme: "true"
    nginx.ingress.kubernetes.io/client_max_body_size: 100m
    nginx.ingress.kubernetes.io/proxy-body-size: 50m
    nginx.ingress.kubernetes.io/proxy-request-buffering: "off"
spec:
  rules:
  - host: jenkins.test.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: jenkins
            port: 
              number: 80

    kubectl apply -f ingress.yml 
 在host文件添加dns记录
 访问jenkins：jenkins.test.com
 登录页面，安装推荐插件，如果安装失败就更换成国内源地址

 3.2 配置jenkins下载插件地址，并安装必要插件

cd $jenkins_home/ 
    sed -i 's#https://updates.jenkins.io/update-center.json#http://mirrors.tuna.tsinghua.edu.cn/jenkins/updates/update-center.json#g' hudson.model.UpdateCenter.xml 
cd $jenkins_home/updates 
    替换插件源地址： 
　　　　sed -i 's#https://updates.jenkins.io/download#http://mirrors.aliyun.com/jenkins#g' default.json
    替换谷歌地址： 
       sed -i 's#http://www.google.com#http://www.baidu.com#g' default.json 　

安装插件：Git/Git Parameter/Pipeline/Kubernetes/Kubernetes Continuous Deploy/Config File Provider
　　Kubernetes Continuous Deploy： 用于将资源配置部署到Kubernetes
　　Config File Provider：用于存储kubectl用于连接k8s集群的kubeconfig配置文件

 注意：Kubernetes Continuous Deploy插件因为版本原因，在构建过程中报错，所以被我弃用了，用Config File Provider插件代替也可以达到目的

 3.3 Jenkins在K8S中动态创建代理

3.3.1 配置Kubernetes plugin           
   Jenkins页面配置k8s集群信息：系统管理——系统配置——Cloud——配置集群
　　 
　　 

　　注意：这个是最重要的一个配置，决定整个安装的成败，"kubernetes地址" 用"https://kubernetes.default"或者"https://k8s集群主节点的ip+端口"，
　　　然后点击"连接测试"，连接成功会出现k8s版本号。
　　　为什么连k8s不需要凭证：jenkins是在k8s内部搭建的，所以不需要k8s凭证，如果是在外部搭建的就需要添加k8s凭证
　　　jenkins地址： kubectl get svc 　　#查看jenkins的端口
　　　jenkins通道：这个参数是Jenkins Master和Jenkins Slave之间通信必须配置的，kubectl get svc 　　#查看ip和端口
　　　　

3.3.2 构建Jenkins—slave镜像（Dockerfile）
   #jenkins 官方有jenkins-slave 制作好的镜像，可以直接 docker pull jenkins/jnlp-slave 下载到本地并上传本地私有镜像厂库。
　　  官方的镜像好处就是不需要再单独安装maven,kubectl 这样的命令了，如果项目是maven构建就可以直接使用了。

　 #我们要用gradle构建项目，所以需要安装gradle，jdk等，构建镜像所需要Dockerfile如下：（需要先下载jdk和gradle二进制文件）
　　构建镜像所需文件在：https://github.com/fxkjnj/kubernetes/tree/main/jenkins-for_kubernetes/jenkins-slave 

FROM centos:7
MAINTAINER liang
ENV JAVA_HOME=/usr/local/java
ENV PATH=$JAVA_HOME/bin:/usr/local/gradle/bin:$PATH

RUN yum install -y maven curl git libtool-ltdl-devel && \
    yum clean all && \
    rm -rf /var/cache/yum/* && \
    mkdir -p /usr/share/jenkins
COPY jdk-11.0.9 /usr/local/java
COPY gradle6.4 /usr/local/gradle
COPY slave.jar /usr/share/jenkins/slave.jar 
COPY jenkins-slave /usr/bin/jenkins-slave
COPY settings.xml /etc/maven/settings.xml
RUN chmod +x /usr/bin/jenkins-slave
COPY kubectl /usr/bin
ENTRYPOINT ["jenkins-slave"]　　　

　　　　jenkins-slave：shell脚本，用于启动slave.jar 　　　　
　　　　settings.xml： 修改maven官方源为阿里云源 　　　　
　　　　slave.jar: agent程序，接收master下发的任务 　　　　
　　　　kubectl： 让jenkins-slave可以执行kubectl命令，cp /usr/bin/kubectl ./
 构建dockerfile，生成slave-agent镜像
　　docker build -t jenkins-slave-jdk:11 .
 上传到harbor仓库　　　　
　　docker tag jenkins-slave-jdk:11 10.48.14.50:8888/library/jenkins-slave-jdk:11 　　　　
　　docker login -u admin 10.48.14.50:8888 　　　　
　　docker push 10.48.14.50:8888/library/jenkins-slave-jdk:11

3.3.3 创建一个流水线任务，测试jenkins-slave功能（在k8s中动态创建代理）
　创建流水线任务 "test"
　　 

　编写pipeline测试脚本（声明式脚本）
　　需要注意的是，spec中定义containers名字一定要写jnlp

pipeline {
  agent {
    kubernetes {
        label "jenkins-slave"
        yaml """
kind: Pod
metadata:
  name: jenkins-slave
spec:
  containers:
  - name: jnlp
    image: "10.48.14.50:8888/library/jenkins-slave-jdk:11"
"""
    }
  }
 
    stages {
        stage('测试'){
            steps {
                sh """
                    echo hello
                   """
            }
        }
　　}
}

　保存，然后构建任务，查看日志信息

 　 　

 　　 

测试完成，功能正常。
　　在构建的时候，k8s集群default命名空间下，会临时启动一个pod(jenkins-slave-dr835-dh9dz)，这个pod就是jenkins动态创建的代理，
　　用于执行jenkins-master下发的构建任务，当jenkins构建完成后，这个pod自动销毁

 四、Jenkins在K8S中持续部署（完整流程）  4.1 持续集成和持续部署流程

持续集成CI：提交代码——代码构建——可部署的包——打包镜像——推送镜像仓库
持续部署CD：kubectl命令行/yaml文件——创建资源——暴露应用——更新镜像/回滚/扩容——删除资源

jenkins在k8s中持续集成部署流程
　　拉取代码：git checkout
　　代码编译：mvn clean
　　构建镜像并推送远程仓库
　　部署到K8S
　　开发测试

用kubectl命令行持续部署
    1、创建资源（deployment）
        kubectl create deployment tomcat --image=tomcat:v1
        kubectl get pods,deploy
    2、发布服务（service）
        kubectl expose deployment tomcat --port=80 --target-port=8080 --name=tomcat-service --type=NodePort
            --port 集群内部访问的service端口，即通过clusterIP:port可以访问到某个service
            --target-port 是pod的端口，从port和nodeport来的流量经过kube-proxy流入到后端pod的targetport上，最后进入容器
　　　　　　　nodeport：外部访问k8s集群中service的端口，如果不定义端口号会默认分配一个
        　　containerport：是pod内部容器的端口，targetport映射到containerport（一般在deployment中设置）
　　　　 kubectl get service     
        
    3、升级
        kubectl set image deployment tomcat 容器名称=tomcat:v2 --record=true
        #查看升级状态
        kubectl rollout status deployment/tomcat
        
    4、扩容缩容
        kubectl scale deployment tomcat --replicas=10

    5、回滚
        kubectl rollout history deployment/tomcat    #查看版本发布历史
        kubectl rollout undo deployment/tomcat        #回滚到上一版本        
        kubectl rollout undo deployment/tomcat --to-revision=2    #回滚到指定版本
            
    6、删除
        kubectl delete deployment/tomcat            #删除deployment资源
        kubectl delete service/tomcat-service        #删除service资源

 4.2 分步生成CI/CDpipeline语法

4.2.1 拉取代码（git checkout）
　　添加凭证（git仓库、harbor仓库）：系统管理——凭据配置——新增harbor、git仓库的用户名/密码

　　　 

　　用pipeline语法生成器，生成拉取代码步骤的pipeline语法：

　 　

 　　根据自己的代码仓库信息填写，然后点击生成流水线脚本，就有了拉取代码的脚本语法：（credentialsID、URL等信息可以定义成变量传输）

checkout([$class: 'GitSCM', branches: [[name: '*/master']], extensions: [], userRemoteConfigs: [[credentialsId: 'a5ec87ae-87a1-418e-aa49-53c4aedcd261', url: 'http://10.48.14.100:30080/001/java-demo.git']]])

  

  4.2.2 代码编译

　　mvn clean package -Dmaven.test.skip=true

 

  4.2.3 构建镜像

　制作一个tomcat镜像，因为java服务要跑着tomcat中：下载安装包apache-tomcat-8.5.34.tar.gz，并编写Dockerfile

FROM centos:7
MAINTAINER liang
ENV VERSION=8.5.34
RUN yum install -y java-1.8.0-openjdk wget curl unzip iproute net-tools && \
	yum clean all && \
	rm -rf /var/cache/yum/*
COPY apache-tomcat-${VERSION}.tar.gz /
RUN tar -zxf  apache-tomcat-${VERSION}.tar.gz && \
	mv apache-tomcat-${VERSION} /usr/local/tomcat && \
	rm -rf apache-tomcat-${VERSION}.tar.gz /usr/local/tomcat/webapps/* && \
	mkdir /usr/local/tomcat/webapps/test && \
	echo "ok" > /usr/local/tomcat/webapps/test/status.html && \
	sed -i '1a JAVA_OPTS="-Djava.security.edg=file:/dev/./urandom"' /usr/local/tomcat/bin/catalina.sh && \
	ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime
ENV PATH $PATH:/usr/local/tomcat/bin
WORKDIR /usr/local/tomcat
EXPOSE 8080
CMD ["catalina.sh","run"] 

　　  构建镜像，并上传镜像到harbor仓库
　　　　docker build -t tomcat:v1 .
　　　　docker tag tomcat:v1 10.48.14.50:8888/library/tomcat:v1
　　　　docker login -u admin 10.48.14.50:8888
　　　　docker push 10.48.14.50:8888/library/tomcat:v1

  以tomcat:v1为基础镜像，构建项目镜像，并上传到harbor仓库

FROM 10.48.14.50:8888/library/tomcat:v1
LABEL maitainer lizhenliang
RUN rm -rf /usr/local/tomcat/webapps/*
ADD target/*.war /usr/local/tomcat/webapps/ROOT.war　　　　

　　　　docker build -t 10.48.14.50:8888/dev/java-demo:v1 .
　　　　docker login -u admin 10.48.14.50:8888
　　　　docker push 10.48.14.50:8888/dev/java-demo:v1

　　通过credential插件生成ID号来隐藏harbor用户名密码，生成pipeline语法：

　  　 

　　pipeline中构建镜像并上传到harbor仓库：

#其中涉及的变量可以pipeline中定义	
stage('构建镜像'){
  steps {
    withCredentials([usernamePassword(credentialsId: "${docker_registry_auth}", passwordVariable: 'password', usernameVariable: 'username')]) {
      sh """
         echo '
            FROM ${registry}/library/tomcat:v1
            MAINTAINER liang
            RUN rm -rf /usr/local/tomcat/webapps/*
            ADD target/*.war /usr/local/tomcat/webapps/ROOT.war
           ' > Dockerfile
         docker build -t ${image_name} .
         docker login -u ${username} -p '${password}' ${registry}
	 docker push ${image_name}
        """
    }
  } 
}

　　

　4.2.4 部署服务到k8s

　　在k8s中为用户admin授权，生成kubeconfig文件。或者直接复制/root/.kube/config（这是一个kubeconfig文件）

　　Jenkins-slave镜像已经有kubectl命令，只需要kubeconfig就可以连接k8s集群

　　把生成的kubeconfig文件放到Jenkins中：需要安装Config File Provider插件，在Mansged files中配置

      

　　　　Manage Jenkins -> Managed files -> Add a new Config -> Custom file（自定义文件）

      

　　　　将生成的kubeconfig文件内容复制进去，复制ID号，在pipeline脚本定义变量：def k8s_auth = "ID号"

 　　　

　　用pipeline语法生成器，生成部署资源到k8s的pipeline语法：其中Target参数可以自定义

　    　

　　pipeline中部署资源到k8s：

stage('部署到K8S平台'){
  steps {
    configFileProvider([configFile(fileId: "${k8s_auth}", targetLocation: 'admin.kubeconfig')]) {
      sh """
        kubectl apply -f deploy.yaml -n ${Namespace} --kubeconfig=admin.kubeconfig
        sleep 10
        kubectl get pod -n ${Namespace} --kubeconfig=admin.kubeconfig
      """
    }
  }
}

 

 4.3 编写创建项目资源的deploy文件

项目是使用Jenkins在Kubernetes中持续部署一个无状态的tomcat pod应用；涉及到deployment控制器 以及采用NodePort 的方式去访问pod
deploy.yaml文件必须和项目代码在同一个路径下（否则kubectl无法指定yaml文件就无法创建pod），所以编写完yaml后，上传到项目仓库中

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    name: java-demo
  name: java-demo
  namespace: NS
spec:
  replicas: RSCOUNT
  selector:
    matchLabels:
      name: java-demo
  template:
    metadata:
      labels:
        name: java-demo
    spec:
      imagePullSecrets:
      - name: SECRET_NAME 
      containers:
      - image: IMAGE_NAME
        name: java-demo

---

apiVersion: v1
kind: Service
metadata:
  namespace: NS
  labels:
    name: java-demo
  name: java-demo
spec:
  type: NodePort
  ports:
  - port: 80
    protocol: TCP
    targetPort: 8080
  selector:
    name: java-demo

 4.4 定义环境变量，进行参数化构建，以及一些脚本优化

4.4.1 对jenkins-slave创建pod进行优化
   每次maven 打包会产生依赖的库文件，为了加快每次编译打包的速度，我们可以创建一个pvc或挂载目录，用来存储maven每次打包产生的依赖文件。
　　以及我们需要将 k8s 集群 node 主机上的docker 命令挂载到Pod 中，用于镜像的打包 ，推送，修改后的jenkins-salve如下：

    kubernetes {
        label "jenkins-slave"
        yaml """
kind: Pod
metadata:
  name: jenkins-slave
spec:
  containers:
  - name: jnlp
    image: "10.48.14.50:8888/library/jenkins-slave-jdk:11"
    imagePullPolicy: Always
    env: 
      - name: TZ
        value: Asia/Shanghai
    volumeMounts:
      - name: docker-cmd
        mountPath: /usr/bin/docker
      - name: docker-sock
        mountPath: /var/run/docker.sock
      - name: maven-cache
        mountPath: /root/.m2
      - name: gradle-cache
        mountPath: /root/.gradle
  volumes:
    - name: docker-cmd
      hostPath:
        path: /usr/bin/docker
    - name: docker-sock
      hostPath:
        path: /var/run/docker.sock
    - name: maven-cache
      hostPath:
         path: /tmp/m2
    - name: gradle-cache
      hostPath: 
        path: /tmp/gradle
""" 

4.4.2 创建一个登录harbor仓库的secret凭证（部署项目的yaml文件要从harbor拉取镜像需要认证）
    kubectl create secret docker-registry registrypullauth --docker-username=admin --docker-password=Harbor12345 --docker-server=10.48.14.50:8888

　　　　

4.4.3 定义环境变量，修改项目的deploy.yaml文件，进行参数化构建
　定义环境变量，在pipeline语法中引用变量：
    def registry = "10.48.14.50:8888"     #harbor仓库地址
    def project = "dev"                   #harbor存放镜像的仓库名
    def app_name = "java-demo"            #项目名
    def image_name = "${registry}/${project}/${app_name}:${BUILD_NUMBER}"        #编译打包成的镜像名
    def git_address = "http://10.48.14.100:30080/001/java-demo.git"
   // 认证
    def secret_name = "registrypullauth"　　　　#harbor用户名密码生成的secret 
    def docker_registry_auth = "b07ed5ba-e191-4688-9ed2-623f4753781c"   #harbor用户密码生成的id
    def git_auth = "a5ec87ae-87a1-418e-aa49-53c4aedcd261"
    def k8s_auth = "3cd3f414-a0e2-4bc0-8808-78c64e6ad7d2"
    def JAVA_OPTS = "-Xms128m -Xmx256m -Dfile.encoding=UTF8 -Duser.timezone=GMT+08 -Dspring.profiles.active=test"
　
 参数化构建过程中，交互内容：
　　代码分支（prod，dev，test）
　　副本数（1,3,5,7）
　　命名空间（prod，dev，test）
　　
 修改项目的deploy.yaml文件，替换成参数变量：
　　sed -i 's#IMAGE_NAME#${image_name}#' deploy.yaml
　　sed -i 's#SECRET_NAME#${secret_name}#' deploy.yaml
　　sed -i 's#RSCOUNT#${ReplicaCount}#' deploy.yaml
　　sed -i 's#NS#${Namespace}#' deploy.yaml
 指定kubeconfig，运行项目pod
　　kubectl apply -f deploy.yaml -n ${Namespace} --kubeconfig=admin.kubeconfig
　　

 4.5 完整的pipeline脚本

def registry = "10.48.14.50:8888"
// 项目
def project = "dev"
def app_name = "java-demo"
def image_name = "${registry}/${project}/${app_name}:${BUILD_NUMBER}"
def git_address = "http://10.48.14.100:30080/001/java-demo.git"
// 认证
def secret_name = "registrypullauth"
def docker_registry_auth = "b07ed5ba-e191-4688-9ed2-623f4753781c"
def git_auth = "a5ec87ae-87a1-418e-aa49-53c4aedcd261"
def k8s_auth = "3cd3f414-a0e2-4bc0-8808-78c64e6ad7d2"
def JAVA_OPTS = "-Xms128m -Xmx256m -Dfile.encoding=UTF8 -Duser.timezone=GMT+08 -Dspring.profiles.active=test"

pipeline {
  agent {
    kubernetes {
        label "jenkins-slave"
        yaml """
kind: Pod
metadata:
  name: jenkins-slave
spec:
  containers:
  - name: jnlp
    image: "${registry}/library/jenkins-slave-jdk:11"
    imagePullPolicy: Always
    env: 
      - name: TZ
        value: Asia/Shanghai
    volumeMounts:
      - name: docker-cmd
        mountPath: /usr/bin/docker
      - name: docker-sock
        mountPath: /var/run/docker.sock
      - name: gradle-cache
        mountPath: /root/.gradle
      - name: maven-cache
        mountPath: /root/.m2
  volumes:
    - name: docker-cmd
      hostPath:
        path: /usr/bin/docker
    - name: docker-sock
      hostPath:
        path: /var/run/docker.sock
    - name: gradle-cache
      hostPath: 
        path: /tmp/gradle
    - name: maven-cache
      hostPath:
        path: /tmp/m2
"""
        }
      }
    parameters {
        choice (choices: ['1', '3', '5', '7'], description: '副本数', name: 'ReplicaCount')
        choice (choices: ['dev','test','prod','default'], description: '命名空间', name: 'Namespace')
    }
    stages {
        stage('拉取代码'){
            steps {
                checkout([$class: 'GitSCM', 
                branches: [[name: "${params.Branch}"]], 
                doGenerateSubmoduleConfigurations: false, 
                extensions: [], submoduleCfg: [], 
                userRemoteConfigs: [[credentialsId: "${git_auth}", url: "${git_address}"]]
                ])
            }
        }

        stage('代码编译'){
           steps {
             sh """
                pwd
                mvn clean package -Dmaven.test.skip=true
                """ 
           }
        }

        stage('构建镜像'){
           steps {
                withCredentials([usernamePassword(credentialsId: "${docker_registry_auth}", passwordVariable: 'password', usernameVariable: 'username')]) {
                sh """
                  echo '
                    FROM ${registry}/library/tomcat:v1
                    LABEL maitainer lizhenliang
                    RUN rm -rf /usr/local/tomcat/webapps/*
                    ADD target/*.war /usr/local/tomcat/webapps/ROOT.war
                  ' > Dockerfile
                  docker build -t ${image_name} .
                  docker login -u ${username} -p '${password}' ${registry}
                  docker push ${image_name}
                """
                }
           } 
        }
        stage('部署到K8S平台'){
          steps {
            configFileProvider([configFile(fileId: "${k8s_auth}", targetLocation: 'admin.kubeconfig')]) {
              sh """
                pwd
                ls
                sed -i 's#IMAGE_NAME#${image_name}#' deploy.yaml
                sed -i 's#SECRET_NAME#${secret_name}#' deploy.yaml
                sed -i 's#RSCOUNT#${ReplicaCount}#' deploy.yaml
                sed -i 's#NS#${Namespace}#' deploy.yaml
                kubectl apply -f deploy.yaml -n ${Namespace} --kubeconfig=admin.kubeconfig
                sleep 10
                kubectl get pod -n ${Namespace} --kubeconfig=admin.kubeconfig
              """
           }
          }
        }
    }
}

 4.6 构建项目，查询日志

   　

　　

 查看构建过程和日志