Jenkins——00 介绍/入门/Jenkinsfile使用

最新推荐文章于 2024-06-10 04:44:26 发布

迷茫小渣渣

最新推荐文章于 2024-06-10 04:44:26 发布

阅读量8k

点赞数 2

分类专栏： CICD 文章标签： jenkins

原文链接：https://www.w3cschool.cn/jenkins/jenkins-epas28oi.html

版权

CICD 专栏收录该内容

2 篇文章 1 订阅

订阅专栏

Jenkins是一个开源的持续集成的服务器，Jenkins开源帮助我们自动构建各类项目。Jenkins强大的插件式，使得Jenkins可以集成很多软件，可能帮助我们持续集成我们的工程项目。

主要用于：

持续、自动地构建/测试软件项目，如CruiseControl与DamageControl。
监控一些定时执行的任务

说明

本说明是针对使用需要Java 8的“独立”Jenkins发行版。还建议使用超过512MB RAM的系统。

下载 Jenkins。
在下载目录中打开终端并运行 java -jar jenkins.war --httpPort=8080
浏览http://localhost:8080并按照说明完成安装。
许多Pipeline示例需要在与Jenkins相同的计算机上安装Docker。Docker安装下载教程：点击查看

安装完成后，开始将Jenkins运行并创建Pipeline。

Jenkins Pipeline是一套插件，支持将连续输送Pipeline实施和整合到Jenkins。Pipeline提供了一组可扩展的工具，用于将“复制代码”作为代码进行建模。

Jenkinsfile 是一个包含Jenkins Pipeline定义的文本文件，并被检入源代码控制。这是“Pipeline代码”的基础; 处理连续输送Pipeline的一部分应用程序，以像其他代码一样进行版本检查。创建Jenkinsfile提供了一些直接的好处：

自动创建所有分支和拉请求的Pipeline
Pipeline上的代码审查/迭代
Pipeline的审计跟踪
Pipeline的唯一真实来源，可以由项目的多个成员查看和编辑

通用规则

Agent

Agent通常是一个机器或容器，它连接到Jenkins主机，并在主控器指导时执行任务。

Artifact

在Build或Pipeline 运行期间生成的不可变文件，该文件归档到Jenkins Master上以供用户随后检索。

Build

项目单次执行的结果

Cloud

提供动态代理配置和分配的系统配置，例如由Azure VM Agents 或 Amazon EC2插件提供的配置和分配。

Core

主要的Jenkins应用程序（jenkins.war）提供了可以构建Plugins的基本Web UI，配置和基础。

Downstream

配置Pipeline或项目时被触发作为一个单独的Pipeline或项目的执行的一部分。

Executor

用于执行由节点上的Pipeline或项目定义的工作的插槽。节点可以具有零个或多个配置的执行器，其对应于在该节点上能够执行多少并发项目或Pipeline。

Fingerprint

考虑全局唯一性的哈希追踪跨多个Pipeline或项目的工件或其他实体的使用。

Folder

类似于文件系统上的文件夹的Pipeline和/或项目的组织容器。

Item

Web UI中的实体对应于：Folder, Pipeline, or Project.

Job

一个不推荐的术语，与项目同义。

Label

用于分组代理的用户定义的文本，通常具有类似的功能或功能。例如linux对于基于Linux的代理或 docker适用于支持Docker的代理。

Master

存储配置，加载插件以及为Jenkins呈现各种用户界面的中央协调过程。

Node

作为Jenkins环境的一部分并能够执行Pipeline或项目的机器。无论是the Master还是Agents都被认为是Nodes。

Project

用户配置的Jenkins应该执行的工作描述，如构建软件等。

Pipeline

用户定义的连续输送Pipeline模型，以便更多阅读本手册中的“ Pipeline”一章。

Plugin

与Jenkins Core分开提供的Jenkins功能扩展。

Publisher

完成发布报告，发送通知等的所有配置步骤后的构建的一部分。

Stage

stage是Pipeline的一部分，用于定义整个Pipeline的概念上不同的子集，例如：“构建”，“测试”和“部署”，许多插件用于可视化或呈现Jenkins Pipeline状态/进度。

Step

单一任务从根本上讲，指的是Jenkins 在Pipeline或项目中做了什么。

Trigger

触发新Pipeline运行或构建的标准。

Update Center

托管插件和插件元数据的库存，以便在Jenkins内部进行插件安装。

Upstream

配置的Pipeline或项目，其触发单独的Pipeline或项目作为其执行的一部分。

Workspace

Noede文件系统上的一次性目录，可以由Pipeline或项目完成工作。在Build或 Pipeline运行完成后，工作区通常会保留原样，除非在Jenkins Master上已经设置了特定的Workspace清理策略。

Pipeline 介绍

Jenkins Pipeline是一套插件，支持将连续输送Pipeline实施和整合到Jenkins。Pipeline提供了一组可扩展的工具，用于通过PipelineDSL为代码创建简单到复杂的传送Pipeline。

通常，此“Pipeline代码”将被写入 Jenkinsfile项目的源代码控制存储库，例如：

Jenkinsfile (Declarative Pipeline)
pipeline {
    agent any 

    stages {
        stage('Build') { 
            steps { 
                sh 'make' 
            }
        }
        stage('Test'){
            steps {
                sh 'make check'
                junit 'reports/**/*.xml' 
            }
        }
        stage('Deploy') {
            steps {
                sh 'make publish'
            }
        }
    }
}

agent 表示Jenkins应该为Pipeline的这一部分分配一个执行者和工作区。

stage 描述了这条Pipeline的一个阶段。

steps 描述了要在其中运行的步骤 stage

sh 执行给定的shell命令

junit是由JUnit插件提供的用于聚合测试报告的Pipeline步骤。

虽然Jenkins一直允许基本形式的自由式工作联合起来执行顺序任务，Pipeline使这个概念成为Jenkins的最好的一个部分。

基于Jenkins的核心可扩展性，Pipeline也可以由Pipeline共享库用户和插件开发人员扩展。

下面的流程图是在Jenkins Pipeline中容易建模的一个连续发货方案的示例：

图1.Pipeline流量

Pipeline 条件

Step

单一任务，从基础中告诉了Jenkins应该怎么做。例如，要执行shell命令，请make使用以下sh步骤：sh 'make'。当插件扩展Pipeline DSL时，通常意味着插件已经实现了一个新的步骤。

Node

Pipeline执行中的大部分工作都是在一个或多个声明node步骤的上下文中完成的。将工作限制在Node步骤中有两件事情：

通过将项目添加到Jenkins队列来调度要运行的块中包含的步骤。一旦执行器在节点上空闲，步骤就会运行。
创建工作区（特定于该特定Pipeline的目录），可以从源代码控制中检出的文件完成工作。

根据您的Jenkins配置，某些工作空间在一段时间不活动后可能无法自动清除。

Stage

stage是定义整个Pipeline的概念上不同子集的一个步骤，例如：“Build”，“Test”和“Deploy”，许多插件用于可视化或呈现Jenkins Pipeline状态/进度

Pipeline入门

可以通过以下任一方式创建基本Pipeline：

直接在Jenkins网页界面中输入脚本。
通过创建一个Jenkinsfile可以检入项目的源代码管理库。

在Web UI中定义Pipeline

在脚本文本区域中，输入Pipeline，然后单击保存。

单击立即生成以运行Pipeline。

单击“构建历史记录”下的＃1，然后单击控制台输出以查看Pipeline的完整输出。

上面的示例显示了在Jenkins Web UI中创建的基本Pipeline的成功运行，使用两个步骤。

Jenkinsfile (Scripted Pipeline)
node {   
      echo 'Hello World' 
}

node 在Jenkins环境中分配一个执行器和工作空间。

echo 在控制台输出中写入简单的字符串

在SCM中定义Pipeline

复杂的Pipeline难以在Pipeline配置页面的文本区域内进行写入和维护。为了使这更容易，Pipeline也可以写在文本编辑器中，并检查源控件，作为Jenkinsfile，Jenkins可以通过Pipeline脚本从SCM选项加载的控件。

为此，在定义Pipeline时，从SCM中选择Pipeline脚本。

选择SCM选项中的Pipeline脚本后，不要在Jenkins UI中输入任何Groovy代码; 您只需指定要从其中检索Pipeline的源代码中的路径。更新指定的存储库时，只要Pipeline配置了SCM轮询触发器，就会触发一个新构建。

文本编辑器，IDE，GitHub等将使用Groovy代码进行语法高亮显示， 第一行Jenkinsfile应该是#!/usr/bin/env groovy Jenkinsfile。

管道内置文档Jenkinsfile

Pipeline配有内置的文档功能，可以更轻松地创建不同复杂性的Pipeline。根据Jenkins实例中安装的插件自动生成和更新内置文档。

内置文档可以在全局范围内找到： localhost：8080 / pipeline-syntax /，假设您有一个Jenkins实例在本地端口8080上运行。同样的文档也作为管道语法链接到任何配置的Pipeline的侧栏中项目。

【代码段生成器】

Jenkins会安装很多插件，有些插件会为你提供一些方法，也就是代码化的方法让你去使用片段生成器（下面就是安装好的插件为我们提供的所有功能）

流水线代码片段生成器，非常好用。在这里可以找到每个插件以及Jenkins内置的方法的使用方法。使用片段生成器可以根据个人需要生成方法，有些方法来源于插件，则需要先安装相关的插件才能使用哦。

内置的“Snippet Generator”实用程序有助于为单个步骤创建一些代码，发现插件提供的新步骤，或为特定步骤尝试不同的参数。

Snippet Generator动态填充Jenkins实例可用的步骤列表。可用的步骤数量取决于安装的插件，它明确地暴露了在Pipeline中使用的步骤。

要使用代码段生成器生成步骤代码片段：

从配置的流水线或本地主机：8080 / pipeline-syntax导航到Pipeline语法链接（上面引用）。
在“ 样品步骤”下拉菜单中选择所需的步骤
使用“ 样品步骤”下拉列表下方的动态填充区域配置所选步骤。
单击生成Pipeline脚本以创建一个可以复制并粘贴到Pipeline中的Pipeline代码段。

使用checkout生成器下载gitlab代码

pipeline {
    agent any
 
    stages {
        stage('getCode') {
            steps {
               checkout([$class: 'GitSCM', branches: [[name: '*/master']], extensions: [], userRemoteConfigs: [[credentialsId: 'dc735f39-1cef-4a12-a499-6c873b82adcc', url: 'http://192.168.179.100/devops/demo-hello-service.git']]])
            }
        }
    }
}
 
 
Started by user admin
Running in Durability level: MAX_SURVIVABILITY
[Pipeline] Start of Pipeline
[Pipeline] node
Running on build-01 in /data/cicd/jenkinsagent/workspace/pipeline-test
[Pipeline] {
[Pipeline] stage
[Pipeline] { (getCode)
[Pipeline] checkout
The recommended git tool is: NONE
using credential dc735f39-1cef-4a12-a499-6c873b82adcc
Cloning the remote Git repository
Avoid second fetch
Checking out Revision dc647d4ef52aadabf75db582393156decc4ca6a3 (refs/remotes/origin/master)
Commit message: "Update version"
First time build. Skipping changelog.
[Pipeline] }
[Pipeline] // stage
[Pipeline] }
[Pipeline] // node
[Pipeline] End of Pipeline
Cloning repository http://192.168.179.100/devops/demo-hello-service.git
 > git init /data/cicd/jenkinsagent/workspace/pipeline-test # timeout=10
Fetching upstream changes from http://192.168.179.100/devops/demo-hello-service.git
 > git --version # timeout=10
 > git --version # 'git version 2.7.4'
using GIT_ASKPASS to set credentials git-lab-admin-user
 > git fetch --tags --progress http://192.168.179.100/devops/demo-hello-service.git +refs/heads/*:refs/remotes/origin/* # timeout=10
 > git config remote.origin.url http://192.168.179.100/devops/demo-hello-service.git # timeout=10
 > git config --add remote.origin.fetch +refs/heads/*:refs/remotes/origin/* # timeout=10
 > git rev-parse refs/remotes/origin/master^{commit} # timeout=10
 > git config core.sparsecheckout # timeout=10
 > git checkout -f dc647d4ef52aadabf75db582393156decc4ca6a3 # timeout=10
Finished: SUCCESS

【声明式语法生成器】

脚本方式和声明方式不同的地方：

如果使用脚本方式的语法和声明式差不多也是node{ stages{......} }，但是用不到一些特性比如post标签，即构建后的操作，因为不支持脚本方式，说白了，脚本方式都得自己去写代码。

如果是脚本方式的，需要自己去写代码去判断流水线的状态，然后去做什么动作，声明方式是官方非常推荐的做法，更加结构化，更加简单，有些功能就已经帮我们实现好了。直接在里面写就行了，就不需要为了一些功能写额外的代码了。

可以在声明方式的里面嵌入脚本方式的代码，默认情况下是不支持的，怎么才可以支持，添加script，这样就可以写脚本，更加灵活

可以生成声明式流水线语法的语句块。

可以生成声明式流水线语法的语句块。

pipeline {
    agent any
 
    stages {
        stage('getCode') {
            steps {
              script{
           sh '''
           date 
           pwd
           echo "hh"
           '''
                  
              }
            }
        }
    }
}

stages {
  stage('build') {
    steps {
      // One or more steps need to be included within the steps block.
    }
  }
 
}

Jenkinsfile使用

创建一个Jenkinsfile被检入源代码控制，提供了一些直接的好处：

Pipeline上的代码审查/迭代
Pipeline的审计跟踪
Pipeline的唯一真实来源，可以由项目的多个成员查看和编辑。

Pipeline支持两种语法：Declarative（在Pipeline 2.5中引入）和Scripted Pipeline。两者都支持建立连续输送Pipeline。两者都可以用于在Web UI或者a中定义一个流水线Jenkinsfile，尽管通常被认为是Jenkinsfile将文件创建并检查到源代码控制库中的最佳做法。

aaa

创建Jenkins文件

a Jenkinsfile是一个包含Jenkins Pipeline定义的文本文件，并被检入源代码控制。考虑以下Pipeline，实施基本的三阶段连续输送Pipeline。

Jenkinsfile (Declarative Pipeline)
pipeline {
    agent any

    stages {
        stage('Build') {
            steps {
                echo 'Building..'
            }
        }
        stage('Test') {
            steps {
                echo 'Testing..'
            }
        }
        stage('Deploy') {
            steps {
                echo 'Deploying....'
            }
        }
    }
}

Toggle Scripted Pipeline (Advanced)

Jenkinsfile (Scripted Pipeline)
node {
    stage('Build') {
        echo 'Building....'
    }
    stage('Test') {
        echo 'Building....'
    }
    stage('Deploy') {
        echo 'Deploying....'
    }
}

scripted代码和Declarative代码区别：

这个代码，有两点和上面不同。第一个是Scripted模式是node{}开头，并没有pipeline{},这个区别好知道。第二个要指出的是，scripted模式下没有stages这个关键字或者指令，只有stage。上面其实可以node('Node name') {}来开头，Node name就是从节点或master节点的名称

Build

对于许多项目，Pipeline“工作”的开始就是“build”阶段。通常，Pipeline的这个阶段将是源代码组装，编译或打包的地方。Jenkinsfile不是现有构建工具，如GNU/Make,Maven, Gradle,等的替代品，而是可以被看作是一个结合项目的开发生命周期的多个阶段（建设，测试，部署等）一起。

Jenkins有一些插件，用于调用几乎任何一般使用的构建工具，但是这个例子将只是make从shell步骤（sh）调用。该sh步骤假定系统是基于Unix / Linux的，因为bat可以使用基于Windows的系统。

Jenkinsfile (Declarative Pipeline)
pipeline {
    agent any

    stages {
        stage('Build') {
            steps {
                sh 'make' 
                archiveArtifacts artifacts: '**/target/*.jar', fingerprint: true 
            }
        }
    }
}

该sh步骤调用该make命令，只有在命令返回零退出代码时才会继续。任何非零退出代码将失败Pipeline。

archiveArtifacts捕获与include pattern（**/target/*.jar）匹配的文件，并将它们保存到Jenkins主文件以供以后检索。

Archives the build artifacts (for example, distribution zip files or jar files) so that they can be downloaded later.

测试

运行自动化测试是任何成功的连续传送过程的重要组成部分。因此，Jenkins有许多插件提供的测试记录，报告和可视化设备。在基本层面上，当有测试失败时，让Jenkins在Web UI中记录报告和可视化的故障是有用的。下面的示例使用junit由JUnit插件提供的步骤。

在下面的示例中，如果测试失败，则Pipeline被标记为“不稳定”，如Web UI中的黄色球。根据记录的测试报告，Jenkins还可以提供历史趋势分析和可视化。

Jenkinsfile (Declarative Pipeline)
pipeline {
    agent any

    stages {
        stage('Test') {
            steps {
                /* `make check` returns non-zero on test failures,
                * using `true` to allow the Pipeline to continue nonetheless
                */
                sh 'make check || true' 
                junit '**/target/*.xml' 
            }
        }
    }
}

使用内联shell conditional（sh 'make || true'）确保该 sh步骤始终看到零退出代码，从而使该junit步骤有机会捕获和处理测试报告。下面的“ 处理故障”部分将详细介绍其他方法。

junit捕获并关联与包含pattern（**/target/*.xml）匹配的JUnit XML文件

部署

部署可能意味着各种步骤，具体取决于项目或组织的要求，并且可能是从构建的工件发送到Artifactory服务器，将代码推送到生产系统的任何步骤。

在Pipeline示例的这个阶段，“构建”和“测试”阶段都已成功执行。实际上，“部署”阶段只能在上一阶段成功完成，否则Pipeline将早退。

Jenkinsfile (Declarative Pipeline)
pipeline {
    agent any

    stages {
        stage('Deploy') {
            when {
              expression {
                currentBuild.result == null || currentBuild.result == 'SUCCESS' 
              }
            }
            steps {
                sh 'make publish'
            }
        }
    }
}

Jenkinsfile (Scripted Pipeline)
node {
    /* .. snip .. */
    stage('Deploy') {
        if (currentBuild.result == null || currentBuild.result == 'SUCCESS') { 
            sh 'make publish'
        }
    }
    /* .. snip .. */
}

访问该currentBuild.result变量允许Pipeline确定是否有任何测试失败。在这种情况下，值将是 UNSTABLE。

假设一切都在Jenkins Pipeline示例中成功执行，每个成功的Pipeline运行都会将存档的关联构建工件，报告的测试结果和完整的控制台输出全部放在Jenkins中。

脚本Pipeline可以包括条件测试（如上所示），循环，try / catch / finally块甚至函数。下一节将详细介绍这种高级脚本Pipeline语法。

管道高级语法

字符串插值

Jenkins Pipeline使用与Groovy相同的规则进行字符串插值。Groovy的字符串插值支持可能会让很多新来的语言感到困惑。虽然Groovy支持使用单引号或双引号声明一个字符串，例如：

def singlyQuoted = 'Hello'
def doublyQuoted = "World"

只有后一个字符串将支持基于dollar-sign（$）的字符串插值，例如：

def username = 'Jenkins'
echo 'Hello Mr. ${username}'
echo "I said, Hello Mr. ${username}"

会导致

Hello Mr. ${username}
I said, Hello Mr. Jenkins

工作环境

Jenkins Pipeline通过全局变量公开环境变量，该变量env可从任何地方获得Jenkinsfile。假设Jenkins主机正在运行，在本地主机：8080 / pipeline-syntax / globals＃env中记录了可从Jenkins Pipeline中访问的环境变量的完整列表 localhost:8080，其中包括：

BUILD_ID

当前版本ID，与Jenkins版本1.597+中创建的构建相同，为BUILD_NUMBER

JOB_NAME

此构建项目的名称，如“foo”或“foo / bar”。

JENKINS_URL

完整的Jenkins网址，例如example.com:port/jenkins/（注意：只有在“系统配置”中设置了Jenkins网址时才可用）

参考或使用这些环境变量可以像访问Groovy Map中的任何键一样完成，例如：

Jenkinsfile (Declarative Pipeline)
pipeline {
    agent any
    stages {
        stage('Example') {
            steps {
                echo "Running ${env.BUILD_ID} on ${env.JENKINS_URL}"
            }
        }
    }
}

设置环境变量

根据是否使用Declarative或Scripted Pipeline，在Jenkins Pipeline中设置环境变量是不同的。

声明式Pipeline支持环境指令，而Scripted Pipeline的用户必须使用该withEnv步骤。

Jenkinsfile (Declarative Pipeline)
pipeline {
    agent any
    environment { 
        CC = 'clang'
    }
    stages {
        stage('Example') {
            environment { 
                DEBUG_FLAGS = '-g'
            }
            steps {
                sh 'printenv'
            }
        }
    }
}

参数

声明式Pipeline支持开箱即用的参数，允许Pipeline在运行时通过parameters指令接受用户指定的参数。使用脚本Pipeline配置参数是通过properties步骤完成的，可以在代码段生成器中找到。

如果您使用“使用构建参数”选项来配置Pipeline以接受参数，那么这些参数可作为params 变量的成员访问。

假设一个名为“Greeting”的String参数已经在配置中 Jenkinsfile，它可以通过${params.Greeting}以下方式访问该参数：

Jenkinsfile (Declarative Pipeline)
pipeline {
    agent any
    parameters {
        string(name: 'Greeting', defaultValue: 'Hello', description: 'How should I greet the world?')
    }
    stages {
        stage('Example') {
            steps {
                echo "${params.Greeting} World!"
            }
        }
    }
}

故障处理

声明性Pipeline默认支持robust失败处理经由其post section，其允许声明许多不同的“post conditions”，例如：always，unstable，success，failure，和 changed。“ Pipeline语法”部分提供了有关如何使用各种帖子条件的更多详细信息。

Jenkinsfile (Declarative Pipeline)
pipeline {
    agent any
    stages {
        stage('Test') {
            steps {
                sh 'make check'
            }
        }
    }
    post {
        always {
            junit '**/target/*.xml'
        }
        failure {
            mail to: team@example.com, subject: 'The Pipeline failed :('
        }
    }
}

Toggle Scripted Pipeline (Advanced)

Jenkinsfile (Scripted Pipeline)
node {
    /* .. snip .. */
    stage('Test') {
        try {
            sh 'make check'
        }
        finally {
            junit '**/target/*.xml'
        }
    }
    /* .. snip .. */
}

但是脚本Pipeline依赖于Groovy的内置try/ catch/ finally该Pipeline的执行过程中处理故障的语义。
在上面的测试示例中，该sh步骤被修改为从不返回非零退出代码（sh 'make check || true'）。这种方法虽然有效，但是意味着以下阶段需要检查currentBuild.result以确定是否有测试失败。处理这种情况的另一种方法是保留Pipeline故障的早期退出行为，同时仍然junit有机会捕获测试报告，是使用一系列try/ finally块

使用多个代理(agent)

在所有以前的例子中，只使用了一个代理。这意味着Jenkins将分配一个可用的执行器，无论它是如何标记或配置的。但Pipeline同样允许Jenkinsfile从内利用Jenkins环境中的多个代理商，可为更高级的使用情况，如执行有利于帮助建立跨多个平台/测试。

在下面的示例中，“构建”阶段将在一个代理上执行，并且构建的结果将在“测试”阶段中分别标记为“linux”和“windows”的两个后续代理程序中重用。

Jenkinsfile (Declarative Pipeline)
pipeline {
    agent none
    stages {
        stage('Build') {
            agent any
            steps {
                checkout scm
                sh 'make'
                stash includes: '**/target/*.jar', name: 'app' 
            }
        }
        stage('Test on Linux') {
            agent { 
                label 'linux'
            }
            steps {
                unstash 'app' 
                sh 'make check'
            }
            post {
                always {
                    junit '**/target/*.xml'
                }
            }
        }
        stage('Test on Windows') {
            agent {
                label 'windows'
            }
            steps {
                unstash 'app'
                bat 'make check' 
            }
            post {
                always {
                    junit '**/target/*.xml'
                }
            }
        }
    }
}

：该stash步骤允许捕获与包含模式（**/target/*.jar）匹配的文件，以在同一管道中重用。一旦Pipeline完成执行，垃圾文件将从Jenkins主站中删除。

：agent/node中的参数允许任何有效的Jenkins标签表达式。有关详细信息，请参阅Pipeline语法部分。

：unstash 将从Jenkins主机中检索名为“app”的管道当前工作空间。

: 该bat脚本允许在基于Windows的平台上执行批处理脚本.

可选步骤参数

Pipeline遵循Groovy语言约定，允许在方法参数中省略括号。

许多Pipeline步骤还使用命名参数语法作为使用Groovy创建Map的简写，它使用语法[key1: value1, key2: value2]。发表如下功能等同的语句：

git url: 'git://example.com/amazing-project.git', branch: 'master'
git([url: 'git://example.com/amazing-project.git', branch: 'master'])

为方便起见，当仅调用一个参数（或只有一个必需参数）时，可能会省略参数名称，例如：

sh 'echo hello' /* short form  */
sh([script: 'echo hello'])  /* long form */

高级脚本管道

脚本Pipeline是基于Groovy 的领域专用语言，大多数Groovy语法可以在脚本Pipeline中使用而无需修改。

同时执行

上面的例子在线性系列中的两个不同平台上运行测试。在实践中，如果make check 执行需要30分钟完成，“测试”阶段现在需要60分钟才能完成！

幸运的是，Pipeline具有内置功能，用于并行执行Scripted Pipeline的部分，在适当命名的parallel步骤中实现。

迷茫小渣渣

关注

2
点赞
踩
14

收藏

觉得还不错? 一键收藏
1
评论
Jenkins——00 介绍/入门/Jenkinsfile使用

Jenkins是一个开源的持续集成的服务器，Jenkins开源帮助我们自动构建各类项目。Jenkins强大的插件式，使得Jenkins可以集成很多软件，可能帮助我们持续集成我们的工程项目。主要用于：持续、自动地构建/测试软件项目，如CruiseControl与DamageControl。监控一些定时执行的任务说明本说明是针对使用需要Java 8的“独立”Jenkins发行版。还建议使用超过512MB RAM的系统。下载Jenkins。在下载目录中打开终端并运行java -jar .
复制链接

扫一扫