5分钟在阿里云Kubernetes服务上搭建jenkins环境并完成应用构建到部署的流水线作业 ...-CSDN博客

本文主要演示如何在阿里云Kubernetes服务上快速搭建jenkins持续集成环境，并基于提供的示例应用快速完成应用源码编译、镜像构建和推送以及应用部署的流水线。

先决条件：
阿里云Kubernetes集群。

一快速开始

1. 部署jenkins

容器服务-Kubernetes -> 市场 -> 应用目录 -> jenkins:

点击参数菜单修改 AdminPassword 字段，选择Kubernetes集群、填写命名空间和发布名称并点击创建：
ps：如未设置登陆密码，则可在部署完毕后使用如下命名查看：

$ printf $(kubectl get secret --namespace ci jenkins-ci-jenkins -o jsonpath="{.data.jenkins-admin-password}" | base64 --decode);echo

访问jenkins服务并登陆：

2. 创建集群证书、镜像仓库证书并构建和部署示例应用

（1）创建k8s集群证书：
系统管理 -> 系统设置 -> Cloud -> Kubernetes.Credentials:

点击添加证书：

测试连通性：

（2）创建jenkins-docker-cfg secret用于镜像仓库权限设置
本示例中使用了阿里云镜像服务提供的北京区域镜像仓库：

$ docker login -u xxx -p xxx registry.cn-beijing.aliyuncs.com
Login Succeeded
$ kubectl create secret generic jenkins-docker-cfg -n ci --from-file=/root/.docker/config.json

（3）构建demo-pipeline并访问应用服务
根据自己镜像仓库信息修改构建参数，本示例中源码仓库分支为master，镜像为registry.cn-beijing.aliyuncs.com/haoshuwei:stable

完成。

二构建环境与示例项目说明

1. 构建环境配置说明

（1）kubernetes集群动态分配构建pod的配置;

（2）slave-pipeline 使用了4个container分别完成流水线中各个stage的构建，Kubernetes Pod Templates配置

container jnlp:

container kaniko:

container kubectl:

container maven:

(3) 使用到的构建镜像：

jenkins-slave-jnlp 用于构建节点jnlp连接master：

registry.cn-beijing.aliyuncs.com/acs-sample/jenkins-slave-jnlp:3.14-1

jenkins-slave-maven 用于mvn打包构建：

 registry.cn-beijing.aliyuncs.com/acs-sample/jenkins-slave-maven:3.3.9-jdk-8-alpine

jenkins-slave-kaniko 用于镜像构建和推送：

registry.cn-beijing.aliyuncs.com/acs-sample/jenkins-slave-kaniko:0.6.0

jenkins-slave-kubectl 用于kubectl部署应用：
```
registry.cn-beijing.aliyuncs.com/acs-sample/jenkins-slave-kubectl:1.11.5
```
(4) kaniko配置镜像仓库权限：

2. 示例项目说明

（1）示例项目中使用的源码仓库

https://github.com/AliyunContainerService/jenkins-demo.git

（2）kaniko 构建和推送docker镜像说明

kaniko可以不依赖docker daemon并在用户空间执行完成Dockerfile中的每一行命令，最终完成docker镜像的构建和推送。

kaniko -f `pwd`/Dockerfile -c `pwd` --destination=${origin_repo}/${repo}:${image_tag}

（3）部署应用到Kubernetes集群插件说明

插件配置如下：

对应的Pipeline语法为：

step([$class: 'KubernetesDeploy', authMethod: 'certs', apiServerUrl: 'https://kubernetes.default.svc.cluster.local:443', credentialsId:'k8sCertAuth', config: 'deployment.yaml',variableState: 'ORIGIN_REPO,REPO,IMAGE_TAG'])

声明的变量ORIGIN_REPO,REPO,IMAGE_TAG可在构建执行时把deployment.yaml文件中对应的变量值替换为实际值：

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: jenkins-java-demo
spec:
  replicas: 2
  selector:
    matchLabels:
      app: jenkins-java-demo
  template:
    metadata:
      labels:
        app: jenkins-java-demo
    spec:
      containers:
      - name: jenkins-java-demo
        image: ${ORIGIN_REPO}/${REPO}:${IMAGE_TAG}
        imagePullPolicy: Always
        ports:
        - containerPort: 8080

---
apiVersion: v1
kind: Service
metadata:
  name: jenkins-java-demo
spec:
  ports:
  - port: 80
    targetPort: 8080
    name: jenkins-java-demo
  selector:
    app: jenkins-java-demo
  type: LoadBalancer

（4）Jenkinsfile说明

pipeline{
      // 定义groovy脚本中使用的环境变量
      environment{
        // 本示例中使用DEPLOY_TO_K8S变量来决定把应用部署到哪套容器集群环境中，如“Production Environment”， “Staging001 Environment”等
        IMAGE_TAG =  sh(returnStdout: true,script: 'echo $image_tag').trim()
        ORIGIN_REPO =  sh(returnStdout: true,script: 'echo $origin_repo').trim()
        REPO =  sh(returnStdout: true,script: 'echo $repo').trim()
        BRANCH =  sh(returnStdout: true,script: 'echo $branch').trim()
      }

      // 定义本次构建使用哪个标签的构建环境，本示例中为 “slave-pipeline”
      agent{
        node{
          label 'slave-pipeline'
        }
      }

      // "stages"定义项目构建的多个模块，可以添加多个 “stage”， 可以多个 “stage” 串行或者并行执行
      stages{
        // 定义第一个stage， 完成克隆源码的任务
        stage('Git'){
          steps{
            git branch: '${BRANCH}', credentialsId: '', url: 'https://github.com/AliyunContainerService/jenkins-demo.git'
          }
        }

        // 添加第二个stage， 运行源码打包命令
        stage('Package'){
          steps{
              container("maven") {
                  sh "mvn package -B -DskipTests"
              }
          }
        }


        // 添加第四个stage, 运行容器镜像构建和推送命令， 用到了environment中定义的groovy环境变量
        stage('Image Build And Publish'){
          steps{
              container("kaniko") {
                  sh "kaniko -f `pwd`/Dockerfile -c `pwd` --destination=${ORIGIN_REPO}/${REPO}:${IMAGE_TAG}"
              }
          }
        }


        stage('Deploy to Kubernetes') {
            parallel {
                stage('Deploy to Production Environment') {
                    when {
                        expression {
                            "$BRANCH" == "master"
                        }
                    }
                    steps {
                        container('kubectl') {
                            step([$class: 'KubernetesDeploy', authMethod: 'certs', apiServerUrl: 'https://kubernetes.default.svc.cluster.local:443', credentialsId:'k8sCertAuth', config: 'deployment.yaml',variableState: 'ORIGIN_REPO,REPO,IMAGE_TAG'])
                        }
                    }
                }
                stage('Deploy to Staging001 Environment') {
                    when {
                        expression {
                            "$BRANCH" == "latest"
                        }
                    }
                    steps {
                        container('kubectl') {
                            step([$class: 'KubernetesDeploy', authMethod: 'certs', apiServerUrl: 'https://kubernetes.default.svc.cluster.local:443', credentialsId:'k8sCertAuth', config: 'deployment.yaml',variableState: 'ORIGIN_REPO,REPO,IMAGE_TAG'])
                        }
                    }
                }
            }
        }
      }
    }

了解更多阿里云容器服务内容，请访问 https://www.aliyun.com/product/containerservice
了解更多kaniko内容请参考：
https://github.com/GoogleContainerTools/kaniko