Jenkins Pipeline 语法

Jenkins 的 Pipeline 语法 主要有两种：

1. Declarative Pipeline（声明式语法） 

2. Scripted Pipeline（脚本式语法）

######装 Pipeline（workflow-aggregator）插件######

官网：管道语法https://www.jenkins.io/doc/book/pipeline/syntax/

一、声明式语法示例

声明式语法包括以下核心流程：

1.pipeline : 声明其内容为一个声明式的 pipeline 脚本

2.agent: 执行节点（job 运行的 slave 或者 master 节点）

3.stages: 阶段集合，包裹所有的阶段（例如：打包，部署等各个阶段）

4.stage: 阶段，被 stages 包裹，一个 stages 可以有多个 stage

5.steps: 步骤,为每个阶段的最小执行单元,被 stage 包裹

6.post: 执行构建后的操作，根据构建结果来执行对应的操作

1、Pipeline 基本结构

pipeline {
    agent any   // 在任意节点上运行
    stages {
        stage('Build') {
            steps {
                echo "开始构建..."
            }
        }
        stage('Test') {
            steps {
                echo "运行测试..."
            }
        }
        stage('Deploy') {
            steps {
                echo "部署应用..."
            }
        }
    }
}

作用域：应用于全局最外层，表明该脚本为声明式 pipeline
是否必须：必须

2. agent 配置

pipeline {
    agent any               // 任意可用节点
    // agent none           // 不指定，需要在每个 stage 定义
    // agent { label 'node1' }   // 在指定节点执行
    // agent { docker 'maven:3.8.6' } // 直接用 Docker 镜像
}

作用域：可用在全局与 stage 内
agent 表明此 pipeline 在哪个节点上执行
是否必须：是
参数：any,none, label, node,docker,dockerfile

3. stages 和 steps

stages {
    stage('Build') {
        steps {
            sh 'mvn clean package -DskipTests'
        }
    }
    stage('Test') {
        steps {
            sh 'mvn test'
        }
    }
}

1. stages { ... }

   • 表示流水线的阶段集合。

   • 一个 Pipeline 可以有多个 stage，每个 stage 代表流水线中的一个环节（比如构建、测试、部署）。

---

1. stage('Build') { ... }

   • 定义一个名字叫 Build 的阶段。

   • 阶段名会显示在 Jenkins 控制台和 Web UI 的蓝色进度条里，方便追踪进度。

---

1. steps { ... }

   • stage 里面的实际操作步骤。

   • 在 Declarative Pipeline 里，所有执行命令必须放在 steps 块中。

---

1. sh 'mvn clean package -DskipTests'

   • 使用 Shell 执行命令（sh 是 Jenkins 内置步骤，用来执行 Linux/Unix shell 命令）。

   • 命令含义：

     • mvn clean package
        使用 Maven 清理并重新打包项目，生成 .jar 或 .war 包。

     • -DskipTests
       打包时跳过单元测试，节省时间。

---

1. stage('Test') { ... }

   • 定义一个名字叫 Test 的阶段。

   • 通常在构建之后运行，主要用来执行测试。

---

1. sh 'mvn test'

   • 执行 mvn test，运行 单元测试。

   • 如果测试失败，Pipeline 默认会在这里中断并标记为失败（除非你加了特殊的错误处理）。

4.后置操作（post）

pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                echo "构建中..."
            }
        }
    }
    post {
        always {
            echo '总会执行'
        }
        success {
            echo '成功时执行'
        }
        failure {
            echo '失败时执行'
        }
    }
}

二、脚本式语法示例

Scripted Pipeline 是 Jenkins 最早支持的 Pipeline 方式，完全基于 Groovy 脚本。

1、基本结构

node {
    stage('Build') {
        sh 'mvn clean package -DskipTests'
    }
    stage('Test') {
        sh 'mvn test'
    }
    stage('Deploy') {
        sh './deploy.sh'
    }
}

• node { ... }：定义流水线在 Jenkins 的一个节点（agent）上执行。

• stage('xxx') { ... }：定义一个阶段。

• sh '命令'：在 Shell 中执行命令。

2、常见语法

2.1环境变量

node {
    stage('Env') {
        echo "构建用户: ${env.BUILD_USER}"
        echo "工作目录: ${env.WORKSPACE}"
    }
}

2.2 参数化构建

node {
    stage('Deploy') {
        if (params.ENV == 'prod') {
            echo "部署到生产环境"
        } else {
            echo "部署到测试环境"
        }
    }
}

2.3并行执行

node {
    stage('Tests') {
        parallel (
            "Unit Test": {
                sh 'mvn test'
            },
            "Integration Test": {
                sh 'mvn verify -Pintegration'
            }
        )
    }
}

2.4条件判断 + 循环

node {
    stage('Check') {
        def servers = ["web1", "web2", "web3"]
        for (srv in servers) {
            echo "检查服务器: ${srv}"
        }
        if (env.BRANCH_NAME == "main") {
            echo "这是主分支，允许部署"
        } else {
            echo "这是测试分支，不允许部署"
        }
    }
}

2.5 错误处理

node {
    stage('Build') {
        try {
            sh 'mvn clean package'
        } catch (err) {
            echo "构建失败: ${err}"
            currentBuild.result = 'FAILURE'
        }
    }
}

三、Scripted Pipeline CI/CD 示例

• 代码构建（Maven）

• Docker 镜像打包

• 推送到 Harbor

• 部署到 Kubernetes

node {
    // 定义变量
    def appName = "myapp"
    def harborUrl = "harbor.example.com"   ##仓库地址
    def harborProject = "dev"
    def imageTag = "${env.BUILD_NUMBER}"   // 使用 Jenkins 构建号作为镜像tag
    def kubeConfig = "/root/.kube/config"

    stage('Checkout') {
        echo "拉取代码..."
        checkout scm
    }

    stage('Build') {
        echo "构建Java项目..."
        sh 'mvn clean package -DskipTests'
    }

    stage('Docker Build & Push') {
        echo "构建并推送Docker镜像..."
        sh """
            docker build -t ${harborUrl}/${harborProject}/${appName}:${imageTag} .
            docker login ${harborUrl} -u admin -p Harbor12345
            docker push ${harborUrl}/${harborProject}/${appName}:${imageTag}
        """
    }

    stage('Deploy to K8s') {
        echo "部署到Kubernetes..."
        sh """
            export KUBECONFIG=${kubeConfig}
            kubectl set image deployment/${appName} ${appName}=${harborUrl}/${harborProject}/${appName}:${imageTag} -n dev
            kubectl rollout status deployment/${appName} -n dev
        """
    }
}

• checkout scm → 拉取 Git 仓库代码。

• mvn clean package -DskipTests → 使用 Maven 构建项目并打包，跳过测试。

• docker build → 构建 Docker 镜像。

• docker login & docker push → 登录 Harbor 并推送镜像。

• kubectl set image → 更新 Kubernetes Deployment 的镜像版本。

• kubectl rollout status → 等待部署完成。

####有待补充。。。。。。。