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

阅读原文时间：2022年04月15日阅读：2

搭建平台目的：
　　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

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

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

特点：  
    策略简单  
    升级/回滚速度快  
    用户无感知，平滑过渡  
缺点：  
    需要两倍以上服务器资源  
    短时间内浪费一定资源成本  
![](https://article.cdnof.com/2204/6170c3d8-ba49-4e24-a68b-d1557ea162ca.jpg)

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

k8s中的落地方式  
 ![](https://article.cdnof.com/2204/32e3db95-3689-4b70-b844-a951a6c9f6f8.jpg)

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

缺点：  
    部署周期长  
    发布策略较复杂  
    不易回滚

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配置文件

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 这样的命令了，可以直接使用。
可能还需要安装gradle，jdk等，所以我们自己制作镜像，构建镜像所需要的文件：
#在https://github.com/fxkjnj/kubernetes/tree/main/jenkins-for_kubernetes/jenkins-slave 目录下
Dockerfile文件如下：

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自动销毁

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
  """
  }
  }
  }
  }
  }