本文主要介绍使用Jenkins配合argocd以及argo rollouts实现CI/CD。其中jenkins配合argocd做CI/CD前面已经介绍过了，这里不再赘述，不懂的地方可以移步《使用Jenkins和Argocd实现CI/CD》。
本篇文章新增了如下几个功能：

  • 优化argocd的触发CD的速度
  • 使用argo rollouts进行金丝雀发布
  • 给代码仓库打tag

    优化Argocd触发CD的速度

    Argo CD每三分钟轮询一次Git存储库，以检测清单的变化。为了消除轮询带来的延迟，可以将API服务器配置为接收Webhook事件。Argo CD支持来自GitHub，GitLab，Bitbucket，Bitbucket Server和Gogs的Git Webhook通知，更多点击官网：https://argoproj.github.io/argo-cd/。
    我这里使用Gitlab作为仓库地址。
    （1）在argocd中配置webhook token
    使用kubectl edit secret argocd-secret -n argocd命令进行配置： ``` apiVersion: v1 kind: Secret metadata: name: argocd-secret namespace: argocd type: Opaque data: …

stringData:

gitlab webhook secret

webhook.gitlab.secret: coolops

  1. 配置完点击保存会自动生成一个secret，如下：

kubectl describe secret argocd-secret -n argocd

Name: argocd-secret Namespace: argocd Labels: app.kubernetes.io/name=argocd-secret app.kubernetes.io/part-of=argocd Annotations:
Type: Opaque

Data

admin.passwordMtime: 20 bytes server.secretkey: 44 bytes tls.crt: 1237 bytes tls.key: 1679 bytes webhook.gitlab.secret: 7 bytes admin.password: 60 bytes

  1. （2）在gitlab的代码仓库配置webhook，如下：<br />![](https://cdn.nlark.com/yuque/0/2022/png/5374140/1668439475908-de689b51-a662-4226-9c8c-a78633447f86.png#averageHue=%23efeded&clientId=ufea626db-b783-4&crop=0&crop=0&crop=1&crop=1&from=paste&id=uf5e7f44f&margin=%5Bobject%20Object%5D&originHeight=508&originWidth=1080&originalType=url&ratio=1&rotation=0&showTitle=false&status=done&style=none&taskId=ucf90b60c-5f14-4809-ab04-7c7e88321bc&title=)<br />image.png<br />由于集群内部证书是无效证书，所有要把Enabled SSL去掉，如下：<br />![](https://cdn.nlark.com/yuque/0/2022/png/5374140/1668439475940-e4b1bd42-a50e-42b1-b7f6-a0cee6c3c91e.png#averageHue=%23f0efef&clientId=ufea626db-b783-4&crop=0&crop=0&crop=1&crop=1&from=paste&id=u136c41a6&margin=%5Bobject%20Object%5D&originHeight=508&originWidth=1080&originalType=url&ratio=1&rotation=0&showTitle=false&status=done&style=none&taskId=u63d59c55-588a-40a5-9937-19f5b2e6226&title=)<br />image.png<br />然后点击保存，点击测试，看是否链接成功。如果有如下提示则表示webhook配置没问题了。<br />![](https://cdn.nlark.com/yuque/0/2022/png/5374140/1668439475940-2a904a6b-3e8d-4b64-b8fe-4541cbb16219.png#averageHue=%23efefee&clientId=ufea626db-b783-4&crop=0&crop=0&crop=1&crop=1&from=paste&id=udd3a419c&margin=%5Bobject%20Object%5D&originHeight=508&originWidth=1080&originalType=url&ratio=1&rotation=0&showTitle=false&status=done&style=none&taskId=u730d4eb7-a937-4cb8-9f44-6f2d33672c3&title=)<br />image.png<br />现在可以进行修改gitlab仓库，观察是否一提交，argocd那边就可以响应了。
  2. <a name="DjhzI"></a>
  3. ## 使用argo rollouts进行金丝雀发布
  4. 关于argo rollouts的更多介绍可以查看之前的文章[《使用argo-rollouts实现金丝雀发布》](http://mp.weixin.qq.com/s?__biz=MzIyMDY2MTE3Mw==&mid=2247486432&idx=1&sn=d06ac32760ccc874be5c5acc331eadf9&chksm=97c9df3aa0be562ced1ee86c51fba91c6a10282ae409e5f133fc5067e3140861e522e9f08852&scene=21#wechat_redirect)。<br />按着官方文档进行安装，官方地址为：https://argoproj.github.io/argo-rollouts/installation/#kubectl-plugin-installation<br />（1）在Kubernetes集群中安装argo-rollouts

kubectl create namespace argo-rollouts kubectl apply -n argo-rollouts -f https://raw.githubusercontent.com/argoproj/argo-rollouts/stable/manifests/install.yaml

  1. （2）安装argo-rollouts的kubectl plugin

curl -LO https://github.com/argoproj/argo-rollouts/releases/latest/download/kubectl-argo-rollouts-linux-amd64 chmod +x ./kubectl-argo-rollouts-linux-amd64 mv ./kubectl-argo-rollouts-linux-amd64 /usr/local/bin/kubectl-argo-rollouts

  1. （3）我们这里主要是要重写deployment的配置文件，主要的配置清单如下。<br />rollout.yaml

apiVersion: argoproj.io/v1alpha1 kind: Rollout metadata: name: rollouts-simple-java spec: replicas: 3 strategy: canary: canaryService: rollouts-simple-java-canary stableService: rollouts-simple-java-stable trafficRouting: nginx: stableIngress: rollouts-simple-java-stable steps:

  1.   - setWeight: 20
  2.   - pause: {duration: 60}
  3.   - setWeight: 50
  4.   - pause: {duration: 10}
  5.   - setWeight: 80
  6.   - pause: {duration: 10}

revisionHistoryLimit: 2 selector: matchLabels: app: rollouts-simple-java template: metadata: labels: app: rollouts-simple-java spec: containers:

  1.     - args:
  2.         - -jar
  3.         - /opt/myapp.jar
  4.         - --server.port=8080
  5.       command:
  6.         - java
  7.       env:
  8.         - name: HOST_IP
  9.           valueFrom:
  10.             fieldRef:
  11.               apiVersion: v1
  12.               fieldPath: status.hostIP
  13.       image: registry.cn-hangzhou.aliyuncs.com/rookieops/myapp:latest
  14.       imagePullPolicy: IfNotPresent
  15.       lifecycle:
  16.         preStop:
  17.           exec:
  18.             command:
  19.               - /bin/sh
  20.               - -c
  21.               - /bin/sleep 30
  22.       livenessProbe:
  23.         failureThreshold: 3
  24.         httpGet:
  25.           path: /hello
  26.           port: 8080
  27.           scheme: HTTP
  28.         initialDelaySeconds: 60
  29.         periodSeconds: 15
  30.         successThreshold: 1
  31.         timeoutSeconds: 1
  32.       name: myapp
  33.       ports:
  34.         - containerPort: 8080
  35.           name: http
  36.           protocol: TCP
  37.       readinessProbe:
  38.         failureThreshold: 3
  39.         httpGet:
  40.           path: /hello
  41.           port: 8080
  42.           scheme: HTTP
  43.         periodSeconds: 15
  44.         successThreshold: 1
  45.         timeoutSeconds: 1
  46.       resources:
  47.         limits:
  48.           cpu: "1"
  49.           memory: 2Gi
  50.         requests:
  51.           cpu: 100m
  52.           memory: 1Gi
  53.       terminationMessagePath: /dev/termination-log
  54.       terminationMessagePolicy: File
  55.   dnsPolicy: ClusterFirstWithHostNet
  56.   imagePullSecrets:
  57.     - name: gitlab-registry
  1. services.yaml

apiVersion: v1 kind: Service metadata: name: rollouts-simple-java-canary spec: ports:

  • port: 8080 targetPort: http protocol: TCP name: http selector: app: rollouts-simple-java

    This selector will be updated with the pod-template-hash of the canary ReplicaSet. e.g.:

    rollouts-pod-template-hash: 7bf84f9696

apiVersion: v1 kind: Service metadata: name: rollouts-simple-java-stable spec: ports:

  • port: 8080 targetPort: http protocol: TCP name: http selector: app: rollouts-simple-java

    This selector will be updated with the pod-template-hash of the stable ReplicaSet. e.g.:

    rollouts-pod-template-hash: 789746c88d

    1. ingress.yaml
    apiVersion: networking.k8s.io/v1beta1 kind: Ingress metadata: name: rollouts-simple-java-stable annotations: kubernetes.io/ingress.class: nginx spec: rules:
  • host: rollouts-simple-java.coolops.cn http: paths:
    • path: / backend:

      Reference to a Service name, also specified in the Rollout spec.strategy.canary.stableService field

      serviceName: rollouts-simple-java-stable servicePort: 8080
      1. kustomization.yaml

      Example configuration for the webserver

      at https://github.com/monopole/hello

      commonLabels: app: rollouts-simple-java

resources:

  • rollout.yaml
  • services.yaml
  • ingress.yaml apiVersion: kustomize.config.k8s.io/v1beta1 kind: Kustomization images:
  • name: registry.cn-hangzhou.aliyuncs.com/rookieops/myapp newTag: “latest” namespace: dev
    1. 让后将这些文件保存到gitlab yaml仓库里，比如：<br />image.png<br />这里的金丝雀发布是才有的时间暂停的方式，还可以采用手动继续的方式。我这里方便测试就才有了时间暂停。
    2. <a name="bkog4"></a>
    3. ## 给代码仓库打Tag
    4. 为啥要给代码仓库打Tag呢？<br />当一个代码仓库进过长时间的迭代，针对不同的时期和需求，必定会有不同的版本。而借助 Git 提供的标签功能，可以快捷方便地记录代码版本。无论什么时候，想取回某个版本，不再需要查找冗长的commit_id，只需要取出打标签的历史版本即可。<br />可以这么理解：**标签是版本库的一个快照**。在主流的 Git 平台上，版本可以直接下载的，节省了开发者的不少精力。<br />这里通过gitlab的api对代码仓库打tag。API的具体操作见https://docs.gitlab.com/ee/api/tags.html<br />这里在shareLibrary的代码仓库中创建了gitlab.groovy文件。<br />image.png<br />具体内容如下：
    package org.devops

//封装HTTP请求 def HttpReq(reqType,reqUrl,reqBody){ def gitServer = “http://172.17.100.135:32080/api/v4“ withCredentials([string(credentialsId: ‘gitlab-token’, variable: ‘gitlabToken’)]) { result = httpRequest customHeaders: [[maskValue: true, name: ‘PRIVATE-TOKEN’, value: “${gitlabToken}”]], httpMode: reqType, contentType: “APPLICATION_JSON”, consoleLogResponseBody: true, ignoreSslErrors: true, requestBody: reqBody, url: “${gitServer}/${reqUrl}” //quiet: true } return result }

//获取项目ID def GetProjectID(projectName){ projectApi = “projects?search=${projectName}” response = HttpReq(‘GET’,projectApi,’’) def result = readJSON text: “””${response.content}”””

  1. for (repo in result){
  2.    // println(repo['path_with_namespace'])
  3.     if (repo['path'] == "${projectName}"){
  5.         repoId = repo['id']
  6.         println(repoId)
  7.     }
  8. }
  9. return repoId

}

// 给仓库打tag def TagGitlab(projectId,tag_name,tag_ref){ def apiUrl = “projects/${projectId}/repository/tags” reqBody = “””{“tag_name”: “${tag_name}”,”ref”: “${tag_ref}”}””” HttpReq(‘POST’,apiUrl,reqBody) }

  1. 首先通过GetProjectID获取到项目仓库的ID，然后再调用TagGitlab进行打Tag。<br />然后我们需要在Jenkins上创建一个名叫gitlab-token的token凭据。<br />（1）在gitlab上生成token<br />![](https://cdn.nlark.com/yuque/0/2022/png/5374140/1668439475895-9f1f1a42-fcd6-46a4-ac79-47676e53fccf.png#averageHue=%23f0efef&clientId=ufea626db-b783-4&crop=0&crop=0&crop=1&crop=1&from=paste&id=u02a79380&margin=%5Bobject%20Object%5D&originHeight=508&originWidth=1080&originalType=url&ratio=1&rotation=0&showTitle=false&status=done&style=none&taskId=ud7727120-da9c-4d80-a051-d8e85e2496d&title=)<br />image.png<br />（2）在Jenkins上创建凭据<br />系统管理->凭据管理->全局凭据->添加凭据<br />image.png<br />注意这个ID，要和gitlab.groovy中的ID一一对应。
  2. <a name="SVvr2"></a>
  3. ## 在argocd中配置项目
  4. 可以直接在UI上配置项目，我这里采用的是YAML清单的方式，如下：<br />rollout-simple-java.yaml
  5. ```yaml
  6. apiVersion: argoproj.io/v1alpha1
  7. kind: Application
  8. metadata:
  9.   name: 'rollout-simple-java'
  10.   namespace: argocd
  11. spec:
  12.   destination:
  13.     namespace: 'dev'
  14.     server: 'https://kubernetes.default.svc'
  15.   source:
  16.     path: 'rollout-simple-java/'
  17.     repoURL: 'http://172.17.100.135:32080/root/devops-cd.git'
  18.     targetRevision: HEAD
  19.   project: 'default'
  20.   syncPolicy:
  21.     automated: {}

创建之后可以在UI界面看到新建的应用了。
基于Jenkins+Argocd+Argo Rollouts的DevOps实现并用金丝雀发布 - 图1
image.png

在Jenkins上配置项目

（1）在shareLibrary上创建如下Jenkinsfile

  1. def labels = "slave-${UUID.randomUUID().toString()}"
  3. // 引用共享库
  4. @Library("jenkins_shareLibrary")
  6. // 应用共享库中的方法
  7. def tools = new org.devops.tools()
  8. def sonarapi = new org.devops.sonarAPI()
  9. def sendEmail = new org.devops.sendEmail()
  10. def build = new org.devops.build()
  11. def sonar = new org.devops.sonarqube()
  13. // 前端传来的变量
  14. def gitBranch = env.branch
  15. def gitUrl = env.git_url
  16. def buildShell = env.build_shell
  17. def image = env.image
  18. def dockerRegistryUrl = env.dockerRegistryUrl
  19. def devops_cd_git = env.devops_cd_git
  20. def repo_name = env.repo_name
  21. def gitlab = new org.devops.gitlab()
  22. def deploy = new org.devops.deploy()
  24. // 固定变量
  25. // def SonarServer = "http://sonar.devops.svc.cluster.local:9000/api"
  26. // def dockerRegistryUrl = "registry.cn-hangzhou.aliyuncs.com"
  27. def isUpdate = ''
  31. pipeline {
  32.     agent {
  33.         kubernetes {
  34.         label labels
  35.         yaml """
  36. apiVersion: v1
  37. kind: Pod
  38. metadata:
  39. labels:
  40. some-label: some-label-value
  41. spec:
  42. volumes:
  43. - name: docker-sock
  44. hostPath:
  45. path: /var/run/docker.sock
  46. type: ''
  47. - name: maven-cache
  48. persistentVolumeClaim:
  49. claimName: maven-cache-pvc
  50. containers:
  51. - name: jnlp
  52. image: registry.cn-hangzhou.aliyuncs.com/rookieops/inbound-agent:4.3-4
  53. - name: maven
  54. image: registry.cn-hangzhou.aliyuncs.com/rookieops/maven:3.5.0-alpine
  55. command:
  56. - cat
  57. tty: true
  58. volumeMounts:
  59. - name: maven-cache
  60. mountPath: /root/.m2
  61. - name: docker
  62. image: registry.cn-hangzhou.aliyuncs.com/rookieops/docker:19.03.11
  63. command:
  64. - cat
  65. tty: true
  66. volumeMounts:
  67. - name: docker-sock
  68. mountPath: /var/run/docker.sock
  69. - name: sonar-scanner
  70. image: registry.cn-hangzhou.aliyuncs.com/rookieops/sonar-scanner:latest
  71. command:
  72. - cat
  73. tty: true
  74. - name: kustomize
  75. image: registry.cn-hangzhou.aliyuncs.com/rookieops/kustomize:v3.8.1
  76. command:
  77. - cat
  78. tty: true
  79. """
  80.     }
  81.     }
  83.     environment{
  84.         auth = 'joker'
  85.     }
  87.     options {
  88.         timestamps()    // 日志会有时间
  89.         skipDefaultCheckout()   // 删除隐式checkout scm语句
  90.         disableConcurrentBuilds()   //禁止并行
  91.         timeout(time:1,unit:'HOURS') //设置流水线超时时间
  92.     }
  95.     stages {
  96.         // 拉取代码
  97.         stage('GetCode') {
  98.             steps {
  99.                 checkout([$class: 'GitSCM', branches: [[name: "${gitBranch}"]],
  100.                           doGenerateSubmoduleConfigurations: false,
  101.                           extensions: [],
  102.                           submoduleCfg: [],
  103.                           userRemoteConfigs: [[credentialsId: '83d2e934-75c9-48fe-9703-b48e2feff4d8', url: "${gitUrl}"]]])
  104.             }
  105.         }
  107.         // 单元测试和编译打包
  108.         stage('Build&Test') {
  109.             steps {
  110.                 container('maven') {
  111.                     script{
  112.                         tools.PrintMes("编译打包","blue")
  113.                         build.DockerBuild("${buildShell}")
  114.                     }
  115.                 }
  116.             }
  117.         }
  118.         // 代码扫描
  119.         stage('CodeScanner') {
  120.             steps {
  121.                 container('sonar-scanner') {
  122.                     script {
  123.                         tools.PrintMes("代码扫描","green")
  124.                         tools.PrintMes("搜索项目","green")
  125.                         result = sonarapi.SearchProject("${JOB_NAME}")
  126.                         println(result)
  128.                         if (result == "false"){
  129.                             println("${JOB_NAME}---项目不存在,准备创建项目---> ${JOB_NAME}！")
  130.                             sonarapi.CreateProject("${JOB_NAME}")
  131.                         } else {
  132.                             println("${JOB_NAME}---项目已存在！")
  133.                         }
  135.                         tools.PrintMes("代码扫描","green")
  136.                         sonar.SonarScan("${JOB_NAME}","${JOB_NAME}","src")
  138.                         sleep 10
  139.                         tools.PrintMes("获取扫描结果","green")
  140.                         result = sonarapi.GetProjectStatus("${JOB_NAME}")
  142.                         println(result)
  143.                         if (result.toString() == "ERROR"){
  144.                             toemail.Email("代码质量阈错误！请及时修复！",userEmail)
  145.                             error " 代码质量阈错误！请及时修复！"
  147.                         } else {
  148.                             println(result)
  149.                         }
  150.                     }
  151.                 }
  152.             }
  153.         }
  154.         // 构建镜像
  155.         stage('BuildImage') {
  156.             steps {
  157.                 withCredentials([[$class: 'UsernamePasswordMultiBinding',
  158.                                   credentialsId: 'dockerhub',
  159.                                   usernameVariable: 'DOCKER_HUB_USER',
  160.                                   passwordVariable: 'DOCKER_HUB_PASSWORD']]) {
  161.                     container('docker') {
  162.                         script{
  163.                             tools.PrintMes("构建镜像","green")
  164.                             imageTag = tools.createVersion()
  165.                             sh """
  166. docker login ${dockerRegistryUrl} -u ${DOCKER_HUB_USER} -p ${DOCKER_HUB_PASSWORD}
  167. docker build -t ${image}:${imageTag} .
  168. docker push ${image}:${imageTag}
  169. docker rmi ${image}:${imageTag}
  170. """
  171.                         }
  172.                     }
  173.                 }
  174.             }
  175.         }
  176.         // 部署
  177.         stage('Deploy') {
  178.             steps {
  179.                 withCredentials([[$class: 'UsernamePasswordMultiBinding',
  180.                                    credentialsId: 'ci-devops',
  181.                                    usernameVariable: 'DEVOPS_USER',
  182.                                    passwordVariable: 'DEVOPS_PASSWORD']]){
  183.                      container('kustomize') {
  184.                         script{
  185.                             APP_DIR="${JOB_NAME}".split("_")[0]
  186.                             sh """
  187. git remote set-url origin http://${DEVOPS_USER}:${DEVOPS_PASSWORD}@${devops_cd_git}
  188. git config --global user.name "Administrator"
  189. git config --global user.email "coolops@163.com"
  190. git clone http://${DEVOPS_USER}:${DEVOPS_PASSWORD}@${devops_cd_git} /opt/devops-cd
  191. cd /opt/devops-cd
  192. git pull
  193. cd /opt/devops-cd/${APP_DIR}
  194. kustomize edit set image ${image}:${imageTag}
  195. git commit -am 'image update'
  196. git push origin master
  197. """
  198.                         }
  199.                     }
  200.                  }
  201.             }
  202.         }
  203.         // 接口测试
  204.         stage('InterfaceTest') {
  205.             steps{
  206.                 sh 'echo "接口测试"'
  207.             }
  208.         }
  209.         // 继续更新或回滚
  210.         stage('UpdateOrRollBack') {
  211.             input {
  212.                 message 'Should we continue?'
  213.                 ok 'Yes, we should.'
  214.                 submitter 'alice,bob'
  215.                 parameters {
  216.                     string(name: 'input', defaultValue: 'yes', description: 'continue update?')
  217.                 }
  218.             }
  219.             steps {
  220.                 script {
  221.                     // 调用更新或者回滚函数
  222.                     tools.PrintMes("更新或者回滚","green")
  223.                     // 将input的值赋值给全局变量isUpdate，供下阶段使用
  224.                     isUpdate = "${input}"
  225.                 }
  226.             }
  227.         }
  229.         // 如果是继续更新服务，待验证通过后给gitlab代码仓库打tag
  230.         stage('TagGitlab') {
  231.             steps {
  232.                 script {
  233.                     if ("${isUpdate}" == 'yes' && "${gitBranch}" == 'master') {
  234.                         tools.PrintMes('给仓库打TAG', 'green')
  235.                         // 获取项目的projectId
  236.                         repo_id = gitlab.GetProjectID("${repo_name}")
  237.                         sh "echo ${repo_id}"
  238.                         // 生产tag,以当前时间为tag
  239.                         tag_name = "release"+"-"+tools.getTime()
  240.                         gitlab.TagGitlab("${repo_id}", "${tag_name}", 'master')
  241.                     }else {
  242.                         tools.PrintMes('不打TAG', 'red')
  243.                     }
  244.                 }
  245.             }
  246.         }
  247.     }
  248.     // 构建后的操作
  249.     post {
  250.         success {
  251.             script{
  252.                 println("success:只有构建成功才会执行")
  253.                 currentBuild.description += "\n构建成功！"
  254.                 // deploy.AnsibleDeploy("${deployHosts}","-m ping")
  255.                 sendEmail.SendEmail("构建成功",toEmailUser)
  256.                 // dingmes.SendDingTalk("构建成功 ✅")
  257.             }
  258.         }
  259.         failure {
  260.             script{
  261.                 println("failure:只有构建失败才会执行")
  262.                 currentBuild.description += "\n构建失败!"
  263.                 sendEmail.SendEmail("构建失败",toEmailUser)
  264.                 // dingmes.SendDingTalk("构建失败 ❌")
  265.             }
  266.         }
  267.         aborted {
  268.             script{
  269.                 println("aborted:只有取消构建才会执行")
  270.                 currentBuild.description += "\n构建取消!"
  271.                 sendEmail.SendEmail("取消构建",toEmailUser)
  272.                 // dingmes.SendDingTalk("构建失败 ❌","暂停或中断")
  273.             }
  274.         }
  275.     }
  276. }

Jenkinsfile和之前的大同小异，只是增加了两个stage。
其中UpdateOrRollBack这个stage只是占了一个坑，并没有具体实现，其思路是：

  • 在部署新版本的时候第一次暂停，然后通过Jenkins这里的输入决定是否继续
    • 如果继续则表示该版本上线没什么问题，继续后面的TagGitlab
    • 如果不继续则表示该版本上线有问题，取消本次上线，并将应用回滚至上一版本

（2）、在Jenkins上配置项目
注意项目名字的前缀和YAML清单所在的文件夹名一致
基于Jenkins+Argocd+Argo Rollouts的DevOps实现并用金丝雀发布 - 图2
image.png
然后添加几个参数。
基于Jenkins+Argocd+Argo Rollouts的DevOps实现并用金丝雀发布 - 图3
image.png
基于Jenkins+Argocd+Argo Rollouts的DevOps实现并用金丝雀发布 - 图4
image.png
基于Jenkins+Argocd+Argo Rollouts的DevOps实现并用金丝雀发布 - 图5
image.png
基于Jenkins+Argocd+Argo Rollouts的DevOps实现并用金丝雀发布 - 图6
image.png
基于Jenkins+Argocd+Argo Rollouts的DevOps实现并用金丝雀发布 - 图7
image.png
基于Jenkins+Argocd+Argo Rollouts的DevOps实现并用金丝雀发布 - 图8
image.png
基于Jenkins+Argocd+Argo Rollouts的DevOps实现并用金丝雀发布 - 图9
image.png
基于Jenkins+Argocd+Argo Rollouts的DevOps实现并用金丝雀发布 - 图10
image.png
配置流水线
基于Jenkins+Argocd+Argo Rollouts的DevOps实现并用金丝雀发布 - 图11基于Jenkins+Argocd+Argo Rollouts的DevOps实现并用金丝雀发布 - 图12

发布应用

（1）打开一个终端，输入以下命令，让其一直curl页面

  1. while true;do curl http://rollouts-simple-java.coolops.cn:30122/hello;sleep 2;echo "\n";done

输出如下：
基于Jenkins+Argocd+Argo Rollouts的DevOps实现并用金丝雀发布 - 图13
image.png
（2）修改源代码，进行发布，我将源码中的Hello world改成hello joker，如下
基于Jenkins+Argocd+Argo Rollouts的DevOps实现并用金丝雀发布 - 图14
image.png
然后提交到代码库。
（3）、在Jenkins上进行build
然后可以在终端上看到少量的流量访问到了hello joker，如下
基于Jenkins+Argocd+Argo Rollouts的DevOps实现并用金丝雀发布 - 图15
image.png
（4）、点击继续部署
上面能正常访问到hello joker，表示测试通过，在Jenkins流水线上点击继续部署，对当前代码仓库进行打tag
基于Jenkins+Argocd+Argo Rollouts的DevOps实现并用金丝雀发布 - 图16
image.png
待其执行完后，在gitlab的代码仓库中可以看到新的tag，如下
基于Jenkins+Argocd+Argo Rollouts的DevOps实现并用金丝雀发布 - 图17
image.png
点击进去可以看到更改的内容。
基于Jenkins+Argocd+Argo Rollouts的DevOps实现并用金丝雀发布 - 图18
image.png
后面金丝雀发布完成后，可以看到终端输出如下：
基于Jenkins+Argocd+Argo Rollouts的DevOps实现并用金丝雀发布 - 图19
image.png
到此整个过程完成。

写在最后

argo全家桶还是非常不错，目前我使用了argocd和argo rollouts，初步使用来看运行都比较稳定，不过argocd有几个需要注意的点：

  • 建议对创建在argocd上的每个应用的yaml文件进行备份，因为argocd本身是无状态的，保不齐你啥时候就将其清空了。
  • argocd-cm这个configmap每次修改过后就会清空部署在上面的应用，不过对我应用本身不受影响，这也是为什么要备份的原因，方便重建
  • argo rollouts对ingress的支持有限，目前只支持ingress和alb