This document is intended for novice users of the Jenkins pipeline feature. The document explains what a pipeline is,why that matters,and how to create the different kinds of pipelines.

本文档面向Jenkins管道特性的新手。 该文档解释了什么是管道，为什么重要，以及如何创建不同类型的管道。

While standard Jenkins "freestyle" jobs support simple continuous integration by allowing you to define sequential tasks in an application lifecycle,they do not create a record of execution that persists through any planned or unplanned restarts,enable one script to address all the steps in a complex workflow,or confer the other advantages of pipelines.

虽然标准的Jenkins“自由式”作业通过允许在应用程序生命周期中定义顺序任务来支持简单的持续集成，但它们不会创建通过任何计划或计划外重新启动持续执行的记录，使一个脚本能够处理所有步骤 复杂的工作流程，或赋予管道的其他优点。

In contrast to freestyle jobs,pipelines enable you to define the whole application lifecycle. Pipeline functionality helps Jenkins to support continuous delivery (CD). The Pipeline plugin was built with requirements for a flexible,extensible,and script-based CD workflow capability in mind.

与自由式工作相反，管道使您能够定义整个应用程序生命周期。 管道功能帮助Jenkins支持连续交付（CD）。 Pipeline插件构建时考虑了灵活，可扩展和基于脚本的CD工作流功能的要求。

Accordingly,pipeline functionality is:

The flowchart below is an example of one continuous delivery scenario enabled by the Pipeline plugin:

因此，管线功能是：


耐用：管道可以在计划和计划外重新启动您的Jenkins主人生存。
可停止：管道可以选择停止并等待人工输入或批准，然后再完成其构建的作业。
通用：流水线支持复杂的现实世界CD要求，包括分叉或连接，循环和彼此并行工作的能力。
可扩展：Pipeline插件支持对其DSL（域脚本语言）的自定义扩展和用于与其他插件集成的多个选项。
以下流程图是由管道插件启用的一个连续交付方案的示例：

Pipelines are Jenkins jobs enabled by the Pipeline (formerly called "workflow") plugin and built with simple text scripts that use a Pipeline DSL (domain-specific language) based on the Groovy programming language.

Pipelines leverage the power of multiple steps to execute both simple and complex tasks according to parameters that you establish. Once created,pipelines can build code and orchestrate the work required to drive applications from commit to delivery.

管道是由Pipeline（以前称为“工作流”）插件启用的Jenkins作业，并使用简单的文本脚本构建，使用基于Groovy编程语言的管道DSL（领域专用语言）。


管道利用多个步骤的功能根据您建立的参数执行简单和复杂的任务。 一旦创建，管道可以构建代码并编排从提交到交付的应用所需的工作。

Pipeline terms such as "step," "node," and "stage" are a subset of the vocabulary used for Jenkins in general.

In Jenkins generally,"node" also means any computer that is part of your Jenkins installation,whether that computer is used as a master or as an agent.

在管道编码上下文中，“节点”是执行两个操作的步骤，通常通过从代理上的可用执行器获取帮助：
通过将其中包含的步骤添加到Jenkins构建队列（以便一旦执行器插槽在节点上可用，就运行相应的步骤）来运行它包含的步骤。

创建工作空间，意味着特定于特定作业的文件目录，其中可以进行资源密集型处理，而不会对流水线性能产生负面影响。在节点声明中包含的所有 步骤完成执行后，将自动删除由节点创建的工作空间。在节点中执行所有重要工作（例如构建或运行shell脚本）是最佳做法，因为阶段中的节点 块告诉Jenkins其中的步骤是足够资源调度的，请求代理池的帮助，并只锁定工作区，只要它们需要它。
在Jenkins中，“节点”还指任何作为Jenkins安装的一部分的计算机，无论该计算机是作为主机还是作为代理。

To run pipelines,you need to have a Jenkins instance that is set up with the appropriate plugins. This requires:

You can create pipelines in either of the following ways:

Initial pipeline usage typically involves the following tasks:

初始管道使用通常包括以下任务：

下载和安装Pipeline插件（除非它已经是Jenkins安装的一部分）
创建特定类型的管道
配置管道
通过您的管道控制流（工作流）
缩放您的管道

To create a simple pipeline from the Jenkins interface,perform the following steps:

Pipelines are written as Groovy scripts that tell Jenkins what to do when they are run. Relevant bits of syntax are introduced as needed,so while an understanding of Groovy is helpful,it is not required to use Pipeline.

管道编写为Groovy脚本，告诉Jenkins当它们运行时要做什么。 根据需要引入了相关的语法位，因此理解Groovy是有帮助的，但不需要使用Pipeline。

If you are a Jenkins administrator (in other words,authorized to approve your own scripts),sandboxing is optional but efficient,because it lets scripts run without approval as long as they limit themselves to operations that Jenkins considers inherently safe.

如果您是Jenkins管理员（换句话说，授权批准您自己的脚本），沙盒是可选的，但有效，因为它允许脚本没有批准，只要他们限制自己的操作，Jenkins认为本质上是安全的。

The following example shows a successful build of a pipeline created with a one-line script that uses theechostep to output the phrase,"Hello from Pipeline":

It is a best practice to use parallel steps whenever you can,as long as you remember not to attempt so much parallel processing that it swamps the number of available executors. For example,you can acquire a node within the parallel branches of your pipeline:

这是一个最佳实践，只要你能够使用并行步骤，只要你记得不要尝试这么多的并行处理，它集满了可用执行器的数量。 例如，您可以获取管道并行分支中的一个节点：

TheMultibranch Pipelineproject type enables you to configure different jobs for different branches of the same project. In a multibranch pipeline configuration,Jenkins automatically discovers,manages,and executes jobs for multiple source repositories and branches. This eliminates the need for manual job creation and management,as would otherwise be necessary when,for example,a developer adds a new feature to an existing product.

多分支管道项目类型允许您为同一项目的不同分支配置不同的作业。 在多分支管道配置中，Jenkins自动发现，管理和执行多个源存储库和分支的作业。 这消除了对例如当开发者向现有产品添加新特征时将需要的手动作业创建和管理的需要。

A multibranch pipeline project always includes aJenkinsfilein its repository root. Jenkins automatically creates a sub-project for each branch that it finds in a repository with aJenkinsfile.

多分支管道项目总是在其存储库根目录中包含一个Jenkinsfile。 Jenkins自动为每个分支创建一个子项目，它在一个Jenkinsfile存储库中找到。

Multibranch pipelines use the same version control as the rest of your software development process. This "pipeline as code" approach has the following advantages:

多分支管道使用与其余软件开发过程相同的版本控制。 这种“作为代码的管道”方法具有以下优点：

To create a Multibranch Pipeline:

Jenkins automatically scans the designated repository and creates appropriate branches.

Jenkins自动扫描指定的存储库并创建适当的分支。

例如（再次在Git），如果你开始一个主分支，然后想试验一些变化，因此git checkout -b newfeature并推送一些提交，Jenkins会自动检测你的仓库中的新分支，并创建一个新的子项目。这个子项目将有自己的建设历史无关主干（主线）。

For example (again in Git),if you started with a master branch,and then wanted to experiment with some changes,and so didgit checkout -b newfeatureand pushed some commits,Jenkins would automatically detect the new branch in your repository and create a new sub-project for it. That sub-project would have its own build history unrelated to the trunk (main line).

If you choose,you can ask for the sub-project to be automatically removed after its branch is merged with the main line and deleted. To change your Pipeline script—for example,to add a new Jenkins publisher step corresponding to new reports that yourMakefile/pom.xml/etc. is creating—you edit the appropriateJenkinsfile. Your Pipeline script is always synchronized with the rest of the source code you are working on.

如果选择，您可以要求子项目在其分支与主行合并并删除后自动删除。要更改您的Pipeline脚本 - 例如，添加一个新的Jenkins发布者步骤，对应于您的Makefile / pom.xml / etc的新报表。正在创建 - 您编辑相应的Jenkins文件。您的Pipeline脚本始终与您正在处理的其他源代码同步。

Multibranch Pipelineprojects expose the name of the branch being built with theBRANCH_NAMEenvironment variable. In multibranch pipelines,thecheckout scmstep checks out the specific commit that theJenkinsfileoriginated,so as to maintain branch integrity.

Complex pipelines would be cumbersome to write and maintain if you could only do that in the text area provided by the Jenkins job configuration page.

Accordingly,you also have the option of writing pipeline scripts (Jenkinsfiles) with the editor that you use in your IDE (integrated development environment) or SCM system,and then loading those scripts into Jenkins using thePipeline Script from SCMoption enabled by the workflow-scm-step plugin,which is one of the plugins that the Pipeline plugin depends on and automatically installs.

Loading pipeline scripts using thecheckout scmstep leverages the idea of "pipeline as code," and lets you maintain pipelines using version control and standalone Groovy editors.

To do this,selectPipeline script from SCMwhen defining the pipeline.

With thePipeline script from SCMoption selected,you do not enter any Groovy code in the Jenkins UI; you just indicate by specifying a path where in source code you want to retrieve the pipeline from. When you update the designated repository,a new build is triggered,as long as your job is configured with an SCM polling trigger.

如果您只能在Jenkins作业配置页面提供的文本区域中进行编写和维护，复杂管道将很麻烦。


因此，您还可以选择使用您在IDE（集成开发环境）或SCM系统中使用的编辑器编写管道脚本（Jenkinsfiles），然后使用工作流启用的SCM选项中的管道脚本将这些脚本加载到Jenkins中-scm-step插件，这是Pipeline插件依赖并自动安装的插件之一。


使用checkout scm步骤加载流水线脚本利用“管道作为代码”的概念，并允许您使用版本控制和独立的Groovy编辑器来维护管道。


为此，在定义管道时从SCM中选择流水线脚本。


使用来自SCM选项的Pipeline脚本，您不在Jenkins UI中输入任何Groovy代码;您只需通过指定源代码中要从中检索管道的路径来指示。更新指定的存储库时，只要您的作业配置了SCM轮询触发器，就会触发新的构建。

Because Pipelines are comprised of text scripts,they can be written (edited) in the same script creation area of the Jenkins user interface where you create them:

You typically add functionality to a new pipeline by performing the following tasks:

To configure a pipeline you have created through the Jenkins UI,select the pipeline and clickConfigure.

If you run Jenkins on Linux or another Unix-like operating system with a Git repository that you want to test,you can do that with syntax like the following,substituting your own name for "joe-user":

要配置通过Jenkins UI创建的流水线，请选择流水线，然后单击配置。


例如，如果您在Linux或其他类似于具有Git存储库的操作系统上运行Jenkins，例如，您可以使用下面的语法替换您自己的名称为“joe-user”：

Groovy lets you omit parentheses around function arguments. The named-parameter syntax is also a shorthand for creating a map,which in Groovy uses the syntax[key1: value1,key2: value2],so you could write: