创建人工服务器实例
要向Artifactory服务器上传或下载文件，您需要在Pipeline脚本中创建一个Artifactory服务器实例。
如果您的Artifactory服务器已经在Jenkins中定义，您只需要它的服务器ID，可以在下面获得管理|配置系统。
然后，要创建Artifactory服务器实例，在脚本中添加以下行:
defserver = Artifactory。服务器“my-server-id”
如果你的Artifactory没有在Jenkins中定义，你仍然可以这样创建它:
defserver = Artifactory。newServer url: 'artifactory-url'，用户名:'username'，密码:'password'
你也可以使用Jenkins凭证ID代替用户名和密码:
defserver = Artifactory。newServer url: 'artifactory-url'， credentialsId: ' ccreeddenentitiaall '
您可以通过以下方法修改server对象:
//如果Jenkins被配置为使用http代理，你可以在使用Artifactory server: server时绕过代理。bypassProxy = true //如果你使用的是用户名和密码:Username = 'new-user-name'服务器。password = 'new-password' //如果您正在使用凭据ID: server。credentialsId = ' ccrecreeddeennttiiaall ' //配置连接超时时间(秒)。//默认值(如果没有配置)是300秒:server.connection.timeout = 300
使用变量
我们建议使用变量而不是纯文本来指定Artifactory服务器详细信息。
上传和下载文件
要上传或下载文件，首先需要创建一个规范，它是一个JSON文件，指定应该上传或下载哪些文件以及目标路径。
例如:
def downloadSpec = " "{"文件":[{“模式”:“bazinga-repo / * . zip”,“目标”:“bazinga /" } ] }"""
的所有ZIP文件bazinga-repo工件存储库应该下载到bazinga目录。
"files"是一个数组
由于“files”元素是一个数组，因此可以在一个下载规范中指定多个模式和相应的目标。
要下载这些文件，在脚本中添加以下代码行:
服务器。下载规格:下载规格
上传文件非常相似。下面的示例上传包含的所有ZIP文件不好的在他们的名字进入froggy-files文件夹中的bazinga-repoArtifactory库。
def uploadSpec = """{"files": [{"pattern": "bazinga/*froggy*.zip"， "target": "bazinga-repo/froggy-files/"}]}""" server. "上传规格:uploadSpec
您可以阅读有关使用文件规格下载和上传文件在这里。
如果您希望构建失败，在没有上传或下载文件的情况下，请添加failNoOp论证上传或下载方法如下:
服务器。下载规格:downloadSpec, failNoOp: true服务器。上传规格:uploadSpec, failNoOp: true
在Artifactory中设置和删除文件属性
将文件上传到Artifactory时使用server.upload方法时，您可以选择设置文件的属性。属性被定义为发送给该方法的文件规范的一部分。稍后可以使用这些属性来过滤和下载这些文件。
在某些情况下，您可能希望在Artifactory中已经存在的文件上设置属性。这里要设置的属性发送到文件规范之外。要定义要设置属性的文件，需要使用文件规范。这里有一个例子:
def setPropsSpec = """{"files": [{"pattern": "my-frog -local-repo/dir/*.zip"， "props": "filter-by-this-prop=yes"}]}""" " server. conf . conf . conf "setProps spec: setPropsSpec, props: " p1=v1;p2=v2 "
在上面的示例中，p1和p2属性将使用v1和v2值分别。目录下的dir目录中的所有zip文件都将设置属性my-froggy-local-repo存储库。只适用于已经具有filter-by-this-prop属性设置为是的都会受到影响。
的failNoOp参数是可选的。如果没有设置任何属性，将其设置为true将导致作业失败。下面是如何使用它:
server.setPropsspec: setPropsSpec, props: “p1=v1;p2=v2”, failNoOp: true
的server.deleteProps方法可用于从Artifactory中的文件中删除属性，如server.setProps这两个方法的唯一区别是，对于deleteProps，我们只指定要删除的属性的名称。名称以逗号分隔。不应该指定属性值。的failNoOp参数是可选的。如果没有删除任何属性，将其设置为true将导致作业失败。
这里有一个例子:
server.deleteProps spec: deletePropsSpec, props: " p1,p2,p3 "， failNoOp: true
将构建信息发布到Artifactory
如果您还不熟悉build-info实体，请阅读相关内容在这里。
下载和上传方法都返回一个build-info对象，该对象可以发布到Artifactory，如下所示:
defbuildinfo1 =服务器。下载下载Spec def buildInfo2 = server.upload uploadSpec buildInfo1.append buildInfo2 server.publishBuildInfo buildInfo1
defbuildinfo = Artifactory.newBuildInfo()服务器。下载规格:下载规格, buildInfo: buildInfo server.upload spec: uploadSpec, buildInfo: buildInfo server.publishBuildInfo buildInfo
您还可以自定义用于下载和上传操作的build-info模块名称。你应该这样做:
defbuildinfo1 =服务器。下载spec: downloadSpec, module: 'my-custom-build-info-module-name' def buildInfo2 = server.upload spec: uploadSpec, module: 'my-custom-build-info-module-name'
从Build-Info中获取依赖项和工件
build-info实例将构建信息存储在本地。它可以稍后发布到Artifactory。如上所示，server.uploadmethod将构件添加到构建信息和服务器。下载方法将依赖项添加到构建信息中。
您可以选择获取存储在build-info实例中的依赖项和构件列表。您可以在任何时候执行此操作，在将构建信息发布到Artifactory之前或之后。在下面的示例中，我们首先检查build-info中是否存储了任何依赖项，如果有，我们访问其中一个依赖项的属性。然后我们对工件做同样的处理。
如果(buildInfo.getDependencies () .size () > 0) {def localPath = buildInfo.getDependencies () [0] .getLocalPath () def remotePath = buildInfo.getDependencies () [0] .getRemotePath () def md5 = buildInfo.getDependencies () [0] .getMd5 () def sha1 = buildInfo.getDependencies () [0] .getSha1()}如果(buildInfo.getArtifacts () .size () > 0) {def localPath = buildInfo.getArtifacts () [0] .getLocalPath () def remotePath = buildInfo.getArtifacts () [0] .getRemotePath () def md5 = buildInfo.getArtifacts () [0] .getMd5 () def sha1 =buildInfo.getArtifacts () [0] .getSha1 ()}
修改默认生成名称和生成编号
您可以修改Jenkins设置的默认构建名称和构建号。你应该这样做:
def buildInfo = Artifactory.newBuildInfo() buildInfo.name = 'super-frog' buildInfo。数字= 'v1.2.3'…服务器。publishBuildInfo buildInfo
如果您要像上面所示的那样设置构建名称或编号，那么在使用这个buildInfo实例上传文件之前这样做是很重要的。
原因如下:服务器。上传的方法also tags the uploaded files with the build name and build number (using the build.name和构建。数属性)。在文件已经上传到Artifactory之后设置新的构建名称或编号，将不会更新附加到文件的属性。
设置Build-Info项目
如果构建信息应该作为特定JFrog项目的一部分发布，那么在将构建信息实例发布到Artifactory之前，您应该在构建信息实例上设置项目密钥。你应该这样做:
def buildInfo = Artifactory.newBuildInfo()Project = 'my-jfrog-project-key'…服务器。publishBuildInfo buildInfo
捕获环境变量
要设置Build-Info对象在下载和上传文件时自动捕获环境变量，请在脚本中添加以下内容:
defbuildinfo = Artifactory.newBuildInfo() buildInfo.env.capture = true
默认情况下，包含“password”、“psw”、“secret”、“token”或“key”(不区分大小写)的环境变量名称将被排除在外，并且不会发布到Artifactory。
你可以用通配符添加更多的include/exclude模式，如下所示:
def buildInfo = Artifactory.newBuildInfo() buildInfo.env.filter. addinclude ("*a*") buildInfo.env.filter. addexinclude ("DONT_COLLECT*")
以下是如何重置为include/exclude模式的默认值:
buildInfo.env.filter.reset ()
你也可以完全清除include/exclude模式:
buildInfo.env.filter.clear ()
要在脚本的任何位置收集环境变量，使用:
buildInfo.env.collect ()
您可以通过以下方式获取收集到的环境变量的值:
value = buildInfo.env.vars['env-var-name']
触发构建保留
要在向Artifactory发布构建信息时触发构建保留，请使用以下方法:
buildInfo。maxBuilds: 10
buildInfo。保留率maxDays: 7
若要保留构建并删除构建工件，请添加deleteBuildArtifacts与真正的值如下所示:
buildInfo。retention maxBuilds: 10, maxDays: 7, doNotDiscardBuilds: ["3"， "4"]， deletebuilartifacts: true
触发异步构建保留是可能的。要做到这一点，请添加异步参数与真正的如下图所示:
buildInfo。保留maxBuilds: 10, deletebuilartifacts: true, async: true
收集构建问题
构建信息可以包括作为构建的一部分处理的问题。问题列表是由Jenkins从git提交消息中自动收集的。这要求项目开发人员使用一致的提交消息格式，其中包括问题ID和问题摘要，例如:
HAP-1364 -将制表符替换为空格
然后可以在Artifactory的构建UI中查看问题列表，并在问题跟踪系统中提供到问题的链接。
收集问题所需的信息通过JSON配置提供。该配置可以作为文件或JSON字符串提供。
下面是一个问题收集配置的示例。
{“版本”:1、“问题”:{“trackerName”:“JIRA”、“正则表达式”:“(. + - [0 - 9]+)\ \ s - \ \ s(+)”,“keyGroupIndex”:1、“summaryGroupIndex”:2,“trackerUrl”:“http://my-jira.com/issues”,“总”:“真正的”、“aggregationStatus”:“发布”}}
配置文件属性:
属性名 |
描述 |
|---|---|
| 版本 | 模式版本仅供内部使用。不要改变! |
| trackerName | 问题跟踪系统的名称(类型)。例如，JIRA。这个属性可以取任何值。 |
| trackerUrl | 问题跟踪URL。此值用于构造到Artifactory构建UI中的问题的直接链接。 |
| keyGroupIndex | 用于检索问题键的正则表达式中的捕获组索引。在上面的示例中，将索引设置为“1”检索hap - 1364从这个提交消息: HAP-1364 -将制表符替换为空格 |
| summaryGroupIndex | 正则表达式中用于检索问题摘要的捕获组索引。在上面的示例中，将索引设置为“2”检索的这个提交消息的示例问题: HAP-1364 -将制表符替换为空格 |
总 |
如果希望所有构建都包含以前构建中的问题，则设置为true。 |
aggregationStatus |
如果aggregate设置为true，则此属性指示聚合问题的时间间隔。在上面的例子中，问题将从以前的构建中聚集起来，直到找到具有RELEASE状态的构建。当在Artifactory中提升构建时，可以设置此状态。 |
| 正则表达式 | 用于匹配git提交消息的正则表达式。表达式应该包括两个捕获组—问题键(ID)和问题摘要。在上面的示例中，正则表达式匹配的提交消息如下所示: HAP-1364 -将制表符替换为空格 |
下面是如何在管道脚本中设置问题收集。
服务器=人工制品。服务器“my-server-id”config = """{ "version": 1, "issues": { "trackerName": "JIRA", "regexp": "(.+-[0-9]+)\\s-\\s(.+)", "keyGroupIndex": 1, "summaryGroupIndex": 2, "trackerUrl": "http://my-jira.com/issues", "aggregate": "true", "aggregationStatus": "RELEASED" } }""" buildInfo.issues.collect(server, config) server.publishBuildInfo buildInfo
为了帮助您开始，我们建议使用Github的例子。
聚合构建
发布到Artifactory的构建信息可以包含表示不同构建步骤的多个模块。如本节前面所示，您只需要将相同的buildInfo实例传递给需要它的所有方法(server.upload例如)。
但是，如果构建过程在多台机器上运行，或者分布在不同的时间段，会发生什么情况?如何将所有构建步骤聚合到一个构建信息中?
您可以选择为构建过程的每个部分创建和发布单独的构建信息，然后将所有发布的构建信息聚合到一个构建信息中。最终的结果是一个build-info引用了其他先前发布的build-info。
在下面的例子中，我们的管道脚本向Artifactory发布了两个build-info实例:
defbuildinfo1 = Artifactory.newBuildInfo() buildInfo1.name = 'my-app-linux' buildInfo1。编号= '1'服务器。publishBuildInfo buildInfo1 def buildInfo2 = Artifactory.newBuildInfo() buildInfo2.name = 'my-app-windows' buildInfo2。编号= '1'服务器。publishBuildInfo buildInfo2
此时，我们在Artifactory中存储了两个构建信息。现在让我们创建最后一个build-info，它引用前面两个build-info。
deffinalbuildinfo = Artifactory.newBuildInfo()服务器。buildAppend(finalBuildInfo， 'my-app-linux'， '1')服务器。buildAppend(finalBuildInfo， 'my-app-windows'， "1")服务器。publishBuildInfo finalBuildInfo
'finalBuildInfo'包含两个模块，它们引用＇my-app-linux'和'my-app-windows”。
构建提升和x射线构建扫描目前不支持聚合构建。
在Artifactory中促进构建
要在Artifactory中提升存储库之间的构建，请在promotionConfig对象中定义提升参数并对其进行提升。例如:
def promotionConfig =[//必选参数'targetRepo': 'lib -prod-ready-local'， //可选参数//要升级的构建名和构建号如果没有指定，Jenkins作业的构建名称和构建号使用'buildName': buildInfo.name， 'buildNumber': buildInfo.name。//只有当此构建与Artifactory中的项目相关联时，才能按如下方式设置项目键。'project': 'my-project-key'， //注释和状态显示在Artifactory的Build History选项卡中' Comment ': 'this is the promotion Comment '， ' Status ': 'Released'， //指定构建工件的源存储库。'sourceRepo': 'lib - stage -local'， //指示是否提升构建依赖关系，除了构件。'includeDependencies': true， //表示是否复制文件。Move是默认的'copy': true， //表示如果移动或复制某个文件失败，是否使升级进程失败。默认为False。'failFast': true] //提升构建服务器。促进promotionConfig
允许发布版本的交互式推广
本文中的“在Artifactory中提升构建”一节描述了您的Pipeline脚本如何在Artifactory中提升构建。然而，在某些情况下，您希望在构建完成后执行构建提升。您可以配置Pipeline作业，将其发布到Artifactory的部分或全部构建公开，以便以后可以使用GUI交互式地提升它们。以下是互动推广的内容:
当构建完成时，可以通过单击构建运行旁边的升级图标来访问升级窗口。
你应该这样做。
首先，您需要创建一个'promotionConfig'实例，与'Promoting Builds in Artifactory'一节中所示的方式相同。
接下来，你可以使用它，为交互式推广公开构建如下:
Artifactory。addInteractivePromotion server: server, promotionConfig: promotionConfig, displayName: "Promote me please"
通过多次使用该方法，您可以添加任意多的构建。添加的所有构建都将显示在提升窗口中。
'addInteractivePromotion'方法需要以下参数:
- “服务器”是完成构建升级的工件。您可以像本文开头所描述的那样创建服务器实例。
- “promotionConfig”包含促销详细信息。“在Artifactory中提升构建”一节描述了如何创建promotionConfig实例。
- "displayName"是一个可选参数。如果您添加了它，提升窗口将显示它，而不是构建名称和编号。
使用Artifactory构建Maven
Maven构建可以解析依赖关系、部署构件并向Artifactory发布构建信息。
Maven的兼容性
- 支持的Maven最低版本是3.3.9
- 对Artifacts的部署由部署和安装阶段触发。
要从Pipeline脚本中使用Artifactory运行Maven构建，首先需要创建Artifactory服务器实例，如本文开头所述。
这里有一个例子:
defserver = Artifactory。服务器“my-server-id”
下一步是创建一个Artifactory Maven Build实例:
defrtmaven = Artifactory.newMavenBuild()
现在让我们定义Maven构建应该从哪里下载它的依赖项。假设你想从'lib -release'库中解析发布依赖，从'lib -snapshot'库中解析快照依赖。这两个存储库都位于您上面定义的Artifactory服务器实例上。下面是你如何定义它，使用我们创建的Artifactory Maven Build实例:
rtMaven。解析服务器:server, releaseRepo: 'lib -release'， snapshotRepo: 'lib -snapshot'
现在让我们定义构建工件应该部署到哪里。同样，我们在rtMaven实例上定义了Artifactory服务器和存储库:
rtMaven.deployer server: server, releaseRepo: 'lib -release-local'， snapshotRepo: 'lib -snapshot-local'
默认情况下，所有构建构件都部署到Artifactory。如果您只想部署一些工件，您可以使用'addInclude'方法根据它们的名称对它们进行过滤。在下面的示例中，我们只部署名称以“frog”开头的工件
青蛙rtMaven.deployer.artifactDeploymentPatterns.addInclude(“*”)
您还可以从部署中排除工件。在下面的例子中，我们部署了所有的工件，除了那些zip文件:
rtMaven.deployer.artifactDeploymentPatterns.addExclude(“* . zip”)
为了让事情更有趣，你可以把这两种方法结合起来。例如，要部署所有名称以“frog”开头但不是zip文件的工件，请执行以下操作:
青蛙rtMaven.deployer.artifactDeploymentPatterns.addInclude(“*”).addExclude(“* . zip”)
如果您想向已部署的构件添加自定义属性，您可以这样做:
rtMaven.deployer.addProperty(“地位”,“在qa阶段”)。addProperty("compatibility"， "1"， "2"， "3")
默认情况下，将使用3个线程来上传maven构件。您可以修改使用的线程数如下:
rtmaven .deploy .threads = 6
在某些情况下，您希望禁用工件部署到Artifactory，或者使部署成为有条件的。你应该这样做:
rtmwen .deployer. deployartifacts = false
如果您想在此构建中使用Maven包装器，请添加以下内容:
rtMaven。useWrapper = true
要为我们的构建选择一个Maven安装，我们应该通过Jenkins Manage定义一个Maven工具，然后设置工具名称如下:
rtMaven.tool= 'maven tool name'
而不是使用rtMaven.tool，您可以使用MAVEN_HOME环境变量设置Maven安装目录的路径，如下所示:
env。MAVEN_HOME = '/tools/apache-maven-3.3.9'
下面是如何为构建定义Maven选项:
rtMaven。opts = '-Xms1024m -Xmx4096m'
如果您希望Maven使用与构建代理的默认JDK不同的JDK，没问题。
只需将JAVA_HOME环境变量设置为所需的JDK路径(bin目录上方的目录的路径，其中包含java可执行文件)。
你可以这样做:
env.JAVA_HOME = 'full/path/to/JDK'
好了，我们已经准备好运行构建了。下面是我们如何定义pom文件路径(相对于工作区)和Maven目标。部署到Artifactory是在“安装”阶段执行的:
defbuildinfo = rtMaven.run pom: 'maven-example/pom.xml'，目标:'clean install'
上面的方法运行Maven构建。注意，该方法返回abuildInfo实例，稍后可以将其发布到Artifactory。
但是，在某些情况下，您希望传递一个现有的buildInfo实例以供构建使用。当您想要在build-info实例上设置自定义构建名称或构建编号时，或者当您想要将多个构建聚合到同一个build-info实例中时，这可能会派上用场。方法传递现有的构建信息实例的方法如下rtMaven.run方法:
rtMaven.run pom: 'maven-example/pom.xml'，目标:'clean install'， buildInfo: existingBuildInfo
默认情况下，构建工件将被部署到Artifactory，除非rtMaven.deployer.deployArtifacts属性被设置为false。这可以在两种情况下派上用场:
- 您不希望发布工件。
- 您希望稍后发布工件。下面是在稍后阶段发布工件的方法:
rtMaven.deployer.deployArtifacts buildInfo
确保使用从rtmwen .run方法接收到的相同的buildInfo实例。还要确保在运行rtmwen .run方法的同一代理上运行上述方法，因为构件是在该代理的文件系统上构建和存储的。
默认情况下，Maven在用户主目录下的.m2目录中使用本地Maven存储库。如果您希望Maven在作业的工作区中创建本地存储库，请添加- Maven .repo.local=。M2系统属性到目标值如下图所示:
debuildinfo = rmaven .run pom: 'maven-example/pom.xml'，目标:'clean install - maven.repo.local=.m2'
build-info呢?
build-info还没有发布到Artifactory，但是它被本地存储在由run方法返回的buildInfo实例中。现在你可以将它发布到Artifactory，如下所示:
服务器。publishBuildInfo buildInfo
您还可以将多个buildInfo实例合并为一个buildInfo实例，并将其作为一个构建发布到Artifactory，如将构建信息发布到Artifactory节。
Gradle build with Artifactory
Gradle构建可以解析依赖关系、部署构件并将构建信息发布到Artifactory。
Gradle兼容性
支持的Gradle最低版本是4.10
要从Pipeline脚本中使用Artifactory运行Gradle构建，首先需要创建一个Artifactory服务器实例，如本文开头所述。
这里有一个例子:
defserver = Artifactory。服务器“my-server-id”
下一步是创建一个人工Gradle Build实例:
defrtgradle = Artifactory.newGradleBuild()
现在让我们定义Gradle构建应该从哪里下载它的依赖项。假设您希望从“lib -release”存储库解析依赖项，该存储库位于您上面定义的Artifactory服务器实例上。下面是你如何定义它，使用我们创建的Artifactory Gradle Build实例:
rtGradle。解析器服务器:server, repo: 'lib -release'
现在让我们定义构建工件应该部署到哪里。同样，我们在“rtGradle”实例上定义了Artifactory服务器和存储库:
rtGradle.deployer server: server, repo: 'lib -release-local'
rtGradle.deployer server: server, releaseRepo: 'lib -release-local'， snapshotRepo: 'lib -snapshot-local'
Gradle允许通过将发布定义为Gradle构建脚本的一部分来定制部署的工件列表。Gradle发布用于将工件分组在一起。您可以选择定义Jenkins应该使用哪个已定义的发布。只有按这些发布分组的工件才会被部署到Artifactory。如果您没有定义发布，那么将使用默认发布，其中包括java项目生成的工件列表。下面是定义出版物列表的方法:
rtGradle.deployer.publications.add阀门(“mavenJava”)(“ivyJava”)
如果您想部署gradle脚本中定义的所有发布的工件，您可以设置“ALL_PUBLICATIONS”字符串，如下所示。
rtGradle.deployer.publications.add(“ALL_PUBLICATIONS”)
默认情况下，所有构建构件都部署到Artifactory。如果您只想部署一些工件，您可以使用'addInclude'方法根据它们的名称对它们进行过滤。在下面的示例中，我们只部署名称以“frog”开头的工件
青蛙rtGradle.deployer.artifactDeploymentPatterns.addInclude(“*”)
您还可以从部署中排除工件。在下面的例子中，我们部署了所有的工件，除了那些zip文件:
rtGradle.deployer.artifactDeploymentPatterns.addExclude(“* . zip”)
为了让事情更有趣，你可以把这两种方法结合起来。例如，要部署所有名称以“frog”开头但不是zip文件的工件，请执行以下操作:
青蛙rtGradle.deployer.artifactDeploymentPatterns.addInclude(“*”).addExclude(“* . zip”)
如果您想向已部署的构件添加自定义属性，您可以这样做:
rtGradle.deployer.addProperty(“地位”,“在qa阶段”)。addProperty("compatibility"， "1"， "2"， "3")
rtgradle .deploy .threads = 6
在某些情况下，您希望禁用工件部署到Artifactory，或者使部署成为有条件的。你应该这样做:
rtgradle .deploy . deployartifacts = false
万一“com.jfrog。Gradle Plugin已经在你的Gradle脚本中应用了，我们需要让Jenkins知道它不应该应用它。我们是这样做的:
rtGradle。usesPlugin = true
如果你想在这个版本中使用Gradle Wrapper，添加如下内容:
rtGradle。useWrapper = true
如果你不想使用Gradle Wrapper，而是设置Gradle安装，你应该通过Jenkins Manage定义Gradle Tool，然后设置工具名称如下:
rtGradle。tool = 'gradle tool name'
如果您希望Gradle使用不同于构建代理默认的JDK，没问题。
只需将JAVA_HOME环境变量设置为所需的JDK路径(bin目录上方的目录的路径，其中包含java可执行文件)。
你可以这样做:
env.JAVA_HOME = ' JDK路径'
好了，看起来我们已经准备好运行Gradle构建了。下面是我们如何定义构建。gradle文件路径(相对于工作区)和gradle任务。部署到Artifactory是作为“artifactoryPublish”任务的一部分执行的:
defbuildinfo = rtGradle.run rootDir: "projectDir/"， buildFile: 'build. exe '。gradle'， tasks: 'clean artifactoryPublish'
上面的方法运行Gradle构建。注意，该方法返回abuildInfo实例，稍后可以将其发布到Artifactory。
但是，在某些情况下，您希望传递一个现有的buildInfo实例以供构建使用。当您想要在build-info实例上设置自定义构建名称或构建编号时，或者当您想要将多个构建聚合到同一个build-info实例中时，这可能会派上用场。方法传递现有的构建信息实例的方法如下rtGradle.run方法:
rtGradle.run rootDir: "projectDir/"， buildFile: 'build. exe '。gradle'， tasks: 'clean artifactoryPublish', buildInfo: existingBuildInfo
默认情况下，构建构件将被部署到Artifactory，除非rtgradle .deploy . deployartifacts属性被设置为false。这可以在两种情况下派上用场:
- 您不希望发布工件。
- 您希望稍后发布工件。下面是在稍后阶段发布工件的方法:
rtGradle.deployer.deployArtifacts buildInfo
确保使用从rtGradle.run方法接收到的同一个buildInfo实例。还要确保在运行rtGradle.run方法的同一代理上运行上述方法，因为构件是在该代理的文件系统上构建和存储的。
build-info呢?
build-info还没有发布到Artifactory，但是它被本地存储在由run方法返回的buildInfo实例中。现在你可以将它发布到Artifactory，如下所示:
服务器。publishBuildInfo buildInfo
您还可以将多个buildInfo实例合并为一个buildInfo实例，并将其作为一个构建发布到Artifactory，如将构建信息发布到Artifactory节。
就是这样!我们都准备好了。
rtGradle实例支持额外的配置api。你可以这样使用这些api:
defrtgradle = Artifactory. newgradlebuild() //将Maven描述符部署到Artifactory: rtGradle.deployer. deploymavendescriptors = true //将Ivy描述符(pom.xml文件)部署到Artifactory: rtGradle.deployer. deployivydescriptors = true //以下属性用于Ivy发布配置。//以下为默认值。//设置已部署的Ivy描述符模式:rtgradle .deployer. ivyppattern = '[organisation]/[module]/ Ivy -[revision].xml' //设置已部署的Ivy工件模式:rtGradle.deployer.artifactPattern = '[organisation]/[module]/[revision]/[artifact]-[revision](-[classifier])。[ext]' //设置mavenCompatible为true，如果你希望在Ivy布局路径中用斜杠替换点，以匹配Maven布局:rtgradle .deploy .mavenCompatible = true
您还可以选择在gradle构建脚本中定义默认值。阅读更多在这里。
使用Artifactory的Maven发布管理
使用Artifactory Pipeline DSL，您可以按照以下说明轻松地管理和运行Maven项目的发布版本:
首先，从源代码控制中克隆代码:
Git url: 'https://github.com/eyalbe4/project-examples.git'
如果pom文件有一个快照版本，Maven将创建快照工件，因为pom文件包含一个快照版本(例如，1.0.0-SNAPSHOT)。
由于您希望构建创建发布工件，因此需要将pom文件中的版本更改为1.0.0。
为此，创建一个mavenDescriptor实例，并将版本设置为1.0.0:
def descriptor = Artifactory.mavenDescriptor()描述符。版本= '1.0.0'
如果项目的pom文件不在克隆项目的根目录，而是在子目录中，将其添加到mavenDescriptor实例中:
描述符。pomFile = 'maven-example/pom.xml'
在大多数情况下，您希望验证您的发布版本不包含快照依赖项。有两种方法可以做到。
第一种方法是配置描述符，使其在pom文件中发现快照依赖项时使构建失败。在这种情况下，在将新版本设置为pom文件之前，作业将失败。
下面是你如何配置它:
描述符。failOnSnapshot = true
验证这一点的第二种方法是使用hasSnapshots方法，如果找到快照依赖项，则返回一个布尔值true:
def快照= description . hassnapshots () if(快照){.... . conf . conf . conf}
就是这样。现在使用mavenDescriptor将改变根文件中的版本。此外，如果项目包含带有pom文件的子模块，其中包含一个版本，它也会更改它们。
然而，有时候，一些子模块应该使用不同的发布版本。例如，假设有一个模块的版本应该更改为1.0.1，而不是1.0.0。其他模块的版本仍然应该更改为1.0.0。以下是如何做到这一点:
描述符。the.group.id: the.artifact setVersion”。id”、“1.0.1”
上面的setVersion方法接收两个参数:模块名称和它的新发布版本。模块名由组ID和工件ID组成，它们之间有一个冒号。
现在您可以转换pom文件以包含新版本:
descriptor.transform ()
转换方法更改了本地pom文件上的版本。
您现在可以构建代码并将发布Maven构件部署到Artifactory，如使用Artifactory构建Maven部分。
下一步是将对pom文件所做的更改提交到源代码管理系统，并在源代码管理存储库中标记新的发布版本。如果您正在使用git，可以使用安装在构建代理上的git客户端，并在Pipeline脚本中运行一些shell命令来完成此操作。
您可能最不想做的事情是将pom文件版本更改为下一个开发版本并提交更改。您可以通过使用mavenDescriptor实例再次执行此操作。
使用Artifactory构建Python
Python构建可以解析依赖关系、部署构件并向Artifactory发布构建信息。要使用Artifactory运行Python构建，请遵循以下步骤，以确保您的Jenkins代理已准备就绪:
- 确保Python已安装在生成代理上，并且python命令在PATH中。
- 安装皮普。你可以使用皮普的文档也使用pip和虚拟环境安装软件包。
- 确保轮和setuptools安装。你可以使用安装软件包文档。
- 通过从终端运行以下命令来验证构建代理是否准备就绪:
输出Python版本:> Python——version输出pip版本:> pip——version检查wheel是否安装:> wheel -h检查setuptools是否安装:> pip show setuptools检查虚拟环境是否激活:> echo $VIRTUAL_ENV
在您的Pipeline脚本中，首先需要创建一个Artifactory服务器实例，如创建人工服务器实例部分。
这里有一个例子:
defserver = Artifactory。服务器“my-server-id”
下一步是在Pip Build实例中创建一个Artifactory:
defrtpip = Artifactory.newPipBuild()
现在让我们定义构建应该从哪里下载它的依赖项。我们设置之前创建的Artifactory服务器实例和解析器上的存储库名称:
rtPip。解析器repo: 'pypi-virtual'， server: server
通常建议在虚拟环境中运行pip命令，以实现pip构建的隔离。为了遵循这个建议，创建一个shell命令来设置一个虚拟环境。让我们把这个shell命令保存在一个变量中，我们很快就会用到:
def virtual_env_activation = "source /Users/myUser/venv-example/bin/activate"
现在我们可以像下面这样下载项目的依赖项:
defbuildinfo = rtPip。安装参数:"-r python-example/requirements.txt"， envActivation: virtual_env_activation
你需要调整的值arg游戏参数，以匹配您的Python项目。的值发送了用于激活虚拟env的命令envActivation论点。这个参数是可选的。
上面的方法返回abuildInfo实例。如果我们已经有了一个想要重用的buildInfo实例，我们可以将buildInfo作为参数发送，如下所示。读了将构建信息发布到Artifactory节获取更多详细信息。
rtPip。安装buildInfo: buildInfo, args: "-r python-example/requirements.txt"， envActivation: virtual_env_activation
Jenkins在这一步的执行过程中生成一个新的java进程。
可以选择将任何java参数传递给这个新进程，方法是传递javaArgs论点:
defbuildinfo = rtPip。安装args: "-r python-example/ requests .txt"， javargs: '-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005'
在大多数情况下，您的构建还会生成工件。生成的工件可以使用server.upload方法中描述的上传和下载文件节。
中所描述的，现在可以将构建信息发布到Artifactory将构建信息发布到Artifactory部分
例子
强烈建议使用这些在设置您的第一个PIP构建时，作为参考的示例项目。
NuGet和。net核心构建与Artifactory
Artifactory Plugin与NuGet和。net Core客户端的集成允许构建解析依赖、部署工件和向Artifactory发布构建信息。
根据您想要使用的客户端，请确保nuget或dotnet客户端包含在构建代理的PATH中。
要从您的Pipeline脚本中使用Artifactory运行NuGet或.NET Core构建，首先需要创建一个Artifactory服务器实例，如创建人工服务器实例部分。
这里有一个例子:
defserver = Artifactory。服务器“my-server-id”
下一步是创建一个NuGet或。net Core Build实例:
def rtBuild = Artifactory.newDotnetBuild() //或者def rtBuild = Artifactory.newNugetBuild()
默认情况下，构建使用NuGet API协议v2。如果您想使用v3，请在构建实例上设置它，如下所示。
rtBuild。setApiProtocol v3的
现在让我们定义构建应该从哪里下载它的依赖项。我们设置之前创建的Artifactory服务器实例和解析器上的存储库名称:
rtBuild。解析器repo: 'nuget-remote'，服务器:server
现在我们可以下载项目的NuGet依赖，使用NuGet或。net Core客户端:
defbuildinfo = rtBuild.run args: 'restore ./src/GraphQL.sln'
上面的方法返回abuildInfo实例。如果我们已经有了一个想要重用的buildInfo实例，我们可以将buildInfo作为参数发送，如下所示。读了将构建信息发布到Artifactory节获取更多详细信息。
rtBuild.run buildInfo: buildInfo, args: 'restore ./src/GraphQL.sln'
您还可以选择自定义与此构建相关联的构建信息模块名称。你可以这样做:
defbuildinfo = rtBuild.run args: 'restore ./src/GraphQL.sln', module: 'my-build-info-module-name'
Jenkins在这一步的执行过程中生成一个新的java进程。
可以选择将任何java参数传递给这个新进程，方法是传递javaArgs论点:
defbuildinfo = rtBuild.run args: 'restore ./src/GraphQL.sln', javaArgs: '-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005'
在大多数情况下，您的构建还会生成工件。工件可以是NuGet包、DLL文件或任何其他类型的工件。生成的工件可以使用server.upload方法中描述的上传和下载文件节。
中所描述的，现在可以将构建信息发布到Artifactory将构建信息发布到Artifactory部分
使用Artifactory构建NPM
NPM构建可以解析依赖关系、部署构件并向Artifactory发布构建信息。要从Pipeline脚本中使用Artifactory运行NPM构建，首先需要创建一个Artifactory服务器实例，如创建人工服务器实例部分。
这里有一个例子:
defserver = Artifactory。服务器“my-server-id”
下一步是创建一个人工的NPM构建实例:
def rtNpm = Artifactory.newNpmBuild()
现在让我们定义NPM构建应该从哪里下载它的依赖项。我们设置之前创建的Artifactory服务器实例和解析器上的存储库名称:
rtNpm。解析器服务器:server, repo: 'npm-virtual'
构建使用npm可执行文件来安装(下载依赖)和发布。默认情况下，Jenkins使用代理的PATH中的npm可执行文件。你也可以引用Jenkins中定义的工具，并设置脚本使用它，如下所示:
//设置Jenkins配置rtNpm中定义的工具名称。tool = 'nodejs-tool-name' // or set the tool as an environment variable env.NODEJS_HOME = "${tool 'nodejs-tool-name'}" // or set a path to the NodeJS home directory (not the npm executable) env.NODEJS_HOME = 'full/path/to/the/nodeJS/home' // or nodejs(nodeJSInstallationName: 'nodejs-tool-name') { // Only in this code scope, the npm defined by 'nodejs-tool-name' is used. }
现在我们可以下载项目的npm依赖项了。下面的方法运行npm安装幕后:
defbuildinfo = rtNpm。安装路径:'npm-example'
你也可以像下面这样添加npm标志或参数:
defbuildinfo = rtNpm。安装路径:'npm-example'，参数:'——verbose'
的npm ci命令也支持相同的方式:
defbuildinfo = rtNpm。Ci路径:'npm-example'
上述方法返回一个buildInfo实例。如果我们已经有了一个想要重用的buildInfo实例，我们可以将buildInfo作为参数发送，如下所示。读了将构建信息发布到Artifactory节获取更多详细信息。
rtNpm。安装路径:'npm-example'， buildInfo: my-build-info
您还可以选择自定义与此构建相关联的构建信息模块名称。你可以这样做:
defbuildinfo = rtNpm。安装路径:'npm-example'，模块:'my-build-info-module-name'
Jenkins在这一步的执行过程中生成一个新的java进程。
你可以选择传递任何java参数给这个新进程，通过传递javaArgs参数:
defbuildinfo = rtNpm。安装路径:'npm-example'， javaArgs: '-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005'
将NPM包发布到Artifactory的操作非常相似。我们从定义部署器开始:
rtNpm.deployer server: server, repo: 'npm-local'
下面的方法将做两件事:打包代码(通过运行npm pack)并将其发布到Artifactory;
defbuildinfo = rtNpm。发布路径:'npm-example'
与install方法类似，还支持以下方法:
rtNpm。发布路径:'npm-example'， buildInfo: my-build-info
您还可以选择自定义与此操作相关联的构建信息模块名称。你可以这样做:
defbuildinfo = rtNpm。发布路径:'npm-example'，模块:'my-build-info-module-name'
Jenkins在这一步的执行过程中生成一个新的java进程。
你可以选择传递任何java参数给这个新进程，通过传递javaArgs参数:
defbuildinfo = rtNpm。发布路径:'npm-example'， javaArgs: '-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005'
中所描述的，现在可以将构建信息发布到Artifactory将构建信息发布到Artifactory部分
使用Artifactory进行构建
在构建Go项目时，Jenkins可以解析依赖关系，部署工件并将构建信息发布到Artifactory。
请确保go客户端包含在构建代理的PATH中。
要从您的Pipeline脚本运行带有Artifactory的Go构建，您首先需要创建一个Artifactory服务器实例，如创建人工服务器实例部分。
这里有一个例子:
defserver = Artifactory。服务器“my-server-id”
下一步是创建一个Artifactory Go Build实例:
defrtgo = Artifactory.newGoBuild()
现在让我们定义Go构建应该从哪里下载它的依赖项。我们设置之前创建的Artifactory服务器实例和解析器上的存储库名称:
rtGo。解析器服务器:server, repo: 'go-virtual'
现在让我们构建项目。我们是这样做的:
defbuildinfo = rtGo.run path: 'path/to/ project/root'， args: 'build'
请确保go客户端包含在构建代理的PATH中。
上面的方法返回一个buildInfo实例。如果我们已经有了一个想要重用的buildInfo实例，我们可以将buildInfo作为参数发送，如下所示。读了将构建信息发布到Artifactory节获取更多详细信息。
rtGo.run path: 'path/to/the/project/root'， args: 'build'， buildInfo: my-build-info
您还可以选择自定义与此构建相关联的构建信息模块名称。你可以这样做:
defbuildinfo = rtGo.run path: 'path/to/the/project/root'， args: 'build'， module: 'my-build-info-module-name'
现在项目已经构建完成，您可以打包并将其作为Go包发布到Artifactory。我们从定义部署器开始:
rtGo.deployer server: server, repo: 'go-local'
下面的方法将做两件事:打包代码并将其发布到Artifactory;
defbuildinfo = rtGo。发布路径:'golang-example/hello'，版本:'1.0.0'
如果你已经配置了一个buildInfo实例，你可以像下面这样把它作为参数传递:
rtGo。发布buildInfo: buildInfo，路径:'path/to/ project/root'，版本:'1.0.0'
您还可以选择自定义与此构建相关联的构建信息模块名称。你可以这样做:
defbuildinfo = rtGo。发布路径:'path/to/the/project/root'，版本:'1.0.0'，模块:'my-build-info-module-name'
中所描述的，现在可以将构建信息发布到Artifactory将构建信息发布到Artifactory部分
柯南和Artifactory一起建造
柯南是一个C/ c++包管理器。Artifactory Pipeline DSL包括一些api，这些api使您可以使用安装在构建代理上的Conan Client轻松运行Conan构建。在使用Jenkins创建你的第一个柯南构建工作之前，你需要做的是:
1、在Jenkins构建代理上安装最新的柯南客户端。请参阅柯南的文档有关安装说明。
2.将Conan Client可执行文件添加到构建代理的PATH环境变量中，以确保Jenkins能够使用该客户端。
3.中所描述的在Artifactory中创建一个Conan存储库柯南存储库Artifactory文档。
好的。让我们开始编写第一个柯南管道脚本。
我们将从创建Artifactory服务器实例开始，如本文开头所述。
这里有一个例子:
defserver = Artifactory。服务器“my-server-id”
现在让我们创建一个Conan Client实例
def conanClient = Artifactory.newConanClient()
在创建Conan客户端时，您还可以指定Conan用户的主目录，如下所示:
defconanclient = Artifactory。newConanClient userHome: "conan/my-conan-user-home"
现在，我们可以通过向新的conanClient实例添加一个Artifactory存储库来配置它。在我们的例子中，我们正在添加“conan-local”存储库，位于Artifactory服务器中，由我们获得的服务器实例引用:
String remoteName = conanClient.remote.add server: server, repo: "conan-local" |
上述方法还接受以下可选参数:
力:真-添加这个参数将使柯南客户端不这样做引发错误。如果存在具有所提供名称的现有远程。
verifySSL:假-添加此参数将使conan客户端跳过SSL证书的验证。
正如您在上面的示例中所看到的，conanClient.remote.add方法返回字符串变量-remoteName。这个“remoteName”变量是什么?这是干什么用的?
好吧，“柯南远程”是一个存储库，它可以用来下载依赖项并上传工件。当我们将“柯南本地”人工存储库添加到柯南客户端时，我们实际上添加了一个柯南远程。'remoteName'变量包含我们添加的新柯南远程的名称。
好的。我们已经准备好开始运行柯南命令了。您需要熟悉Conan命令语法，它由Conan Client公开以运行命令。中的命令语法柯南的文档。
让我们运行第一个命令:
defbuildinfo1 = conanClient.run命令:"install——build missing" |
'conanClient.run'方法返回一个buildInfo实例，稍后我们可以将其发布到Artifactory。如果你已经有了一个buildInfo实例，并且你想让conanClient.run方法将build-info聚合到它上面，你也可以将buildInfo实例发送给run命令作为参数，如下所示:
conanClient.run命令:“install——build missing”，buildInfo: buildInfo |
接下来我们要做的是使用我们创建的柯南遥控器。比如，我们把藏物上传到柯南遥控器。注意，在构建Conan命令时，我们是如何使用前面得到的“remoteName”变量的:
字符串命令= "upload *——all -r ${remoteName}——confirm" |
我们现在可以将buildInfo发布到Artifactory，如将构建信息发布到Artifactory部分。例如:
服务器。publishBuildInfo buildInfo |
Docker使用Artifactory构建
一般
Jenkins Artifactory插件支持管道DSL，允许收集和发布构建信息到Artifactory。要设置Jenkins构建代理来收集Docker构建的构建信息，请参考设置说明。
直接使用Docker守护进程
Jenkins Artifactory Plugin支持通过其REST API直接与docker守护进程一起工作。请确保设置Jenkins与docker和artifacts一起工作，就像上一节提到的那样。
//创建Artifactory服务器实例，如本文所述:server 'my-server-id' //创建一个Artifactory Docker实例实例存储Artifactory凭据和Docker守护进程主机地址。//如果未指定docker守护进程所在主机，则“/var/run/docker. conf”使用“Sock”作为默认值(在这种情况下不应指定host参数)。defrtdocker = Artifactory。docker server: server, host: "tcp://: " // Jenkins在这一步的执行过程中生成一个新的java进程。//当创建rtDocker实例时，你可以选择将任何java参数传递给这个新进程。// defrtdocker = Artifactory。docker server: server, javaArgs: '-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005' //从Artifactory获取docker镜像。defbuildinfo = rtDocker。pull ' /hello-world:latest', ' ' // If you already have a buildInfo instance, you can pass it as an argument to the rtDocker.pull method as follows: // rtDocker.pull ' /hello-world:latest', ' ', buildInfo // Attach custom properties to the published artifacts: rtDocker.addProperty("project-name", "docker1").addProperty("status", "stable") // Push a docker image to Artifactory (here we're pushing hello-world:latest). The push method also expects // Artifactory repository name ( ). // Please make sure that is configured to reference the Artifactory repository. In case it references a different repository, your build will fail with "Could not find manifest.json in Artifactory..." following the push. def buildInfo = rtDocker.push ' /hello-world:latest', ' ' // If you already have a buildInfo instance, you can pass it as an argument to the rtDocker.push method as follows: // rtDocker.push ' /hello-world:latest', ' ', buildInfo // Publish the build-info to Artifactory: server.publishBuildInfo buildInfo
使用Kaniko
的rtDocker.createDockerBuild方法允许收集发布到Artifactory的docker映像的构建信息Kaniko。看到我们在GitHub上的kaniko项目示例去学习怎么做。
使用臂
的rtDocker.createDockerBuild方法允许收集发布到Artifactory的docker映像的构建信息t他JIB Maven插件。看到我们在GitHub上的maven-jib示例去学习怎么做。由于此示例还使用Artifactory管道api运行maven，因此我们还建议参考使用Artifactory构建Maven节包含在本文档页面中。
扫描构建与JFrog x射线
从版本2.9.0开始，Jenkins Artifactory插件通过JFrog Artifactory与JFrog Xray集成，允许您扫描构建工件的漏洞和其他问题。如果发现问题或漏洞，您可以选择使构建作业失败或根据您编写的Pipeline脚本执行其他操作。这种集成需要JFrog Artifactory v4.16在这之上JFrog Xray v1.6及以上。
您可以扫描已发布到Artifactory的任何构建版本。何时发布构建并不重要，只要它在触发JFrog x射线扫描之前发布即可。
以下说明向您展示如何配置Pipeline脚本以扫描构建。
首先，为了让Xray扫描构建，您需要配置一个看使用正确的过滤器指定哪些工件和漏洞应该触发警报，并为该监视设置失败构建作业操作。您可以阅读更多关于使用Xray进行CI/CD集成的信息在这里。
现在你可以配置你的Jenkins Pipeline作业来扫描构建。首先创建一个scanConfig实例，其中包含要扫描的构建名称和构建号:
def scanConfig = ['buildName': 'my-build-name'， 'buildNumber': '17'， //仅当此构建与Artifactory中的项目相关联时，设置项目关键字如下。'project': 'my-project-key']
如果您正在扫描已经在同一作业中发布到Artifactory的构建，那么您可以使用存储在用于发布构建的buildInfo实例上的构建名称和构建号。例如:
服务器。publishBuildInfo buildInfo def scanConfig = ['buildName': buildInfo.name， 'buildNumber': buildInfo.name]。//只有当此构建与Artifactory中的项目相关联时，才能按如下方式设置项目键。“项目”。: 'my-project-key']
在你触发扫描之前，还有一件事你需要知道。默认情况下，如果x射线扫描在构建中发现触发警报的漏洞或问题，则构建作业将失败。如果你不希望构建任务失败，你可以将failBuild属性添加到scanConfig实例中，并将其设置为false，如下所示:
def scanConfig = ['buildName': buildInfo.name， 'buildNumber': buildInfo.name]。//只有当此构建与Artifactory中的项目相关联时，才能按如下方式设置项目键。'project': 'my-project-key'， 'failBuild': false]
好了，我们准备开始扫描了。扫描应该在发布构建的同一Artifactory服务器实例上启动:
def scanResult =服务器。xrayScan scanConfig
就是这样。构建现在将被扫描。如果没有将扫描配置为使构建作业失败，则可以使用从xrayScan方法返回的scanResult实例来查看有关扫描的一些详细信息。
例如，要将结果打印到日志中，可以使用以下代码片段:
echo scanResult as String
有关与JFrog Xray和JFrog Artifactory集成以扫描构建中的问题和漏洞的更多详细信息，请参考CI / CD集成在JFrog Xray文档中。
管理发布包
一般
Jenkins Artifactory Plugin提供了一组用于管理和分发发布包的管道api。这些api需要2.0或更高版本的JFrog分布。这些api使用JFrog Distribution的REST端点，而不是Artifactory REST端点。因此，建议通过以下方式验证是否可以从Jenkins访问JFrog发行版詹金斯|管理|配置系统。本节中所有示例中的serverId值都应该替换为您配置的JFrog平台ID。
为了更容易地开始使用JFrog分发管道api，您可以使用jfrog-distribution-example可用在这里。
要使用这些api，首先需要使用中配置的ID获取一个分布实例詹金斯|管理|配置系统。你应该这样做。
defjfroginstance = JFrog。实例'jfrog-instance-1' def dsServer = jfrogInstance.distribution
创建和更新发布包
的createReleaseBundle和updateReleaseBundle方法在JFrog发行版上创建和更新一个发布包。这些方法接受要创建的发布包名称和发布包版本。方法也接受文件规范，它定义了Artifactory中要绑定到发布包中的文件。让我们按照如下方式开始创建文件规范。
def文件规范= " "{"文件":[{“模式”:“libs-repo /释放/ * . zip”}]}“”“
现在我们按如下方式创建发布包。
dsServer。createReleaseBundle名称:'release-bundle-1'，版本:'1.0.0'，规格:fileSoec
上面的createReleaseBundle方法支持如下所示的其他可选参数。
dsServer。createReleaseBundle version: '1.0.0'， spec: fileSoec //默认为"plain_text"。发行说明的语法。可以是'markdown'， 'asciidoc'或'plain_text'之一。releaseNotesSyntax: "markdown"， //可选。如果设置为true，则自动签署发布包版本。signimmediate: true， //可选。描述发布包版本的发布说明的文件路径。releaseNotesPath: "path/to/release-notes"， //可选。签名密钥的密码短语。 gpgPassphrase: "abc", // Optional. A repository name at the source Artifactory instance, to store release bundle artifacts in. If not provided, Artifactory will use the default one. storingRepo: "release-bundles-1", // Optional. description: "Some desc", // Optional. Path to a file with the File Spec content. specPath: "path/to/filespec.json", // Optional. Set to true to disable communication with JFrog Distribution. dryRun: true
的updateReleaseBundle方法接受与createReleaseBundle方法。
签署发布包
发布包必须在发布之前进行签名。以下是签署发布包的方法。
dsServer。createReleaseBundle name: "example-release-bundle"， version: "1"， //可选GPG passphrase gpgPassphrase: "abc"， //可选源Artifactory实例的存储库名称，用于存储发布包中的工件。如果没有提供，Artifactory将使用默认的。storingRepo:“release-bundles-1”
发布发布包
为了更好地控制将发布包分发到哪里，您可以像下面这样定义分发规则。
def规则= " "{“distribution_rules”:[{”:域名”:“*”,“city_name”:“*”,“country_code ": ["*"] } ] }"""
在确保发布包被签名之后，通过可选地使用分发规则，您可以按如下方式分发它。
dsServer。createReleaseBundle name: "example-release-bundle"， version: "1"， //可选发布规则distRules: rules， //可选国家代码。不能与'distRules'一起使用countryCodes:["001"， "002"] //可选站点名称。siteName: "my-site"， //可选城市名。不能与'distRules'一起使用cityName: "New York"， //可选。如果设置为true，则只有在分发完成后才返回响应。sync: true， //可选。设置为true将禁用与JFrog Distribution的通信。dryRun:真
删除发布包
下面是删除发布包的方法。
dsserver . deleterreleasebundle name: "example-release-bundle"， version: "1"， //可选发布规则distRules: rules， //可选国家代码。不能与'distRules'一起使用countryCodes:["001"， "002"] //可选站点名称。siteName: "my-site"， //可选城市名。不能与'distRules'一起使用cityName: "New York"， //可选。如果设置为true，则只有在删除完成后才返回响应。sync: true， //可选。设置为true将禁用与JFrog Distribution的通信。dryRun:真
建立触发器
的Artifactory触发允许在特定Artifactory路径中添加或修改文件时自动触发Jenkins作业。触发器定期轮询Artifactory以检查是否应该触发作业。你可以读到更多在这里。
您可以选择在管道中定义Artifactory Trigger。你应该这样做:
如本文开头所述，首先创建一个Artifactory服务器实例。
这里有一个例子:
defserver = Artifactory。服务器“my-server-id”
接下来，设置触发器如下:
服务器。setBuildTrigger规格:"*/10 * * * *"，路径:"generic-lib -local/builds/starship"
在部署到Artifactory后触发作业时，您可以在Artifactory中获得触发该作业的文件的URL。你是这样得到它的:
def url = currentBuild.getBuildCauses('org.jfrog.hudson.trigger.ArtifactoryCause')[0]
如果触发作业的原因不同，则url值为空。
