Jenkins定制Agent

上一节，我们实现了最简单的打包任务，在这一节，我们将定制所需的打包环境，为CD流水线做准备。

手动连接Agent

在上一节，我们使用了Kubernetes集群启动新的Slave节点，你可以沿着这条路，继续集成所需的环境，不再展开。

在本节，我们将切换另一种思路，使用手动启动&连接的方式。

首先，在Jenkins中添加一个Agent，路径是：Manage Jenkins -> Manage Nodes and Clouds -> New Node。

关键参数如下：

name：自选，这里e1

Number of executors：在这台机器上的并发执行任务数，这里选默认的2

Remote root directory：默认执行目录，这里选/home/jenkins/ateng

Labels：自选，这里executor，可以用它对Executor分组(如测试、线上等)

Launch method：Launch agent by connecting it to the master，即我们手动连接

保存后，点击进去后，能看到如下提示：

  1. Run from agent command line:
  3. java -jar agent.jar -jnlpUrl http://127.0.0.1:8080/computer/e1/jenkins-agent.jnlp -secret b057970bf978f53a8f945d470ac644e44c945e4b7259b216f703dedb95d0cac9 -workDir "/home/jenkins/agent"
  4. Run from agent command line, with the secret stored in a file:
  6. echo b057970bf978f53a8f945d470ac644e44c945e4b7259b216f703dedb95d0cac9 > secret-file
  7. java -jar agent.jar -jnlpUrl http://127.0.0.1:8080/computer/e1/jenkins-agent.jnlp -secret @secret-file -workDir "/home/jenkins/agent"

如上所示，我们需要用上述的Secret来连接Controller(主控)节点。

我们通过Docker启动Executor节点，如下：

  1. #!/bin/bash
  3. NAME="jenkins_e1"
  4. PUID="1000"
  5. PGID="1000"
  7. docker ps -q -a --filter "name=$NAME" | xargs -I {} docker rm -f {}
  8. docker run \
  9.     --name $NAME \
  10.     --env PUID=$PUID \
  11.     --env PGID=$PGID \
  12.     --detach \
  13.     --init jenkins/inbound-agent \
  14.     -workDir=/home/jenkins/agent \
  15.     -url http://10.1.172.136:8080 \
  16.     b057970bf978f53a8f945d470ac644e44c945e4b7259b216f703dedb95d0cac9 \
  17.     e1

温馨提示：上述的workDir需要与Jenkins中的配置保持一致。

当启动成功后，能看到节点上线了，如下图所示：

f

为了不调度到Controller节点，我们可以将其上的执行数量设置为0。

随后，我们尝试修改任务，如下所示：

  1. pipeline {
  2.     agent any 
  3.     stages {
  4.         stage('Test') { 
  5.             steps {
  6.                 sh 'echo hello world'
  7.             }
  8.         }
  9.     }
  10. }

如果一起顺利，其会成功地在e1完成执行！

定制Executor的环境

从上述例子中，不难理解：真正的打包任务，是在Executor中执行的。

如果我们的打包流程需要用到git、Java、Gradle、Kubernetes的话，我们也需要将这些集成到Executor中。

我们基于Jenkins的官方基础镜像进行定制，Dockerfile如下：

  1. FROM jenkins/inbound-agent:latest-jdk8
  3. ENV GRADLE_VERSION=7.2
  4. ENV K8S_VERSION=v1.22.3
  6. # tool
  7. USER root
  8. RUN apt-get update && \
  9.     apt-get install -y curl unzip docker-ce docker-ce-cli && \
  10.     apt-get clean
  12. # gradle
  13. RUN curl -skL -o /tmp/gradle-bin.zip https://services.gradle.org/distributions/gradle-$GRADLE_VERSION-bin.zip && \
  14.     mkdir -p /opt/gradle && \
  15.     unzip -q /tmp/gradle-bin.zip -d /opt/gradle && \
  16.     ln -sf /opt/gradle/gradle-$GRADLE_VERSION/bin/gradle /usr/local/bin/gradle
  18. RUN chown -R 1001:0 /opt/gradle && \
  19.     chmod -R g+rw /opt/gradle
  21. # kubectl
  22. RUN curl -LO https://storage.googleapis.com/kubernetes-release/release/$K8S_VERSION/bin/linux/amd64/kubectl
  23. RUN chmod +x ./kubectl
  24. RUN mv ./kubectl /usr/local/bin
  26. USER jenkins

如上所示：

  • 我们基于inbound-agent进行定制，这是官方的默认的Agent基础镜像
  • 随后，我们使用apt安装curl、unzip等基础工具
  • 接着，我们安装gradle、kubectl等二进制文件
  • 最后恢复默认的运行环境

制作镜像

  1. docker build -t "coder4/jenkins-my-agent" .

制作时间会比较长

再次打包

  1. pipeline {
  2.     agent {label 'executor'} 
  3.     stages {
  4.         stage('git') {
  5.             steps {
  6.                 sh "echo todo"
  7.             }
  8.         }
  10.         stage('gradle') {
  11.             steps {
  12.                 sh "gradle -v"
  13.             }    
  14.         }
  16.         stage('k8s') { 
  17.             steps {
  18.                 withKubeConfig([credentialsId: "60a8e9d2-0212-4ff4-aa98-f46fced97121",serverUrl: "https://kubernetes:6443"]) {
  19.                     sh "kubectl get nodes"
  20.                 }
  21.             }
  22.         }
  23.     }
  24. }

需要指出的是：上述’k8s’阶段，使用的凭据，是我们在 Jenkins搭建入门一节中生成的证书+凭据。

运行结果

  1. Started by user admin
  2. [Pipeline] Start of Pipeline
  3. [Pipeline] node
  4. Running on e1 in /home/jenkins/agent/workspace/test
  5. [Pipeline] {
  6. [Pipeline] stage
  7. [Pipeline] { (git)
  8. [Pipeline] sh
  9. + git version
  10. git version 2.30.2
  11. [Pipeline] }
  12. [Pipeline] // stage
  13. [Pipeline] stage
  14. [Pipeline] { (gradle)
  15. [Pipeline] sh
  16. + gradle -v
  18. Welcome to Gradle 7.2!
  20. Here are the highlights of this release:
  21.  - Toolchain support for Scala
  22.  - More cache hits when Java source files have platform-specific line endings
  23.  - More resilient remote HTTP build cache behavior
  25. For more details see https://docs.gradle.org/7.2/release-notes.html
  28. ------------------------------------------------------------
  29. Gradle 7.2
  30. ------------------------------------------------------------
  32. Build time:   2021-08-17 09:59:03 UTC
  33. Revision:     a773786b58bb28710e3dc96c4d1a7063628952ad
  35. Kotlin:       1.5.21
  36. Groovy:       3.0.8
  37. Ant:          Apache Ant(TM) version 1.10.9 compiled on September 27 2020
  38. JVM:          1.8.0_302 (Temurin 25.302-b08)
  39. OS:           Linux 5.10.47-linuxkit amd64
  41. [Pipeline] }
  42. [Pipeline] // stage
  43. [Pipeline] stage
  44. [Pipeline] { (k8s)
  45. [Pipeline] withKubeConfig
  46. [Pipeline] {
  47. [Pipeline] sh
  48. + kubectl get nodes
  49. NAME       STATUS   ROLES                  AGE     VERSION
  50. minikube   Ready    control-plane,master   6h58m   v1.21.2
  51. [Pipeline] }
  52. [kubernetes-cli] kubectl configuration cleaned up
  53. [Pipeline] // withKubeConfig
  54. [Pipeline] }
  55. [Pipeline] // stage
  56. [Pipeline] }
  57. [Pipeline] // node
  58. [Pipeline] End of Pipeline
  59. Finished: SUCCESS