pipeline utility steps

pipeline utility steps 介绍

Pipeline Utility Steps 插件是 Jenkins 中的一款强大工具，旨在为 Jenkins Pipelines 提供一系列实用的步骤（steps），以增强和简化 Pipeline 的脚本编写过程。该插件通过引入多种预定义的步骤，使得在执行复杂任务时更加灵活和高效。

pipeline utility steps 主要功能

Pipeline Utility Steps 插件提供的功能包括但不限于：

1. 文件和文本操作: 提供读取、写入、查找文件等步骤，如 readFile, writeFile, findFiles, readProperties, readJSON 等

2. 条件判断和循环: 包括条件执行（conditionalStep）、循环执行（parallel, stage 结合 when 表达式）等步骤，用于实现更复杂的逻辑控制流

3. 网络和系统操作: 如 curl 和 wget 步骤用于网络请求，isUnix 用于判断操作系统类型等

4. 暂停和时间限制: pause 步骤可暂停 Pipeline 执行，等待特定事件或人工干预；timeout 步骤则为步骤或整个 Pipeline 设置时间限制

5. 环境变量和参数管理: 提供如 environmentVariables 和 parameters 步骤，用于定义和管理 Pipeline 的环境变量和参数

6. 通知和日志记录: 如 slackSend 用于发送 Slack 通知，echo 用于输出信息至控制台

7. Maven 和 Gradle 项目支持: 包括读取 Maven POM 文件和 Gradle 构建脚本的能力

pipeline utility steps 安装

登录 jenkins 平台，点击：【dashboard】 -> 【系统管理】 -> 【插件管理】 -> 【可用插件】，搜索 pipeline utility steps，如下图所示：

使用示例

下面是一些使用 Pipeline Utility Steps 插件中步骤的示例：

findFiles 查找文件

在当前工作目录中查找文件。此步骤返回一个文件信息对象数组，您可以在以下示例中看到其属性。

def files = findFiles(glob: '**/TEST-*.xml') echo """${files[0].name} ${files[0].path} ${files[0].directory} ${files[0].length} ${files[0].lastModified}"""

• excludes : String（可选项）
• glob : String（可选项） 应匹配的文件路径的Ant 样式模式。如果设置了此属性，则将搜索当前工作目录的所有后代以查找匹配项并返回，如果省略，则仅返回目录的直接后代。

案例

nodesByLabel 列出节点

按标签列出节点，默认排除离线节点。

nodesByLabel 是一个实用步骤，用于根据标签动态选择节点（即 Jenkins 代理）。这在 Pipeline 中特别有用，当你需要在运行时基于条件或变量选择具有特定标签的节点时。

nodesByLabel 步骤返回一个节点列表，这些节点匹配所提供的标签表达式。你可以在 Pipeline 的不同阶段使用这些节点来执行构建任务。这使得在多节点 Jenkins 环境中实现高级的资源分配和负载平衡成为可能。

node返回具有给定标签的名称 数组。

• label : String
• offline : boolean（可选项）

案例

pipeline {
    agent any

    environment {
        selectedNodes = ""
    }
    stages {
        stage('Select Node') {
            agent {
                label 'master'
            }
            steps {
                script {
                    selectedNodes = nodesByLabel('label-dev')
                    println "Selected nodes: ${selectedNodes}"
                }
            }
        }

        stage('Execute on Nodes') {
            agent {
                node {
                    label "${selectedNodes}"
                }
            }
            steps {
                echo 'Executing on selected node...'
            }
        }
    }
}

在上述示例中，nodesByLabel 被用于在 Select Node 阶段打印出所有匹配特定标签表达式的节点。然后，在 Execute on Nodes 阶段，Pipeline 将在由参数 selectedNodes 指定的节点上执行步骤。

注意

你可能需要将 'label-dev' 替换为你的 Jenkins 环境中实际存在的标签表达式，

prependToFile 创建文件&追加内容

在 Jenkins Pipeline 中，prependToFile 是 utility-steps 插件提供的一项功能，用于在现有文件的开头添加文本。这在需要记录构建元数据、日志条目或其他信息到文件的开头时非常有用，尤其是当需要保留原有文件内容的同时在最前面插入新的信息。

在工作区中创建一个文件（如果尚不存在），并将给定的内容添加到该文件。

如果文件不存在则创建一个文件，并将给定的内容添加到其中。

• file : String 将被添加的文件的路径

• content : String 要添加的内容

案例

pipeline {
    agent any
    stages {
        stage('Prepend Text to File') {
            steps {
                script {
                    // 使用 prependToFile 向文件添加文本
                    prependToFile(
                        file: 'file.txt',
                        content: 'This is the prepended text.\n'
                    )
                }
            }
        }
    }
}

readCSV 读取 csv 文件

在 Jenkins Pipeline 中，readCSV 是 utility-steps 插件提供的一个功能，用于读取 CSV 文件并将其内容转换为一个列表，其中每一项都是 CSV 文件中一行数据的一个映射（map）。这在需要处理 CSV 文件中的数据，例如配置信息、测试数据或构建参数时非常有用。

readCSV 包含如下参数：

• file: 指定了要读取的 CSV 文件的路径
• separator: 指定了 CSV 文件中列之间的分隔符，默认为 ,
• quote: 指定了 CSV 文件中用于包围可能包含分隔符或特殊字符的字段的引号，默认为 "
• trimValues: 如果设置为 true，则会去除字段值两端的空白字符
• ignoreEmptyLines: 如果设置为 true，则会忽略 CSV 文件中的空行

读取当前工作目录中的文件或字符串作为纯文本。返回CSVRecord实例列表

案例

• file.csv

birdbook,birdbook.com.cn
xingmuyang,xingmuyang@birdbook.com.cn
birdbook:birdbook.com.cn

• pipeline

pipeline {
    agent any
    stages {
        stage('Read CSV File') {
            steps {
                script {
                    def csvData = readCSV(
                        file: 'file.csv',
                        separator: ',',
                        quote: '"',
                        trimValues: true,
                        ignoreEmptyLines: true
                    )
                    for (row in csvData) {
                        echo "Name: ${row[0]},Email: ${row[1]}"
                    }
                }
            }
        }
    }
}

• 输出结果

[Pipeline] echo
Name: birdbook,Email: birdbook.com.cn
[Pipeline] echo
Name: xingmuyang,Email: xingmuyang@birdbook.com.cn
[Pipeline] echo
Name: birdbook:birdbook.com.cn,Email: null

readJSON 读取 JSON 文件

在 Jenkins Pipeline 中，readJSON 是 utility-steps 插件提供的一个功能，用于读取 JSON 文件并将其转换为 Groovy 的 Map 或 List 结构。这使得你能够在 Pipeline 中方便地访问和操作 JSON 文件中的数据。 readJSON 包含如下参数：

• file: 指定了要读取的 JSON 文件的路径

案例

• data.json

{
    "name": "birdbook",
    "age": 30,
    "skills": ["Golang", "Python", "Vue"],
    "address": {
        "street": "1101 Main St",
        "city": "ANHUI",
        "country": "CN"
    }
}

• pipeline

pipeline {
    agent any

    stages {
        stage('Read JSON File') {
            steps {
                script {
                    def jsonData = readJSON(file: 'data.json')
                    // 输出 JSON 文件中的数据
                    println("Name: ${jsonData.name}")
                    println("Age: ${jsonData.age}")
                    println("Skills: ${jsonData.skills}")
                    println("city: ${jsonData.address.city}")
                    // 如果 JSON 包含一个列表
                    jsonData.skills.each { skill ->
                        println("Skill: ${skill}")
                    }
                }
            }
        }
    }
}

• 输出结果

[Pipeline] echo
Name: birdbook
[Pipeline] echo
Age: 30
[Pipeline] echo
Skills: [Golang, Python, Vue]
[Pipeline] echo
Skill: Golang
[Pipeline] echo
Skill: Python
[Pipeline] echo
Skill: Vue
[Pipeline] echo
city: ANHUI
[Pipeline] echo
print all row:street=1101 Main St
[Pipeline] echo
print all row:city=ANHUI
[Pipeline] echo
print all row:country=CN

readManifest: 阅读 Jar 清单

在 Jenkins Pipeline 中，readManifest 是 utility-steps 插件提供的一个功能，用于读取 Maven 或其他构建工具生成的 manifest 文件，并将 manifest 中的属性作为键值对返回。这对于在构建过程中访问或检查 manifest 文件中的信息非常有用，例如，版本号、构建时间戳、主类等。

读取Jar Manifest文件或文本并将其解析为一组 Map。返回的数据结构有两个属性：main用于主要属性，以及entries包含每个单独部分（主要部分除外）。

readManifest 包含如下参数：

• file: 指定了要读取的 manifest 文件的路径。通常，这将是你的构建工件中 META-INF/MANIFEST.MF 的路径

案例

• pipeline

pipeline {
    agent any
    stages {
        stage('Read Manifest') {
            steps {
                script {
                    // def manifest = readManifest(file: '/path/to/META-INF/MANIFEST.MF')
                    def manifest = readManifest(file: 'birdbook.jar')
                    // 输出 manifest 的主类
                    echo "Main-Class: ${manifest['Main-Class']}"
                    // 输出 manifest 的 Build-Time
                    echo "Built at: ${manifest['Build-Time']}"
                    // 输出 manifest 的所有属性
                    manifest.each { key, value ->
                        echo "${key}: ${value}"
                    }
                }
            }
        }
    }
}

读取 manifest 内容有两种方法

直接从文件读取

def manifest = readManifest(file: 'target/birdbook.jar!/META-INF/MANIFEST.MF')

从 jar 或 war 包读取

def manifest = readManifest(file: 'target/birdbook.jar')

readMavenPom 读取maven项目文件

在Jenkins Pipeline中，readMavenPom步骤是utility-steps插件的一部分，用于解析Maven POM文件（Project Object Model）并返回一个Map，其中包含了POM文件中定义的各种属性，如项目版本、依赖关系、构建配置等。

读取Maven 项目文件。返回的对象是Model。

避免使用此步骤和writeMavenPom。最好使用sh步骤来运行mvn目标。例如：

def version = sh script: 'mvn help:evaluate -Dexpression=project.version -q -DforceStdout', returnStdout: true

readMavenPom 包含如下参数：

• file: 这个参数指定了要读取的POM文件的位置，通常是pom.xml
• pom: readMavenPom返回的Map，包含了POM文件中的信息
• pom.version, pom.groupId, pom.artifactId: 分别代表了项目的版本、组ID和Artifact ID
• pom.dependencies 和 pom.build.plugins: 这些列表包含了POM文件中声明的依赖项和构建插件的信息

案例

• pipeline

pipeline {
    agent any
    stages {
        stage('Read POM') {
            steps {
                script {
                    // 读取POM文件
                    def pom = readMavenPom file: 'pom.xml'
                    // 输出项目版本
                    echo "Project Version: ${pom.version}"
                    // 输出项目组ID
                    echo "Group ID: ${pom.groupId}"
                    // 输出项目Artifact ID
                    echo "Artifact ID: ${pom.artifactId}"
                    // 输出项目依赖关系
                    pom.dependencies.each { dep ->
                        echo "Dependency: ${dep.groupId}:${dep.artifactId}:${dep.version}"
                    }
                    // 输出项目构建插件
                    pom.build.plugins.each { plugin ->
                        echo "Plugin: ${plugin.key} - Version: ${plugin.version}"
                    }
                }
            }
        }
    }
}

• 输出结果

[Pipeline] echo
Project Version: 0.0.1-SNAPSHOT
[Pipeline] echo
Group ID: null
[Pipeline] echo
Artifact ID: data
[Pipeline] echo
Dependency: com.alibaba.cloud:spring-cloud-starter-alibaba-nacos-discovery:null
[Pipeline] echo
Plugin: org.springframework.boot:spring-boot-maven-plugin - Version: null

readProperties 读取属性文件

在 Jenkins Pipeline 中，readProperties 是 utility-steps 插件提供的一个功能，用于读取 Java 属性文件（.properties 文件），并将文件中的键值对作为 Map 返回。这在需要从配置文件中加载属性或变量时非常有用，例如数据库连接字符串、API 密钥、环境变量等。

readProperties 包含如下参数：

• file: 这个参数指定了要读取的 .properties 文件的路径
• props: readProperties 方法返回的 Map，包含了 .properties 文件中的所有键值对

案例

• config.properties

db.url=jdbc:mysql://localhost:3306/mydatabase
db.user=birdbook
db.password=mysecretpassword

• pipeline

pipeline {
    agent any
    stages {
        stage('Read Properties') {
            steps {
                script {
                    // 读取 properties 文件
                    def props = readProperties file: 'config.properties'
                    // 输出 properties 文件中的值
                    echo "DB_URL: ${props['db.url']}"
                    echo "DB_USER: ${props['db.user']}"
                    echo "DB_PASSWORD: ${props['db.password']}"
                    // 或者遍历所有的属性
                    props.each { key, value ->
                        echo "${key}: ${value}"
                    }
                }
            }
        }
    }
}

• 输出结果

[Pipeline] echo
DB_URL: jdbc:mysql://localhost:3306/mydatabase
[Pipeline] echo
DB_USER: birdbook
[Pipeline] echo
DB_PASSWORD: mysecretpassword
[Pipeline] echo
db.user: birdbook
[Pipeline] echo
db.password: mysecretpassword
[Pipeline] echo
db.url: jdbc:mysql://localhost:3306/mydatabase

readYaml 读取 yaml 文件

在 Jenkins Pipeline 中，readYaml 是 utility-steps 插件提供的一个功能，用于读取 YAML 文件并将其转换为 Groovy 的 Map 或 List 结构，这使得你能够在 Pipeline 中轻松地访问和操作 YAML 文件中的数据。

readYaml 包含如下参数：

• file: 指定了要读取的 YAML 文件的路径

案例

• data.yaml

name: birdbook
age: 30
skills:
  - Golang
  - Python
  - Vue

• pipeline

pipeline {
    agent any
    stages {
        stage('Read YAML File') {
            steps {
                script {
                    // 读取 YAML 文件
                    def yamlData = readYaml(file: 'data.yaml')
                    // 输出 YAML 文件中的数据
                    println("Name: ${yamlData.name}")
                    println("Age: ${yamlData.age}")
                    println("Skills: ${yamlData.skills}")
                    // 如果 YAML 包含一个列表
                    yamlData.skills.each { skill ->
                        println("Skill: ${skill}")
                    }
                }
            }
        }
    }
}

• 输出结果

[Pipeline] echo
Name: birdbook
[Pipeline] echo
Age: 30
[Pipeline] echo
Skills: [Golang, Python, Vue]
[Pipeline] echo
Skill: Golang
[Pipeline] echo
Skill: Python
[Pipeline] echo
Skill: Vue

tar 创建 Tar 文件

在 Jenkins Pipeline 中，tar 步骤是 utility-steps 插件提供的一种功能，用于创建或解压 tar 归档文件。这对于备份文件、打包工件或在不同构建阶段之间传输文件集非常有用。tar 步骤支持多种压缩格式，如 gzip (gz)、bzip2 (bz2) 和 xz (xz)。

tar 包含如下参数：

• file: 指定要创建的 tar 文件的名称

• dir: 指定要包含在归档中的文件或文件夹，为空将从当前工作目录创建

• exclude: 指定要排除的文件，支持Ant 样式文件模式

• glob: 指定要包含在目标文件中的文件（Ant 样式文件模式。），留空以包含所有文件和目录

• overwrite: 指定如果已经存在同名文件，是否覆盖

案例

• 将要打包的 birdbork 目录数据

$ ls birdbook/
1.txt  2.txt  data.json

• pipeline

  对 birdbook 目录进行打包

pipeline {
    agent any
    stages {
        stage('Extract Tarball') {
            steps {
                script {
                    tar(
                        archive: false,
                        compress: false,
                        defaultExcludes: false,
                        dir: "birdbook",
                        exclude: "data.json",
                        glob: "1.txt"
                        file: "birdbook.tar.gz",
                        overwrite: true
                    )
                }
            }
        }
    }
}

• 输出结果

[Pipeline] tar
Compress /home/jenkins/workspace/test/birdbook filtered by [1.txt] - [data.json] to /home/jenkins/workspace/test/birdbook.tar.gz
Compressed 1 entries.

• 解压 tar 结果

$ tar xvf birdbook.tar.gz 
1.txt

zip：创建 Zip 文件

在 Jenkins Pipeline 中，zip 步骤是 utility-steps 插件提供的一项功能，用于创建 ZIP 归档文件。这对于打包项目工件、备份文件或准备上传到远程服务器的文件集非常有用。zip 步骤可以将一个或多个文件或目录压缩成一个 ZIP 文件。同 tar 非常类似。

zip 包含如下参数：

• zipFile : String

  要创建的 zip 文件的名称/路径

• archive : boolean（可选项）

  如果 zip 文件应作为当前构建的工件存档。存档后，该文件仍将保留在工作区中

• dir : String（可选项）

  创建 zip 文件的基础目录的路径。保留为空将从当前工作目录创建

• exclude : String（可选项）

  从 zip 中排除的文件，支持Ant 样式文件模式

• glob : String（可选项）

  zip 中包含的文件，留空则包含所有文件和目录，支持Ant 样式模式

• overwrite : boolean（可选项）

  如果已经存在同名文件，则应覆盖 zip 文件

案例

• pipeline

pipeline {
    agent any
    stages {
        stage('Extract Tarball') {
            steps {
                script {
                    zip(
                        archive: false,
                        compress: false,
                        defaultExcludes: false,
                        dir: "birdbook",
                        exclude: "data.json",
                        glob: "1.txt"
                        zipFile: "birdbook.zip",
                        overwrite: true
                    )
                }
            }
        }
    }
}

tee 将结果写入文件

在 Jenkins Pipeline 中，tee 步骤是 utility-steps 插件提供的一项功能，它类似于 Unix/Linux 中的 tee 命令。这个步骤允许你将命令的输出同时重定向到控制台和一个文件中。这对于在执行命令的同时保存输出以便于后期分析或审计非常有用。

tee 包含如下参数：

• file : String，结果写入的文件名

案例

• pipeline

pipeline {
    agent any
    stages {
        stage('Extract Tarball') {
            steps {
                script {
                    tee('tar-log.info') {
                        tar(
                            archive: false,
                            compress: false,
                            defaultExcludes: false,
                            dir: "birdbook",
                            exclude: "data.json",
                            file: "birdbook.tar.gz",
                            overwrite: true
                        )
                    }                    
                }
            }
        }
    }
}

• 输出结果

  此时的输出结果同单独执行 tar 类似，不同的是，在工作空间下生成了一个 tag-log.info 的文件，记录 tar 的执行结果。

$ cat tar-log.info
Compress /home/jenkins/workspace/test/birdbook filtered by [null] - [data.json] to /home/jenkins/workspace/testNodeByLabel/birdbook.tar.gz
Compressed 2 entries.

touch 创建文件

在 Jenkins Pipeline 中，touch 步骤是 utility-steps 插件提供的一项功能，用于创建一个空文件或更新现有文件的时间戳。这类似于 Unix/Linux shell 命令 touch。在自动化构建和部署流程中，这可以用于标记文件的最后修改时间，或作为信号文件指示某些操作已完成。

touch 包含如下参数：

• file: 指定了要创建或更新时间戳的文件路径。如果文件不存在，touch 将会创建一个空文件；如果文件已存在，它将更新文件的最后修改时间

案例

• pipeline

untar 解压 Tar 文件

在 Jenkins Pipeline 中，untar 步骤是 utility-steps 插件提供的一项功能，用于解压缩 tar 归档文件。这个步骤可以方便地将一个或多个 tar 归档文件解压到指定的目录中，这对于处理打包的源代码、工件或配置文件非常有用。

untar 包含如下参数：

• file : String（可选项）

  要提取的 tar/tar.gz 文件的名称/路径

• dir : String（可选项）

  将 tar 文件解压到的目标路径。保留为空则在当前工作目录中解压

• glob : String（可选项）

  从 tar 中提取文件，为空则包含所有文件和目录，支持Ant 样式模式

• keepPermissions : boolean（可选项）

  提取文件权限。例如 untar file: 'birdbook.tgz', keepPermissions: true

• quiet : boolean（可选项）

  禁止记录所处理的每个文件的详细输出。例如 untar file: 'birdbook.tgz', quiet: true

案例

• pipeline

pipeline {
    agent any
    stages {
        stage('Extract Tarball') {
            steps {
                script {
                    untar(
                        file: "birdbook.tar.gz",
                        dir: "birdbook",
                        keepPermissions: true, 
                        quiet: false
                    )                    
                }
            }
        }
    }
}

• 输出结果

[Pipeline] untar
Extracting from /home/jenkins/workspace/test/birdbook.tar.gz
Extracting: 1.txt -> /home/jenkins/workspace/test/birdbook/1.txt
Extracting: 2.txt -> /home/jenkins/workspace/test/birdbook/2.txt
Extracted: 2 files

unzip 解压 Zip 文件

• zipFile : String

  要提取的 zip 文件的名称/路径

• charset : String（可选项）

  指定您希望使用的字符集，例如 UTF-8

• dir : String（可选项）

  将zip 解压文件到哪个目录。保留空白则表示在当前工作目录中解压

• glob : String（可选项）

  从 zip 中提取文件，为空以包含所有文件和目录，支持Ant 样式模式

• quiet : boolean（可选项）

  禁止记录所处理的每个文件的详细输出。例如 unzip zipFile: 'birdbook.zip', quiet: true

• read : boolean（可选项）

  将文件内容读入 Map，而不是将其写入工作区。Map 的键将是读取的文件的路径。例如 def v = unzip zipFile: 'birdbook.zip', glob: '*.txt', read: true String version = v['version.txt']

• test : boolean（可选项）

  测试档案的完整性而不是提取它。启用此参数后，所有其他参数 （zipFile 除外）都将被忽略。该步骤将返回true或false取决于结果，而不是抛出异常。

案例

• pipeline

pipeline {
    agent any
    stages {
        stage('Extract Tarball') {
            steps {
                script {
                    unzip(
                        zipFile: "birdbook.zip",
                        dir: "birdbook",
                        charset: "UTF-8", 
                        quiet: false
                    )                   
                }
            }
        }
    }
}

• 输出结果

[Pipeline] unzip
Extracting from /home/jenkins/workspace/test/birdbook.zip
Extracting: birdbook/1.txt -> /home/jenkins/workspace/test/birdbook/birdbook/1.txt
Extracting: birdbook/2.txt -> /home/jenkins/workspace/test/birdbook/birdbook/2.txt
Extracting: birdbook/data.json -> /home/jenkins/workspace/test/birdbook/birdbook/data.json
Extracted: 3 files

writeCSV 写 CSV文件

在 Jenkins Pipeline 中，writeCSV 是 utility-steps 插件提供的一个步骤，用于将数据写入 CSV（逗号分隔值）文件。这在需要收集、记录或报告构建过程中的数据时非常有用。writeCSV 允许你将数据组织成表格形式，便于进一步分析或导入到电子表格软件中。

writeCSV 包含如下参数：

• file: 指定要写入的 CSV 文件的完整路径
• records: 指定要写入的CSVRecord实例的列表
• format: 指定文件格式CSV格式

案例

• pipeline

pipeline {
    agent any
    stages {
        stage('Write Data to CSV') {
            steps {
                script {
                    def data = [
                        ['Name', 'Age'],
                        ['birdbook', 30],
                        ['xingmuyang', 30]
                    ]
                    writeCSV(
                        file: 'birdbook.csv',
                        records: data,
                        format: CSVFormat.EXCEL
                    )
                }
            }
        }
    }
}

• 输出结果

$ cat birdbook.csv 
Name,Age
birdbook,30
xingmuyang,30

writeJSON 写 JSON 文件

在 Jenkins Pipeline 中使用 writeJSON 步骤，你可以将 JSON 数据写入文件。这个步骤是 utility-steps 插件的一部分，它允许你以结构化的方式存储数据，这对于自动化工作流中的数据交换和持久化非常有用。

writeJSON 包含如下参数：

• json：指定要写入的对象。可以是JSON实例，也可以是其他 Map/List 实现。两者都支持
• file （可选）：指定JSON 文件的完整路径。如果提供，则returnText必须为false或省略
• pretty （可选）：通过在每个缩进级别中添加此数量的空格来美化输出
• returnText （可选）：将 JSON 作为字符串返回，而不是将其写入文件。默认为false

案例

• pipeline

pipeline {
    agent any
    stages {
        stage('Write Data to JSON') {
            steps {
                script {
                    // 创建一个 JSON 对象
                    def data = [
                        name: 'birdbook',
                        age: 30,
                        isDeveloper: true,
                        skills: ['Golang', 'Python', 'Vue']
                    ]
                    // 使用 writeJSON 步骤将数据写入文件
                    writeJSON(
                        file: 'birdbook.json',
                        json: data,
                        pretty: 4
                    )
                }
            }
        }
    }
}

• 输出结果

$ cat birdbook.json 
{
    "name": "birdbook",
    "age": 30,
    "isDeveloper": true,
    "skills":     [
        "Golang",
        "Python",
        "Vue"
    ]
}

writeYaml 写 yaml 文件

在Jenkins Pipeline中，使用writeYaml步骤可以将YAML格式的数据写入文件。这通常用于配置管理，特别是在CI/CD流程中需要生成或更新配置文件时。writeYaml步骤是utility-steps插件的一部分。

writeYaml 包含如下参数：

• file （可选） ：工作区中用于写入 YAML 数据的文件的可选路径。如果提供，则returnText必须为false或省略
• data (可选)：要序列化为YAML的对象。必须是布尔值、字符、数字、字符串、URL、日历、日期、UUID、null或它们的集合/映射
• charset （可选）：指定写入文件时使用的字符集。默认为 UTF-8。可用的字符集取决于您的 Jenkins 主系统。但是，java 规范告诉我们至少应该提供以下内容：
  • 美国ASCII
  • ISO-8859-1
  • UTF-8
  • UTF-16BE
  • UTF-16LE
  • UTF-16
• overwrite （可选）：允许覆盖现有文件。默认为false
• returnText （可选）：将 YAML 作为字符串返回，而不是将其写入文件。默认为false。如果true，则file，charset和overwrite不得提供

案例

• pipeline

pipeline {
    agent  any
    stages {
        stage('Write Data to YAML') {
            steps {
                script {
                    // 创建一个Map数据结构，将被转换为YAML
                    def data = [
                        appName: 'birdbook',
                        version: '1.0.0',
                        environment: [
                            development: [
                                database: 'mysql',
                                server: 'aliyun'
                            ],
                            production: [
                                database: 'ali-rds',
                                server: 'aliyun'
                            ]
                        ]
                    ]
                    // 使用writeYaml步骤将数据写入YAML文件
                    writeYaml(
                        file: 'birdbook.yaml',
                        data: data
                    )
                }
            }
        } 
    }
}

• 输出结果

$ cat birdbook.yaml 
appName: birdbook
version: 1.0.0
environment:
  development:
    database: mysql
    server: aliyun
  production:
    database: ali-rds
    server: aliyun 

条件执行

pipeline {
    agent any
    stages {
        stage('Check Condition') {
            steps {
                script {
                    def condition = sh(script: 'test -f /path/to/file', returnStdout: true).trim() == 'true'
                }
                conditionalStep(condition: "${condition}", ifTrue: { echo 'File exists.' }, ifFalse: { echo 'File does not exist.' })
            }
        }
    }
}