• 基于 Jenkins 的 CI/CD (一)
    • 安装
    • 优点
    • 配置
    • 测试

    基于 Jenkins 的 CI/CD (一)

    前面的课程中我们学习了持久化数据存储在Kubernetes中的使用方法，其实接下来按照我们的课程进度来说应该是讲解服务发现这一部分的内容的，但是最近有很多同学要求我先讲解下 CI/CD 这块的内容，所以我们先把这块内容提前来讲解了。提到基于Kubernete的CI/CD，可以使用的工具有很多，比如Jenkins、Gitlab CI已经新兴的drone之类的，我们这里会使用大家最为熟悉的Jenins来做CI/CD的工具。

    安装

    听我们课程的大部分同学应该都或多或少的听说过Jenkins，我们这里就不再去详细讲述什么是 Jenkins 了，直接进入正题，后面我们会单独的关于 Jenkins 的学习课程，想更加深入学习的同学也可以关注下。既然要基于Kubernetes来做CI/CD，当然我们这里需要将 Jenkins 安装到 Kubernetes 集群当中，新建一个 Deployment：(jenkins2.yaml)

    1. ---
    2. apiVersion: extensions/v1beta1
    3. kind: Deployment
    4. metadata:
    5.   name: jenkins2
    6.   namespace: kube-ops
    7. spec:
    8.   template:
    9.     metadata:
    10.       labels:
    11.         app: jenkins2
    12.     spec:
    13.       terminationGracePeriodSeconds: 10
    14.       containers:
    15.       - name: jenkins
    16.         image: jenkins/jenkins:lts
    17.         imagePullPolicy: IfNotPresent
    18.         ports:
    19.         - containerPort: 8080
    20.           name: web
    21.           protocol: TCP
    22.         - containerPort: 50000
    23.           name: agent
    24.           protocol: TCP
    25.         resources:
    26.           limits:
    27.             cpu: 1000m
    28.             memory: 1Gi
    29.           requests:
    30.             cpu: 500m
    31.             memory: 512Mi
    32.         livenessProbe:
    33.           httpGet:
    34.             path: /login
    35.             port: 8080
    36.           initialDelaySeconds: 60
    37.           timeoutSeconds: 5
    38.           failureThreshold: 12 
    39.         readinessProbe:
    40.           httpGet:
    41.             path: /login
    42.             port: 8080
    43.           initialDelaySeconds: 60
    44.           timeoutSeconds: 5
    45.           failureThreshold: 12
    46.         volumeMounts:
    47.         - name: jenkinshome
    48.           subPath: jenkins2
    49.           mountPath: /var/jenkins_home
    50.         env:
    51.         - name: LIMITS_MEMORY
    52.           valueFrom:
    53.             resourceFieldRef:
    54.               resource: limits.memory
    55.               divisor: 1Mi
    56.         - name: JAVA_OPTS
    57.           value: -Xmx$(LIMITS_MEMORY)m -XshowSettings:vm -Dhudson.slaves.NodeProvisioner.initialDelay=0 -Dhudson.slaves.NodeProvisioner.MARGIN=50 -Dhudson.slaves.NodeProvisioner.MARGIN0=0.85 -Duser.timezone=Asia/Shanghai
    58.       securityContext:
    59.         fsGroup: 1000
    60.       volumes:
    61.       - name: jenkinshome
    62.         persistentVolumeClaim:
    63.           claimName: opspvc
    65. ---
    66. apiVersion: v1
    67. kind: Service
    68. metadata:
    69.   name: jenkins2
    70.   namespace: kube-ops
    71.   labels:
    72.     app: jenkins2
    73. spec:
    74.   selector:
    75.     app: jenkins2
    76.   type: NodePort
    77.   ports:
    78.   - name: web
    79.     port: 8080
    80.     targetPort: web
    81.     nodePort: 30002
    82.   - name: agent
    83.     port: 50000
    84.     targetPort: agent

    为了方便演示，我们把本节课所有的对象资源都放置在一个名为 kube-ops 的 namespace 下面，所以我们需要添加创建一个 namespace：

    1. $ kubectl create namespace kube-ops

    我们这里使用一个名为 jenkins/jenkins:lts 的镜像，这是 jenkins 官方的 Docker 镜像，然后也有一些环境变量，当然我们也可以根据自己的需求来定制一个镜像，比如我们可以将一些插件打包在自定义的镜像当中，可以参考文档：https://github.com/jenkinsci/docker，我们这里使用默认的官方镜像就行，另外一个还需要注意的是我们将容器的 /var/jenkins_home 目录挂载到了一个名为 opspvc 的 PVC 对象上面，所以我们同样还得提前创建一个对应的 PVC 对象，当然我们也可以使用我们前面的 StorageClass 对象来自动创建：(pvc.yaml)

    1. apiVersion: v1
    2. kind: PersistentVolume
    3. metadata:
    4.   name: opspv
    5. spec:
    6.   capacity:
    7.     storage: 20Gi
    8.   accessModes:
    9.   - ReadWriteMany
    10.   persistentVolumeReclaimPolicy: Delete
    11.   nfs:
    12.     server: 10.151.30.57
    13.     path: /data/k8s
    15. ---
    16. kind: PersistentVolumeClaim
    17. apiVersion: v1
    18. metadata:
    19.   name: opspvc
    20.   namespace: kube-ops
    21. spec:
    22.   accessModes:
    23.     - ReadWriteMany
    24.   resources:
    25.     requests:
    26.       storage: 20Gi

    创建需要用到的 PVC 对象：

    1. $ kubectl create -f pvc.yaml

    另外我们这里还需要使用到一个拥有相关权限的 serviceAccount：jenkins2，我们这里只是给 jenkins 赋予了一些必要的权限，当然如果你对 serviceAccount 的权限不是很熟悉的话，我们给这个 sa 绑定一个 cluster-admin 的集群角色权限也是可以的，当然这样具有一定的安全风险：（rbac.yaml）

    1. apiVersion: v1
    2. kind: ServiceAccount
    3. metadata:
    4.   name: jenkins2
    5.   namespace: kube-ops
    7. ---
    9. kind: Role
    10. apiVersion: rbac.authorization.k8s.io/v1beta1
    11. metadata:
    12.   name: jenkins2
    13.   namespace: kube-ops
    14. rules:
    15.   - apiGroups: [""]
    16.     resources: ["pods"]
    17.     verbs: ["create","delete","get","list","patch","update","watch"]
    18.   - apiGroups: [""]
    19.     resources: ["pods/exec"]
    20.     verbs: ["create","delete","get","list","patch","update","watch"]
    21.   - apiGroups: [""]
    22.     resources: ["pods/log"]
    23.     verbs: ["get","list","watch"]
    24.   - apiGroups: [""]
    25.     resources: ["secrets"]
    26.     verbs: ["get"]
    28. ---
    29. apiVersion: rbac.authorization.k8s.io/v1beta1
    30. kind: RoleBinding
    31. metadata:
    32.   name: jenkins2
    33.   namespace: kube-ops
    34. roleRef:
    35.   apiGroup: rbac.authorization.k8s.io
    36.   kind: Role
    37.   name: jenkins2
    38. subjects:
    39.   - kind: ServiceAccount
    40.     name: jenkins2
    41.     namespace: kube-ops

    创建 rbac 相关的资源对象：

    1. $ kubectl create -f rbac.yaml
    2. serviceaccount "jenkins2" created
    3. role.rbac.authorization.k8s.io "jenkins2" created
    4. rolebinding.rbac.authorization.k8s.io "jenkins2" created

    最后为了方便我们测试，我们这里通过 NodePort 的形式来暴露 Jenkins 的 web 服务，固定为30002端口，另外还需要暴露一个 agent 的端口，这个端口主要是用于 Jenkins 的 master 和 slave 之间通信使用的。

    一切准备的资源准备好过后，我们直接创建 Jenkins 服务：

    1. $ kubectl create -f jenkins2.yaml
    2. deployment.extensions "jenkins2" created
    3. service "jenkins2" created

    创建完成后，要去拉取镜像可能需要等待一会儿，然后我们查看下 Pod 的状态：

    1. $ kubectl get pods -n kube-ops
    2. NAME                        READY     STATUS    RESTARTS   AGE
    3. jenkins2-7f5494cd44-pqpzs   0/1       Running   0          2m

    可以看到该 Pod 处于 Running 状态，但是 READY 值确为0，然后我们用 describe 命令去查看下该 Pod 的详细信息：

    1. $ kubectl describe pod jenkins2-7f5494cd44-pqpzs -n kube-ops
    2. ...
    3. Normal   Created                3m                kubelet, node01    Created container
    4.   Normal   Started                3m                kubelet, node01    Started container
    5.   Warning  Unhealthy              1m (x10 over 2m)  kubelet, node01    Liveness probe failed: Get http://10.244.1.165:8080/login: dial tcp 10.244.1.165:8080: getsockopt: connection refused
    6.   Warning  Unhealthy              1m (x10 over 2m)  kubelet, node01    Readiness probe failed: Get http://10.244.1.165:8080/login: dial tcp 10.244.1.165:8080: getsockopt: connection refused

    可以看到上面的 Warning 信息，健康检查没有通过，具体原因是什么引起的呢？可以通过查看日志进一步了解：

    1. $ kubectl logs -f jenkins2-7f5494cd44-pqpzs -n kube-ops
    2. touch: cannot touch '/var/jenkins_home/copy_reference_file.log': Permission denied
    3. Can not write to /var/jenkins_home/copy_reference_file.log. Wrong volume permissions?

    很明显可以看到上面的错误信息，意思就是我们没有权限在 jenkins 的 home 目录下面创建文件，这是因为默认的镜像使用的是 jenkins 这个用户，而我们通过 PVC 挂载到 nfs 服务器的共享数据目录下面却是 root 用户的，所以没有权限访问该目录，要解决该问题，也很简单，我只需要在 nfs 共享数据目录下面把我们的目录权限重新分配下即可：

    1. $ chown -R 1000 /data/k8s/jenkins2

    当然还有另外一种方法是我们自定义一个镜像，在镜像中指定使用 root 用户也可以

    然后我们再重新创建：

    1. $ kubectl delete -f jenkins.yaml
    2. deployment.extensions "jenkins2" deleted
    3. service "jenkins2" deleted
    4. $ kubectl create -f jenkins.yaml
    5. deployment.extensions "jenkins2" created
    6. service "jenkins2" created

    现在我们再去查看新生成的 Pod 已经没有错误信息了：

    1. $ kubectl get pods -n kube-ops
    2. NAME                        READY     STATUS        RESTARTS   AGE
    3. jenkins2-7f5494cd44-smn2r   1/1       Running       0          25s

    等到服务启动成功后，我们就可以根据任意节点的 IP:30002 端口就可以访问 jenkins 服务了，可以根据提示信息进行安装配置即可：
    setup jenkins
    初始化的密码我们可以在 jenkins 的容器的日志中进行查看，也可以直接在 nfs 的共享数据目录中查看：

    1. $ cat /data/k8s/jenkins2/secrets/initAdminPassword

    然后选择安装推荐的插件即可。
    setup plugin

    安装完成后添加管理员帐号即可进入到 jenkins 主界面：
    jenkins home

    优点

    Jenkins 安装完成了，接下来我们不用急着就去使用，我们要了解下在 Kubernetes 环境下面使用 Jenkins 有什么好处。

    我们知道持续构建与发布是我们日常工作中必不可少的一个步骤，目前大多公司都采用 Jenkins 集群来搭建符合需求的 CI/CD 流程，然而传统的 Jenkins Slave 一主多从方式会存在一些痛点，比如：

    • 主 Master 发生单点故障时，整个流程都不可用了
    • 每个 Slave 的配置环境不一样，来完成不同语言的编译打包等操作，但是这些差异化的配置导致管理起来非常不方便，维护起来也是比较费劲
    • 资源分配不均衡，有的 Slave 要运行的 job 出现排队等待，而有的 Slave 处于空闲状态
    • 资源有浪费，每台 Slave 可能是物理机或者虚拟机，当 Slave 处于空闲状态时，也不会完全释放掉资源。

    正因为上面的这些种种痛点，我们渴望一种更高效更可靠的方式来完成这个 CI/CD 流程，而 Docker 虚拟化容器技术能很好的解决这个痛点，又特别是在 Kubernetes 集群环境下面能够更好来解决上面的问题，下图是基于 Kubernetes 搭建 Jenkins 集群的简单示意图：
    k8s-jenkins

    从图上可以看到 Jenkins Master 和 Jenkins Slave 以 Pod 形式运行在 Kubernetes 集群的 Node 上，Master 运行在其中一个节点，并且将其配置数据存储到一个 Volume 上去，Slave 运行在各个节点上，并且它不是一直处于运行状态，它会按照需求动态的创建并自动删除。

    这种方式的工作流程大致为：当 Jenkins Master 接受到 Build 请求时，会根据配置的 Label 动态创建一个运行在 Pod 中的 Jenkins Slave 并注册到 Master 上，当运行完 Job 后，这个 Slave 会被注销并且这个 Pod 也会自动删除，恢复到最初状态。

    那么我们使用这种方式带来了哪些好处呢？

    • 服务高可用，当 Jenkins Master 出现故障时，Kubernetes 会自动创建一个新的 Jenkins Master 容器，并且将 Volume 分配给新创建的容器，保证数据不丢失，从而达到集群服务高可用。
    • 动态伸缩，合理使用资源，每次运行 Job 时，会自动创建一个 Jenkins Slave，Job 完成后，Slave 自动注销并删除容器，资源自动释放，而且 Kubernetes 会根据每个资源的使用情况，动态分配 Slave 到空闲的节点上创建，降低出现因某节点资源利用率高，还排队等待在该节点的情况。
    • 扩展性好，当 Kubernetes 集群的资源严重不足而导致 Job 排队等待时，可以很容易的添加一个 Kubernetes Node 到集群中，从而实现扩展。

    是不是以前我们面临的种种问题在 Kubernetes 集群环境下面是不是都没有了啊？看上去非常完美。

    配置

    接下来我们就需要来配置 Jenkins，让他能够动态的生成 Slave 的 Pod。

    第1步. 我们需要安装kubernetes plugin， 点击 Manage Jenkins -> Manage Plugins -> Available -> Kubernetes plugin 勾选安装即可。
    kubernetes plugin

    第2步. 安装完毕后，点击 Manage Jenkins —> Configure System —> (拖到最下方)Add a new cloud —> 选择 Kubernetes，然后填写 Kubernetes 和 Jenkins 配置信息。
    kubernetes plugin config1

    注意 namespace，我们这里填 kube-ops，然后点击Test Connection，如果出现 Connection test successful 的提示信息证明 Jenkins 已经可以和 Kubernetes 系统正常通信了，然后下方的 Jenkins URL 地址：http://jenkins2.kube-ops.svc.cluster.local:8080，这里的格式为：服务名.namespace.svc.cluster.local:8080，根据上面创建的jenkins 的服务名填写，我这里是之前创建的名为jenkins，如果是用上面我们创建的就应该是jenkins2

    另外需要注意，如果这里 Test Connection 失败的话，很有可能是权限问题，这里就需要把我们创建的 jenkins 的 serviceAccount 对应的 secret 添加到这里的 Credentials 里面。

    第3步. 配置 Pod Template，其实就是配置 Jenkins Slave 运行的 Pod 模板，命名空间我们同样是用 kube-ops，Labels 这里也非常重要，对于后面执行 Job 的时候需要用到该值，然后我们这里使用的是 cnych/jenkins:jnlp 这个镜像，这个镜像是在官方的 jnlp 镜像基础上定制的，加入了 kubectl 等一些实用的工具。
    kubernetes plugin config2

    另外需要注意我们这里需要在下面挂载两个主机目录，一个是 /var/run/docker.sock，该文件是用于 Pod 中的容器能够共享宿主机的 Docker，这就是大家说的 docker in docker 的方式，Docker 二进制文件我们已经打包到上面的镜像中了，另外一个目录下 /root/.kube 目录，我们将这个目录挂载到容器的 /home/jenkins/.kube 目录下面这是为了让我们能够在 Pod 的容器中能够使用 kubectl 工具来访问我们的 Kubernetes 集群，方便我们后面在 Slave Pod 部署 Kubernetes 应用。
    kubernetes plugin config3

    另外还有几个参数需要注意，如下图中的Time in minutes to retain slave when idle，这个参数表示的意思是当处于空闲状态的时候保留 Slave Pod 多长时间，这个参数最好我们保存默认就行了，如果你设置过大的话，Job 任务执行完成后，对应的 Slave Pod 就不会立即被销毁删除。
    kubernetes plugin config4

    到这里我们的 Kubernetes Plugin 插件就算配置完成了。

    测试

    Kubernetes 插件的配置工作完成了，接下来我们就来添加一个 Job 任务，看是否能够在 Slave Pod 中执行，任务执行完成后看 Pod 是否会被销毁。

    在 Jenkins 首页点击create new jobs，创建一个测试的任务，输入任务名称，然后我们选择 Freestyle project 类型的任务：
    jenkins demo

    注意在下面的 Label Expression 这里要填入haimaxy-jnlp，就是前面我们配置的 Slave Pod 中的 Label，这两个地方必须保持一致
    config

    然后往下拉，在 Build 区域选择Execute shell
    Build

    然后输入我们测试命令

    1. echo "测试 Kubernetes 动态生成 jenkins slave"
    2. echo "==============docker in docker==========="
    3. docker info
    5. echo "=============kubectl============="
    6. kubectl get pods

    最后点击保存
    command

    现在我们直接在页面点击做成的 Build now 触发构建即可，然后观察 Kubernetes 集群中 Pod 的变化

    1. $ kubectl get pods -n kube-ops
    2. NAME                       READY     STATUS              RESTARTS   AGE
    3. jenkins2-7c85b6f4bd-rfqgv   1/1       Running             3          1d
    4. jnlp-hfmvd                 0/1       ContainerCreating   0          7s

    我们可以看到在我们点击立刻构建的时候可以看到一个新的 Pod：jnlp-hfmvd 被创建了，这就是我们的 Jenkins Slave。任务执行完成后我们可以看到任务信息，比如我们这里是 花费了 5.2s 时间在 jnlp-hfmvd 这个 Slave上面
    jnlp slave

    同样也可以查看到对应的控制台信息：
    jnlp output

    到这里证明我们的任务已经构建完成，然后这个时候我们再去集群查看我们的 Pod 列表，发现 kube-ops 这个 namespace 下面已经没有之前的 Slave 这个 Pod 了。

    1. $ kubectl get pods -n kube-ops
    2. NAME                       READY     STATUS    RESTARTS   AGE
    3. jenkins2-7c85b6f4bd-rfqgv   1/1       Running   3          1d

    到这里我们就完成了使用 Kubernetes 动态生成 Jenkins Slave 的方法。下节课我们来给大家介绍下怎么在 Jenkins 中来发布我们的 Kubernetes 应用。最后感谢圈友@TangT-newhope-成都提供的帮助。