八、【Pipeline流水线】配置Slave节点、配置docker流水线、配置K8S动态节点

· · · ·

### 配置Slave节点

Jenkins Slave节点概述

- Jenkins的从节点，用于执行主节点分配的构建任务。
- 从节点的作用是协助主节点执行构建任务，这样可以实现并行构建和分布式构建
- 主节点可以为每个从节点分配不同的标签（labels），然后将具有相应标签的构建任务分发到相应的从节点上执行

Slave节点接入配置

-  配置slave节点: slave节点创建家目录 mkdir -p /home/jenkins/

配置Slave节点端口

- 代理端口配置成与容器代理端口一致

运行Slave节点

- 根据如下命令运行Slave节点。首先需要安装java环境

内容：

**一、Jenkins slave 简介**

Jenkins slave 即从节点，用于执行主节点分配的构建任务，可分担主节点压力，实现并行构建与分布式构建，尤其适合构建任务大、主节点复杂度高的场景。

**二、从节点调用方式**

给每个从节点分配不同标签，通过 label 定义，在 Jenkins 流水线中调用 label 标签名来分配构建任务给相应从节点。

**三、从节点接入配置步骤**

1. 准备一台 CentOS 服务器作为slave节点，创建家目录：` cd /home/jenkins/agent`。 在agent之下分为：caches、remoting、workspace目录
       - caches：在构建时，需要拉取依赖，存放该目录下
       - remoting：用于 Jenkins 主节点与从节点建立连接生成的一些文件，会存储在这个目录里面
       - workspace：不同的构建项目就是存放在这个命名空间下的
    2. 在 Jenkins 页面系统管理配置从节点。
       - 我们需要确保 Jenkins 页面上配置的端口与 Jenkins 容器端口保持一致，也就是必须要跟 Jenkins 从节点的容器端口要保持一致。
       - 点击系统管理员 - 全局安全配置。找到代理端口处。如果修改了代理节点容器端口号的话，这边是必须要修改为一致的。接着我们去到节点和云管理来配置从节点
       - 定义了一个名字为 my-slave-1 的从节点。它的并行执行数量为 10，远程工作目录为`/home/jenkins/agent`调用的标签为slave。用法为: 尽可能的使用这个节点，启动方式为: Java Web 启动代理。内部数据目录：`remoting`，用法：尽量保持代理在线，点击保存即可

**四、其他关键配置**

1. 配置从节点端口，若修改默认 50000 端口（如改为 31000），需在 Jenkins 系统管理 - 全局安全配置的代理端口处同步修改。
    2. 可用性配置可选择尽量保持代理在线等策略。

**五、从节点运行与使用**

1. 配置好从节点后，下载提供的 JAR 文件到从节点服务器，通过 java 命令运行，需注意 Java 版本兼容性（如 Java 11 可用，Java 8 可能无法运行）。
    2. 在 Jenkins 流水线中，通过 label 指定从节点标签名来调用该节点进行构建任务，例如在 Pipeline 配置中，用 label 关键字指定从节点标签，编写构建任务代码，运行任务后可在对应从节点服务器查看执行结果及相关文件等。

在从节点拉取agent ,中运行起来

```shell
cd /data/slave
curl -sO http://xx/jnlpJars/agent.jar
java -jar agent.jar -jnlpUrl http://xx/computer/xx/jenkins-agent.jnlp -secret xx -workDir "/home/jenkins/agents"

# 信息：Connected 表示运行起来了
# 此时可以断开连接，上线节点
```

```groovy
pipeline {
    agent {
        node {
            label 'slave'
        }
    }

stages {
        stage('Hello') {
            steps {
                script {
                  sh 'hostname;pwd;free -h;touch a.txt'   
                }
            }
        }
    }
}
```

### 配置docker流水线

- 安装插件  Docker Pipeline

```groovy
  pipeline {
      agent none //静态代理
      stages {
          stage('Back-end') {
              agent {
                  docker {
                      label 'my-defined-label'
                      image 'maven:3.9.6-eclipse-temurin-17-alpine'
                      args '-v /path/to/mount1:/mount1, -v /path/to/mount2:/mount2'
                  }
              }
              steps {
                  sh 'mvn --version'
              }
          }
          stage('Front-end') {
              agent {
                  docker { image 'node:20.10.0-alpine3.19' }
              }
              steps {
                  sh 'node --version'
              }
          }
      }
  }
  ```

- 配置build创建镜像并push到仓库

```groovy
  node {
      checkout scm
      docker.withRegistry('https://registry.example.com', 'credentials-id') {
          def customImage = docker.build("my-image:${env.BUILD_ID}")
          /* Push the container to the custom Registry */
          customImage.push()
      }
  }
  ```

- 指定Dockerfile文件路径，`./dockerfiles/test/Dockerfiledef testImage = docker.build("test-image", "./dockerfiles/test")`

- 指定Dockerfile文件名与路径`def dockerfile = 'Dockerfile.test'     def customImage = docker.build("my-image:${env.BUILD_ID}","-f ${dockerfile} ./dockerfiles")`

```groovy
pipeline {
    agent {
        node {
            label 'slave'
        } 
    }
    stages { 
        stage('Build') {
            agent {
                docker {
					label 'slave'
                    image 'maven:3.9.3-eclipse-temurin-17'
                    args '-v $HOME/.m2:/root/.m2'
                }
            }        
            steps {
                sh 'mvn --version;touch a.txt;ls -l /root/.m2/build.txt'
            }
        }        
        stage('alpine ls') {
            agent {
                docker {
					label 'slave'
                    image 'alpine:3.14'
                    args '-v $HOME/.m2:/root/.m2'
                }
            }             
            steps {
                script {
                    sh """
						ls -la;pwd
                        ls -la /root/.m2/build.txt
                        echo "#########################"
                    """
                }
            }
        }  
		stage('slave-test') {
            steps {
                script {
                    sh """
                        ls -la;pwd
                        echo "#########################"
                    """
                }
            }
        } 
	}
}

```

```groovy
pipeline {
    agent {
        node {
            label 'slave'
        } 
    }
    environment {
		images_head = "registry.cn-hangzhou.aliyuncs.com"
    }

stages { 
        stage('Build') {
            agent {
                docker {
                    label 'slave'
                    image 'maven:3.9.3-eclipse-temurin-17'
                    args '-v $HOME/.m2:/root/.m2'
                }
            }        
            steps {
                sh 'mvn --version'
            }
        }        
        stage('Hello') {
            agent {
                docker { 
                    label 'slave'
                    image 'alpine:3.14' 
                }
            }
            steps {
                script {
                    sh """
                        ls -la
                        pwd
                        hostname
                        echo "#########################"
                    """
                }
            }
        }         
        stage('build-2') {          
            steps {
                script {
                    sh """
                    ls -la 
                    pwd
                    hostname
                    """
                    docker.withRegistry("https://${images_head}", 'aliyun-images-registry') {
                        def customImage = docker.build("${images_head}/tool-bucket/muke:${BUILD_TAG}-${GIT_COMMIT}")
                        customImage.push()                                              
                    }                        
                }                
            }
        }
                                        
    }
}
```

### 配置K8S动态节点

安装插件kubernetes

配置节点

配置名称和pod模板

如果注释inheritFrom则使用yaml的pod作为pod模板使用

八、【Pipeline流水线】配置Slave节点、配置docker流水线、配置K8S动态节点

安装VMWare以及配置NAT网络和docker安装

RAG-Embedding-Vector基础内容总结

十、【Pipeline流水线】掌握参数插件化配置、使用Kaniko技术构建镜像

JDK 源码解析 —— 调试环境搭建（二）进阶

JDK 源码解析 —— 集合（一）数组 ArrayList

Dubbo 源码分析 —— 调试环境搭建