JIRA-每日任务自动化指南-全-

JIRA 每日任务自动化指南（全）

原文：annas-archive.org/md5/e458a739b164bdaa4b2329a26b296064

译者：飞龙

协议：CC BY-NC-SA 4.0

前言

Jira 最初是作为开发人员跟踪软件中的错误的工具开始的，经过多年的发展，它已经演变成一个强大的项目管理平台，允许组织在多个团队之间以及跨软件、服务管理和业务项目之间进行计划、管理和跟踪工作。

随着时间的推移，这使得团队能够跟上他们的项目进度；然而，这也带来了管理上的开销，用户必须不断执行简单而重复的任务，以确保 Jira 问题与正在执行的工作保持相关。

2019 年底，Atlassian 收购了 Automation for Jira，一款让用户无需编写代码即可自动化 Jira 中任务的应用程序。此功能随后被集成到 Jira Cloud 中，作为本地功能提供，同时仍作为可选附加组件，供服务器版 Jira 产品的用户使用。

本书是一本实践指南，适用于高级用户和 Jira 管理员，帮助他们使用 Jira 系列产品（包括 Jira 软件、Jira 服务管理和 Jira Core）以无代码方式自动化日常、重复和繁琐的任务。

本书适用对象

本书面向 Jira 管理员和项目经理，他们希望了解 Jira 中提供的自动化功能。要求读者对 Jira 有一定的了解，并具备一定的 Jira 管理概念知识，包括工作流和项目配置。

本书内容

第一章，自动化的关键概念，向你介绍 Jira 自动化规则的关键概念。我们将探索规则的基本构成部分，以及典型规则的样子。到本章结束时，你将理解自动化规则的工作原理，以及如何创建你的第一个规则。

第二章，自动化 Jira 问题，探讨了条件如何用于缩小自动化规则的适用范围，以及如何针对和处理相关问题，如子任务和关联问题。我们还将学习如何编辑和转换问题，如何使用高级字段编辑器。最后，你将学习如何按设定的时间间隔调度任务，所有这些都通过为每个主题提供的实际示例来帮助你理解。

第三章，使用智能值增强规则，讲述了智能值以及它们如何使你能够为自动化增加显著的力量和复杂性。我们将学习如何操作和格式化文本字符串、日期和时间，以及值列表，最后，还会介绍可以使用的强大数学表达式。

第四章，发送自动化通知，解释了如何使用自动化规则发送通知。你将学习如何向客户发送电子邮件通知，以及如何借助每个主题中涉及的实际用例，集成到包括 Slack 和 Microsoft Teams 在内的外部聊天系统中。

第五章，与外部系统协作，解释了如何使用自动化规则向外部系统发送请求以及如何处理这些系统返回的数据。我们还将学习如何使用自动化规则创建入站 Webhook，以接收来自外部系统的请求，并如何处理接收到的数据。

第六章，自动化 Jira 服务管理，解释了如何使用自动化规则来处理并自动将来请求路由到服务管理项目。我们还将学习如何监控服务请求的 SLA 合规性，最后，了解如何实现常见任务的端到端完全自动化。

第七章，自动化 Jira 软件项目，探讨了针对 Jira 软件项目的多种自动化方法。你将通过一些实际例子了解如何自动化开发人员在日常工作中常遇到的重复性任务，如保持多个项目之间的版本同步，并确保为任务和故事创建正确的子任务。

第八章，与 DevOps 工具集成，解释了如何使用自动化与 GitHub 和 Bitbucket 等工具进行集成。我们将发现如何在这些工具中的事件触发时，自动转换与之相关的 Scrum 看板上的问题，并通知相关方更新。我们还将探讨如何在 Sprint 完成时启动构建工具中的部署。

第九章，最佳实践，介绍了编写自动化规则时应遵循的一些最佳实践。特别是，我们将探讨如何规划和组织规则，并了解如何确保你的规则不会对性能产生负面影响。

第十章，故障排除技巧与方法，重点介绍了故障排除技术。我们将探讨调试规则和解决常见问题的技巧。我们还将了解服务限制及如何监控和维护它们，最后，我们将审视自动化性能洞察以及如何利用它们来微调规则。

第十一章，超越自动化：脚本入门，为你介绍了 Jira 最受欢迎的脚本插件之一，并通过一个先前的示例将其与自动化规则进行比较，以便我们可以比较 Jira Cloud 和 Jira Server 中无代码自动化规则与脚本的区别。

为了最大限度地发挥本书的价值

你至少需要拥有一个免费的 Atlassian 账户，并且能够访问 Jira Cloud 上的 Jira Software 和 Jira Service Management。或者，你需要安装最新版本的 Jira Server/Jira Data Center 和 Automation for Jira。所有示例都已在 Jira Cloud 和 Jira Server 上进行测试：

如果你使用的是本书的电子版本，建议你亲自输入代码或通过 GitHub 仓库访问代码（链接在下一节提供）。这样可以帮助你避免由于复制粘贴代码而导致的潜在错误。

如果你还没有这样做，应该在 https://community.atlassian.com 注册 Atlassian 社区账户。这里聚集了来自世界各地的 Atlassian 用户，你可以在这里提问或参与讨论，并获得关于任何 Atlassian 相关话题（包括自动化）的答案。

下载示例代码文件

你可以从 GitHub 上下载本书的示例代码文件，链接地址是 https://github.com/PacktPublishing/Automate-Everyday-Tasks-in-Jira。如果代码有更新，它将在现有的 GitHub 仓库中进行更新。

我们还提供了其他代码包，这些代码包来自我们丰富的书籍和视频目录，可以在 https://github.com/PacktPublishing/ 上找到。快去看看吧！

Code in Action

本书的《Code in Action》视频可以在 http://bit.ly/3spHl2T 上观看。

下载彩色图像

我们还提供了一份 PDF 文件，包含本书中使用的屏幕截图/图表的彩色图像。你可以在这里下载： https://static.packt-cdn.com/downloads/9781800562868_ColorImages.pdf。

使用的约定

本书中使用了一些文本约定。

文本中的代码：表示文本中的代码词汇、数据库表名、文件夹名、文件名、文件扩展名、路径名、虚拟 URL、用户输入和 Twitter 账号。例如：“设置 {{now.withDayOfMonth(15)}} 然后点击 保存。”

一块代码的设置如下：

{
    "summary": "some summary text",
    "bugDescription": "some descriptive text",
    "softwareVersion": "version string"
}

当我们希望将注意力集中在代码块的某个特定部分时，相关的行或项会以粗体显示：

{
    "type": "page",
    "title": "Version {{version.name.jsonEncode}}",
    "space": {

任何命令行输入或输出都将如下所示：

$displayName = "Service Desk Autobot"; $objectId = (Get-AzureADServicePrincipal -SearchString $displayName).ObjectId
$roleName = "Company Administrator"; $role = Get-AzureADDirectoryRole | Where-Object {$_.DisplayName -eq $roleName}

粗体：表示新术语、重要词汇，或在屏幕上看到的词汇。例如，菜单或对话框中的词汇在文本中会以这种方式出现。示例：“选择新建操作，然后选择发送电子邮件，并按照以下字段填写，最后点击保存。”

提示或重要说明

如此显示。

联系我们

我们始终欢迎读者的反馈。

一般反馈：如果您对本书的任何内容有疑问，请在邮件主题中注明书名，并通过电子邮件联系我们：customercare@packtpub.com。

勘误：虽然我们已尽最大努力确保内容的准确性，但错误仍然可能发生。如果您发现本书中的错误，我们将非常感激您向我们报告。请访问www.packtpub.com/support/errata，选择您的书籍，点击“勘误提交表格”链接并填写相关细节。

盗版：如果您在互联网上发现任何我们作品的非法副本，无论形式如何，我们将非常感激您提供相关的地址或网站名称。请通过 copyright@packt.com 与我们联系，并附上相关链接。

如果您有兴趣成为作者：如果您在某个领域拥有专长，并且有兴趣撰写或参与书籍的编写，请访问authors.packtpub.com。

评论

请留下评论。一旦您阅读并使用了本书，为什么不在您购买书籍的网站上留下评论呢？潜在读者可以看到并利用您的公正意见来做出购买决策，我们 Packt 公司也能了解您对我们产品的看法，而我们的作者也能看到您对他们书籍的反馈。谢谢！

欲了解更多关于 Packt 的信息，请访问packt.com。

第一部分：入门 – 基础知识

在本节中，您将了解自动化规则，并学习定义和管理规则的最佳实践。

本节包括以下章节：

• 第一章，自动化的关键概念

• 第二章，自动化 Jira 问题

第一章：第一章: 自动化的关键概念

Atlassian Jira 是一个流行的工作流管理系统，允许团队在各种场景中跟踪工作，其中最常见的是软件项目，其次是服务台。随着时间的推移，大多数团队都会意识到，存在许多重复且耗时的任务，这些任务需要执行以确保项目任务和请求能够准确及时地进行跟踪。

由于 Atlassian 最近收购了Jira 自动化并将其作为 Jira Cloud 的原生功能集成，现在使用直观的if-this-then-that方法，甚至不需要编写任何代码，就能更轻松地创建复杂且强大的自动化规则。Jira 自动化仍然可以作为 Jira Server 和 Jira Data Center 的附加应用使用，我们将在本书中讲解两者的不同应用场景。

如果你像我一样，在面对 Jira 中的另一个单调且耗时的任务时，会不由自主地说出我相信我们一定可以找到一种方法来自动化这个任务，那么你选对书了。

在本章中，我们将涵盖以下主要主题：

• 开始使用规则

• 使用触发器

• 使用条件

• 使用操作

• 创建你的第一个规则

到本章结束时，你将对 Jira 中的自动化规则的关键概念有一个清晰的理解，了解规则的各个组件如何协作，使你能够编写规则，帮助你自动化 Jira 中的任何重复性和耗时任务，从而能专注于真正重要的事情：完成任务！

技术要求

本章的要求如下：

• Jira Cloud 环境：如果你还没有 Jira 账户，可以在www.atlassian.com/software/jira/free创建一个免费的 Jira Cloud 账户，并确保你选择了 Jira Software 和 Jira Service Management；或者

• Jira Server 环境：如果你使用的是 Jira Server（可以在www.atlassian.com/software/jira/download下载），请确保你已获得 Jira Software 和 Jira Service Management 的许可证。此外，你还需要确保安装了来自 Atlassian Marketplace 的Automation for Jira应用。

在这两种情况下，你都需要至少拥有 Jira 项目的项目管理员权限。

你可以从本书的官方 GitHub 仓库下载本章的最新代码示例，链接为github.com/PacktPublishing/Automate-Everyday-Tasks-in-Jira。

本章的 Code in Action 视频可以在bit.ly/38POLVA观看

开始使用规则

要理解自动化，我们首先需要了解与之相关的一些基本概念，其中最重要的就是规则。

在本节中，我们将讨论以下概念：

• 规则的定义

• 规则作用域

• 所有者和参与者

• 审计日志

这些将为我们在接下来的章节中构建奠定基础，那么不再拖延，开始吧。

什么是规则？

一个规则，在其基本形式下，是一系列步骤，按特定顺序执行，以实现一个既可重复又可审计的预期结果。

通过这点，我们的意思是，规则应该在每次执行时都具有完全相同的结果，并且我们应该能够按时间顺序检查规则所应用的操作。

具体来说，Jira 中的规则允许你根据你设定的标准对问题执行操作。

每个规则由三个基本组件组成：

• 触发器：规则的入口点。

• 条件：这些精炼了规则的标准。

• 操作：这些执行实际任务。

除了这些，规则还包含一些其他基本信息：

• 规则名称

• 规则描述

• 规则作用域

• 规则所有者和参与者

• 在规则失败时通知规则所有者的选项

• 允许其他规则触发此规则的选项

• 规则审计日志

这些组件共同构成了自动化规则的构建块。通过将这些基本组件结合起来，你可以创建用于自动化许多耗时和重复任务的规则。

下图展示了 Jira 中规则的基本组件概述：

图 1.1 – 可视化规则的基本组件

我们将在本章和下一章中更详细地讨论这些组件。

理解作用域

Jira 中的规则可以应用于四个作用域中的一个：

• 全局规则

• 跨项目规则

• 项目类型特定规则

• 项目特定规则

下表展示了这些规则作用域是如何定义的，并且为了创建和管理在该作用域中应用的规则，需要哪些 Jira 权限：

图 1.2 – 规则作用域权限

正如我们所看到的，大多数规则作用域需要你拥有 Jira 全局管理员权限才能管理它们，这是预期的，因为这些规则跨越多个项目，因此不能仅依赖于项目特定权限。

另一方面，项目规则除了 Jira 全局管理员外，还可以由项目管理员创建和管理。

这种区分使得 Jira 管理员可以委托项目特定的自动化规则，同时给予项目管理员在管理自己项目规则时更大的灵活性，而 Jira 全局管理员则可以专注于可以应用于更广泛受众的自动化规则。

规则也可以由 Jira 管理员在全局范围和项目范围之间移动。例如，如果确定某个项目特定的规则可以在多个项目中重用，Jira 管理员可以调整规则的范围。反之亦然，如果某个全局规则仅由单个项目使用，Jira 管理员可以将其范围调整为该特定项目，从而将规则的管理权限转交给项目管理员。

所有者和执行者

每个规则都需要一个所有者和一个执行者。

规则的所有者通常是创建规则的用户，负责维护该规则。如果规则在执行时失败，规则所有者还将收到来自 Jira 的电子邮件通知。

规则执行者是规则将以其身份执行的用户。此用户必须在项目中具有正确的权限，才能执行触发器和规则将执行的任何操作。例如，如果你创建一个需要向问题添加评论的规则，则规则执行者需要在项目中拥有添加评论权限。

重要提示

在 Jira Cloud 中，默认的规则执行者始终是自动化应用用户，并且属于atlassian-addons-project-access项目角色。该项目角色被分配了项目中的所有权限，并可以在项目设置 | 权限部分进行更改。从该角色中移除权限可能会导致插件无法正常工作，因此通常建议不要更改这些权限。

审计日志

每个规则都有自己的审计日志，该日志按时间顺序跟踪规则的执行，并允许你检查每次执行的结果以及对受影响项应用的操作。

这个功能不仅是为了能够跟踪规则执行的结果；它还使我们能够在规则执行不如预期时进行调试。

我们将在第十章，故障排除技巧与方法中更详细地探讨审计日志在调试规则中的作用，当时我们将探索调试规则和解决常见问题的技巧。

使用触发器

每个规则的起点是一个触发器。触发器定义了规则如何激活，通常会监听 Jira 中的事件，比如当问题被创建或问题中的字段值发生变化时。

在本节中，我们将首先查看 Jira 事件，因为这将帮助你理解规则是何时和为什么被触发，然后我们将探索可用的规则触发器，它们是什么以及如何使用它们。

理解 Jira 事件

为了更好地理解触发器的工作原理，值得简要了解 Jira 中的事件是如何工作的，因为这些事件是大多数自动化规则中可用触发器的驱动力。

Jira 像许多应用程序一样，采用事件驱动架构。从本质上讲，这意味着每当在 Jira 中执行一个操作时，都会触发一个事件，允许相关组件监听并根据这些事件执行额外的操作。

有两种主要类型的事件会影响 Jira 中的问题。第一种是工作流事件。当一个问题被创建时，或者每当问题在其底层工作流中转换为新状态时，都会触发这些事件，负责在自动化规则中触发问题创建和问题过渡。

第二种类型的事件是问题事件，这些事件负责大部分其他问题触发器，并在用户（或应用程序）对问题进行非工作流相关的更改时触发，例如更新字段或将两个问题链接在一起。

规则触发器

Jira 自动化为我们提供了多个触发器，我们可以利用这些触发器来启动规则的执行。

这些触发器被分为不同类别，方便你在创建规则时识别需要的触发器类型，这些类别如下：

• 问题触发器

• DevOps 触发器

• 定时触发器

• 集成触发器

我们将依次查看每个类别及其可用的触发器。

问题触发器

正如我们在理解 Jira 事件部分中提到的，大多数触发器与问题发生的事件相关，例如问题被创建或编辑时。

大多数触发器都很容易理解且具有单一目的。然而，也有一些触发器可以进一步配置，使其更具体，而无需使用额外的条件。

让我们来看看在编写本文时可用的所有问题触发器以及每个触发器的作用：

• 字段值更改：当字段的值发生变化时，规则将会运行。你可以通过选择你希望监控的字段，或使用正则表达式来匹配你希望监控的字段名来配置此触发器。你还可以选择性地缩小哪些问题操作会触发规则。

• 问题指派：当问题的指派人发生变化时，规则将会运行。

• 问题评论：每当向问题添加新评论时，规则都会执行。请注意，这不包括编辑或删除评论的情况。

• 问题创建：每次创建问题时，规则将会执行。此触发器监听问题创建事件，这是工作流中的第一步。

• 问题删除：当一个问题被删除时，规则将会运行。

• 问题链接删除：当一个问题与另一个问题解除链接时，规则将会运行。你可以选择性地配置此触发器，仅在特定的链接类型上执行。

• 问题链接：当一个问题被链接到另一个问题时，规则将执行。和问题链接删除触发器一样，你可以选择性地配置触发器执行的链接类型。

• 问题移动：当问题从一个项目移动到另一个项目时，此规则将被执行。您还可以选择仅当问题从特定项目移动时触发该规则。

• 问题过渡：每次问题在工作流中从一个状态过渡到另一个状态时，此规则将被执行。您还可以选择配置此触发器以监听特定的过渡或多个过渡到或从特定状态。

• 问题更新：当问题的详情更新时（除非更改是通过关联、指派或记录工作完成的），此规则将被触发。

• SLA 阈值突破：当服务管理项目中的 SLA 阈值被突破或即将突破时，此规则会被触发。您可以配置要监控的 SLA，以及突破前后的时间。

• 工作记录：当创建、更新或删除工作日志时，此规则将被触发。

有一些值得注意的专用问题触发器，它们如下：

• 手动触发器：此触发器不依赖于任何底层事件。相反，这类触发器会出现在用户的问题视图中，并需要用户手动激活。

• 多个问题事件：此触发器允许您监听一个问题的多个事件。例如，当您需要在一个工单既被创建又被更新时执行相同的自动化，而不必为每个事件创建单独的规则时，这将非常有用。

• 冲刺和版本触发器：这些触发器与底层问题没有直接关联，而是允许您在包含的冲刺发生变化或与项目相关的版本被创建或更改时，对相关问题执行操作。

• 服务限制突破：这是一个专用触发器，允许您监控和管理自动化规则本身。

DevOps 触发器

DevOps 触发器是专门针对 Jira Cloud 设计的，它允许您创建与连接的开发工具中的事件（如 Bitbucket 和 GitHub）相关联的规则。

让我们快速看一下这些触发器及其作用：

• 分支创建：当连接的源代码库中创建一个分支时，此规则将被触发。

• 构建失败：当连接的构建工具中的构建失败时，此规则将被执行。您还可以选择将其配置为在特定的构建名称、分支或标签上触发。

• 构建状态变更：当连接的构建工具中的构建状态发生变化时，例如从失败变为成功，或反之时，此规则将被触发。您还可以选择将其配置为在特定的构建名称、分支或标签上触发。

• 构建成功：与前面的触发器类似，当连接的构建工具中的构建成功时，此规则将被执行。此规则也可以选择配置为监听特定的构建名称、分支或标签。

• 提交创建：当在连接的源代码库中创建提交时，此规则将执行。

• 部署失败：当在指定环境中的部署失败时，此规则将执行。

• 部署状态更改：当在指定环境中的部署状态从失败变为成功，或反之时，此规则将执行。

• 部署成功：当在指定环境中进行的部署成功时，此规则将执行。

• 拉取请求创建：当在连接的源代码库中创建拉取请求时，此规则将执行。

• 拉取请求被拒绝：当在连接的源代码库中拒绝拉取请求时，此规则将执行。

• 拉取请求合并：当在连接的源代码库中合并拉取请求时，此规则将执行。

  重要提示

  DevOps 触发器在 Jira Server 中不可用，尽管可以使用传入 Webhook 集成触发器来模拟这些触发器。

我们将在第八章中更详细地探讨这些触发器，与 DevOps 工具的集成。

定时触发器

定时触发器允许你配置在定义的时间间隔内运行的规则。这些可以是简单的固定间隔或更复杂的调度。

定时触发器非常适合自动化清理过程，或者创建需要定期执行的任务，我们将在第二章中更详细地讨论，自动化 Jira 问题。

集成触发器

最后一种触发器是传入的 webhook。这个触发器为第三方应用程序提供了一种触发自动化规则的方法。

传入的 webhook 触发器可以指定需要操作的确切问题，甚至提供实时数据供你更新问题。

第五章，与外部系统协作，专门探讨了如何将我们的自动化规则与外部系统集成。

使用条件

一旦触发规则，并且为了规则继续运行，它需要满足你指定的条件。

因此，条件会缩小规则的范围，如果条件失败，规则将停止运行，且不会执行该条件后面的任何操作。

自动化提供了一系列可以应用于规则的条件，大多数条件可以单独使用或链式组合，形成更复杂的条件。

自动化规则可用的条件集如下：

• 问题字段条件不足以满足需求。

• If/else 块：此条件允许我们根据每个块中的条件是否匹配来执行交替操作，你可以根据需要添加任意数量的条件。

• 问题附件：此条件检查问题是否存在附件。

• 问题字段条件：此条件将问题字段与您指定的特定标准进行比较。

• JQL 条件：此条件允许您根据任何有效的 JQL 查询检查问题。

• 相关问题条件：此条件允许您检查触发问题是否存在相关问题，以及这些问题是否符合特定的 JQL 查询。

• 用户条件：此条件允许您将用户与一组标准进行比较。

我们将在第二章中详细讲解条件，自动化 Jira 问题。

使用操作

规则链中的最终构建块是操作。操作是允许您在项目中进行更改的组件，能够执行许多任务，包括编辑问题、发送通知、创建任务等等。

与条件类似，规则链可以包含多个操作，从而允许您在单一规则中执行多个任务；例如，先编辑一个问题字段，然后立即通过电子邮件发送通知。

规则操作按类别分组，以便更容易识别您希望规则执行的操作类型。

让我们先看看各个类别，然后再逐个检查每个类别中的操作：

• 问题操作

• 通知

• Jira 服务管理

• 软件

• 高级

问题操作

问题操作类别中的操作允许您对现有问题进行更改，也可以创建新问题。让我们看看此类别中的可用操作，以及它们的作用：

• 指派问题：此操作将问题指派给一个用户。可以指派给特定用户，或通过使用负载均衡、轮询或随机等方法，在用户列表中进行指派。

• 克隆问题：此操作会在同一项目或不同项目中创建一个新问题，复制所有可能的字段。但这并不是真正的克隆，因此不会复制链接、附件或评论。

• 评论问题：此操作允许您向问题添加评论，您可以选择在服务管理项目中指定可见性。

• 创建问题：此操作将在项目中创建一个新问题，或在全球规则中为选定项目创建新问题，并允许您选择配置哪些字段及其相应的值。

• 创建子任务：此操作将在问题上创建子任务，并将摘要设置为指定值。如果您选择添加其他字段，此操作将转化为创建问题操作，并将问题类型设置为子任务。

• 删除评论：此操作仅能与涉及添加评论的触发器一起使用，并且只能删除触发规则的评论。不能用于删除任何其他评论。

• 删除问题：此操作会删除当前上下文中的问题。

• 删除问题链接：此操作允许你删除问题上的任何问题链接。你可以指定删除某些类型的链接或特定的问题。

• 编辑问题：此操作允许你通过选择字段并设置其相应值，来编辑问题上的字段。

• 链接问题：使用此操作将允许你通过选择链接类型和要链接的问题，将一个问题链接到另一个问题。

• 记录工作：此操作允许你使用实际日期和时间或智能值函数记录针对问题的工作时间。

• 管理观察者：使用此操作指定要添加或删除的观察者用户。

• 转换问题：此操作允许你通过分配的工作流将问题从一个状态转换到另一个状态。你还可以选择要在转换过程中更新的字段及其关联的值，前提是这些字段存在于问题转换屏幕上。

通知

本类别的操作允许你通过各种渠道发送通知，并且提供将数据发送到其他外部系统的能力。此类别的操作如下：

• 发送电子邮件：此操作在规则执行时发送一封电子邮件。

• 发送 Microsoft Teams 消息：此操作允许你在规则执行时向 Microsoft Teams 中的团队发送消息通知。

• 发送 Slack 消息：此操作允许你在规则执行时向 Slack 渠道或特定的 Slack 用户发送消息。

• 发送 Twilio 通知：使用此操作，在规则执行时通过 Twilio 发送短信消息。

• 发送网页请求：此操作允许你向任何可以接受网页请求的第三方系统发送请求。你还可以配置此操作以接受来自外部系统的响应数据，供后续操作使用。

Jira 服务管理

这些操作允许你执行专门针对服务管理项目的任务，具体如下：

• 添加服务项目客户：此操作允许你向服务管理项目中添加客户。

• 批准/拒绝请求：你可以使用此操作在服务管理项目中批准或拒绝请求。

• 创建服务请求：此操作允许你在服务管理项目中创建服务请求。其功能类似于创建问题操作，但增加了选择请求类型和客户的能力。

软件

软件操作允许你在软件项目中操作软件版本，且仅限于以下操作：

• 创建版本：此操作允许你在项目中创建新版本。如果已存在同名版本，则不会创建新版本。

• 发布版本：此操作使用版本的发布日期发布项目中的下一个未发布版本。或者，你可以配置发布哪个未发布的版本，并选择性地覆盖发布日期。

• 取消发布版本：此操作允许您取消发布一个版本。

高级

最后一类是高级操作。这些操作允许您执行一些任务，例如为后续规则组件创建变量、将信息记录到审核日志等。现在我们来看看这些操作：

• 创建变量：此操作允许您为在此规则中其他操作和条件使用的智能变量创建变量，仅在 Jira Cloud 中可用。

• 删除附件：此操作允许您使用正则表达式根据附件文件名删除问题中的附件。

• 记录操作：使用此操作将消息记录到规则的审核日志中。此操作在调试规则时特别有用。

• 查找问题：此操作允许您使用 JQL 搜索最多 100 个其他问题，并将结果列表包含在此规则的其他操作中。

• 重新获取问题数据：此操作使用最新的问题数据刷新智能值。对于多操作规则，后续操作依赖于先前更新的数据时，此操作尤其有用。

• 设置实体属性：您可以使用此操作为问题、项目和用户设置实体属性。这些是某些应用程序使用的隐藏的键/值存储。

创建您的第一个规则

现在我们已经涵盖了关键概念，让我们来看看如何创建您的第一个自动化规则。

在深入了解实际规则之前，我们先简要查看规则编辑器的用户界面及其布局。

规则编辑器

下图展示了自动化规则编辑器。正如您所见，它以结构化的格式呈现，使得操作规则变得简单直观：

图 1.3 – 自动化规则编辑器

让我们来看一下我们在前面截图中编号的主要组件：

1. 规则链视图：在此面板中，您可以看到规则的名称以及构成该规则的组件，按执行顺序排列。这也是您可以访问规则的主要详细信息和其定制审核日志的地方。您还可以在此面板中拖放组件以重新排列它们。

2. 组件：您可以通过单击任何现有组件之间出现的添加组件链接，在规则链中任何位置添加新的组件。

3. 规则详情视图：规则详情视图允许您编辑主要规则详情、查看规则的审核日志，并根据需要编辑组件配置。

创建一个规则，将 VIP 用户的问题分配最高优先级

这引出了我们的第一个自动化规则。在许多组织中，VIP 用户（如经理或高管）提出的问题需要被赋予最高优先级，以便能立即引起团队成员的注意。

由于这是我们的第一个规则，我们将一步一步地展示如何在 Jira 中编写自动化规则，并通过相关截图帮助你看到规则编辑器如何让我们直观地快速创建规则。

提示

自动化规则的配置位置在 Jira Cloud 和 Jira Server 之间略有不同。

在 Jira Cloud 项目中，自动化规则可以在项目设置中的自动化标签下找到，而在 Jira Server 中，它们可以在项目自动化标签下找到。

对于这个规则，我们将使用一个服务管理项目。要跟随此规则，你需要定义一个名为VIP的用户组，并将适当的用户分配给该组。

首先，在你的服务管理项目中，导航到项目设置，点击自动化标签，然后点击右上角的创建规则按钮：

1. 在决定创建新规则后，首先呈现给你的是选择触发器的选项。

   对于这个规则，点击问题创建触发器，然后点击保存，如下面的截图所示：

   

   图 1.4 – 选择问题创建触发器

2. 接下来，我们将添加一个条件，检查报告问题的用户是否是VIP用户组的成员。

   在接下来的屏幕中，选择新建条件，然后选择JQL 条件组件：

   

   图 1.5 – 添加 JQL 条件组件

3. JQL 条件组件需要进一步配置，形式为 JQL 查询。在组件的配置屏幕中，输入以下 JQL 查询，然后点击reporter in membersOf("VIP")

   你的规则应该类似于以下截图所示：

   

   图 1.6 – 配置 JQL 条件组件

4. 接下来，我们需要插入执行的操作。在这种情况下，我们需要使用编辑问题操作来将优先级字段设置为最高。

   点击新建操作，然后选择编辑问题：

   

   图 1.7 – 选择编辑问题操作

5. 与JQL 条件组件一样，编辑问题组件也需要进一步配置，我们现在需要选择要更新的字段。

   你可以在此操作中设置多个字段。但是，对于这个规则，我们只会设置优先级字段。首先输入字段名，然后在缩小选择范围后勾选框：

   

   图 1.8 – 选择优先级字段

6. 现在，你已经选择了优先级字段，点击选择字段进行设置选项外的区域，以便访问字段值列表，并从下拉菜单中选择可用选项。选择最高，然后点击保存：

   图 1.9 – 设置优先级字段的值

7. 我们现在已经配置了第一个规则。剩下的就是为新规则命名，启用它，并添加描述。

   在接下来的屏幕中，设置规则名称如下，然后点击为 VIP 设置最高优先级

   完成的规则组件应类似于以下截图：

   

   图 1.10 – 为规则命名并启用它

8. 最后，让我们为规则添加描述，并确保我们对规则的基本细节感到满意。点击确保由 VIP 组成员创建的问题被分配最高优先级。

   图 1.11 – 为规则添加描述

9. 你可能已经注意到，当你输入描述时，规则链视图顶部的菱形标识从启用变为草稿。

   这提醒你规则已被修改，但尚未发布。如果你不希望这些更改被发布，可以点击取消按钮，位于规则详情面板的底部，或点击返回列表链接，位于详情面板的右上角。

   现在，点击发布更改：

图 1.12 – 发布你的规则更改

你的规则现在将在规则列表中显示，针对你的服务管理项目，每当 VIP 用户组的用户创建问题时，优先级将自动更新为最高。

要测试此规则，首先将自己添加到 VIP 组，并在你的服务管理项目中创建一个新的服务请求。确保优先级设置为最高以外的其他选项。一旦你创建了问题，导航到该问题并查看历史记录选项卡中的活动。你应该看到优先级从你选择的值变更为最高，并且活动应记录在规则执行者的日志中。

你现在已经学会了如何在 Jira 中创建和发布自动化规则，而无需编写任何代码。

总结

在本章中，你已经了解了 Jira 中自动化规则的关键概念，以及规则的基本构建块，包括触发器、条件和动作。我们还讲解了规则类型、规则拥有者和执行者之间的差异，最后，我们展示了如何将所有这些概念结合起来，创建我们的第一个自动化规则。

正如你在本章中所学到的，我们有许多强大而灵活的组件可以使用，这些组件将帮助我们创建强大的自动化规则，在 Jira 中自动化日常任务，而无需编写任何代码。在接下来的章节中，我们将更详细地探讨这些组件，并通过实际的示例帮助你启动自己的规则。

在接下来的章节中，我们将学习如何使用这些组件来处理 Jira 中的问题。我们将探讨本章介绍的所有条件，如何处理相关问题，以及如何使用一些可用的操作组件在编辑和转换问题之前运行规则，最后看看如何定期执行这些规则。

第二章：第二章：自动化 Jira 问题

在上一章中，我们介绍了 Jira 自动化规则的一些关键概念，并探讨了规则的基本构建块。要真正掌握自动化规则，我们需要理解如何使用这些构建块在 Jira 中自动化处理问题，本章正是讲解这一内容的。

在这里，我们将学习各种条件的工作原理以及何时使用每种条件。我们还将讨论如何处理相关问题，例如子任务、关联问题和史诗中的故事。最重要的是，你将学会如何使用问题动作对问题字段进行更改。

我们还将讨论如何使用高级字段编辑功能，处理那些标准字段编辑器无法满足的特殊情况，最后，我们将探讨如何在工作流中转换问题，以及如何创建计划规则。

我们将覆盖以下主要内容：

• 理解条件

• 使用分支规则和相关问题

• 编辑问题字段

• 高级字段编辑

• 转换问题

• 安排任务

到本章结束时，你应该能够清楚地理解如何在规则中使用自动化条件和动作，从而有效地处理 Jira 中的问题。

技术要求

本章的要求如下：

• Jira Cloud 环境：如果你还没有访问 Jira 的权限，可以在 www.atlassian.com/software/jira/free 创建一个免费的 Jira Cloud 账户，并确保你选择了 Jira 软件和 Jira 服务管理；或者

• Jira Server 环境：如果你使用的是 Jira Server（可以从 www.atlassian.com/software/jira/download 获取），请确保你拥有 Jira 软件和 Jira 服务管理的许可。此外，你还需要确保安装了 Automation for Jira 应用，这可以在 Atlassian Marketplace 找到。

在这两个实例中，你需要至少拥有服务管理项目和 Scrum 软件项目的项目管理员访问权限，才能跟随本章的示例进行操作。对于本章的示例，我们使用 IT 服务管理项目模板创建了服务管理项目，使用 Scrum 软件项目模板创建了软件项目。

你可以从本书的官方 GitHub 仓库下载本章的最新代码示例，地址为 github.com/PacktPublishing/Automate-Everyday-Tasks-in-Jira。本章的《实践中的代码》视频可以在 bit.ly/2XPMdR7 查看。

理解条件

条件使我们能够使规则更强大和灵活，因为它们使我们能够缩小规则的范围，并且在 if/else 块的情况下，改变规则的控制流。

在本节中，我们将更详细地研究在 第一章 中介绍的每个条件，自动化的关键概念，探索它们各自的功能，以及如何在自动化规则中使用它们。

让我们先来看看 问题字段条件。

问题字段条件

问题字段条件是所有条件中最简单的。它允许你将大多数 Jira 字段与某些标准进行比较，而无需使用智能值或 JQL（即 Jira 查询语言）。

你可以用它来将字段与一个值或一组值进行比较，也可以用它来测试字段与另一个字段的关系，不论是在同一问题中，还是在某些相关问题中，如父问题、史诗问题、目标问题或触发规则的问题。

此外，您可以通过使用加法操作将这些条件链在一起，形成更复杂的条件。

提示

问题字段条件应尽可能在任何其他条件之前使用，因为它不仅更易于配置，而且相较于 JQL 和高级比较条件等条件，它还具有性能优势。

现在，让我们来看看如何在规则中使用这个条件。

创建规则以为故事任务生成子任务

在这个例子中，我们假设开发团队有一个需求，即每个用户故事在创建时都需要同时创建以下三个子任务：

• 开发功能

• 执行 QA 任务

• 记录功能

我们将创建一个规则，在用户故事创建时添加这些子任务，以演示问题字段条件：

1. 如果你使用的是 Jira Cloud，请导航到 项目设置，然后点击软件项目的 自动化 标签，或者对于 Jira Server，请导航到 项目设置，点击 项目自动化 标签，然后点击 创建规则。

2. 选择 问题创建 作为触发器，然后点击 保存。

3. 接下来，选择 新条件，然后选择 问题字段条件。

4. 将 字段 设置为 问题类型，条件 设置为 等于，最后，将 值 设置为 Story，然后点击 保存。

5. 最后，选择 Develop feature

   执行 QA 任务

   记录功能

   你的规则应该如下所示：

   

   图 2.1 – 完成的创建子任务规则

6. 最后，命名规则为 Create story sub-tasks，然后点击 启用，如以下截图所示，以保存并启用该规则：

图 2.2 – 命名并启用自动化规则

在本节中，我们已经看到如何使用问题字段条件，通过简单地从可用字段、条件和值列表中选择我们希望评估的内容，从而在规则中创建决策点。

在下一节中，我们将介绍 JQL 条件，以及如何在自动化规则中使用它。

JQL 条件

JQL 条件允许你测试问题是否符合任何有效的 JQL 查询。除了标准 JQL 外，还可以在查询中使用智能值。我们将在第三章中更详细地介绍智能值，使用智能值增强规则。

让我们看看如何在一个示例规则中利用 JQL 条件。

创建一个规则来创建高优先级事件提醒

在这个例子中，我们希望确保分配的团队成员更新一个高优先级事件，如果它即将突破且报告者在过去 15 分钟内没有被告知事件进展：

1. 在你的服务管理项目中，导航到项目设置，点击自动化标签，然后点击创建规则按钮。

2. 我们希望检查在接下来的 30 分钟内，解决时间 SLA是否即将违反，因此选择SLA 阈值已突破触发器。选择解决时间 SLA，然后选择将在接下来的选项，确保选择了 30 分钟，然后点击保存。

3. 接下来，选择type = Incident AND priority in (Highest, High) AND updated >= "-15m"

   以下截图展示了此时你的规则应该是什么样子的：

   ![图 2.3 – 添加 JQL 条件]

   ](https://github.com/OpenDocCN/freelearn-devops-pt7-zh/raw/master/docs/auto-evdy-task-jira/img/Figure_2.2_B16551.jpg)

   图 2.3 – 添加 JQL 条件

4. 我们希望规则通过电子邮件通知被分配人，因此选择Issue {{issue.key}} is about to breach without update

   现在，设置The issue {{issue.key}} - {{issue.summary}} is about to breach in 30 minutes and requires an update.

   请向上述问题添加评论或根据需要更新。

   非常感谢，

   Jira 自动化

   你的规则现在应该类似于以下截图：

   ![图 2.4 – 高优先级事件提醒规则]

   ](https://github.com/OpenDocCN/freelearn-devops-pt7-zh/raw/master/docs/auto-evdy-task-jira/img/Figure_2.3_B16551.jpg)

   图 2.4 – 高优先级事件提醒规则

5. 最后，点击高优先级事件提醒，然后点击开启以保存并启用规则。

在本节中，我们已经看到如何将任何有效的 JQL 查询作为条件用于我们的规则。

在下一节中，我们将讨论如何在自动化规则中使用用户条件。

用户条件

用户条件允许你检查是否存在某一类型的用户，并且他们是否处于特定的角色或组中，或者是否是某种类型的用户。此条件还允许你在单个条件中添加多个标准，你可以指定是否需要所有标准都匹配，或仅一个标准匹配即可。

然而，这个条件真正亮眼的地方在于服务管理项目中，在该项目中，客户可以是报告人、请求参与者或客户组织的成员，而用户条件为我们提供了一个标准，用户是客户，以便在单次操作中检查用户是否符合这些条件。此外，我们还可以检查用户是否属于特定组织，并根据需要应用特定操作。

现在，让我们来看看如何在规则中使用这个条件。

创建规则以将关系经理添加到客户请求

在此规则中，我们希望将客户关系经理作为观察者添加到我们服务管理项目中由重要客户的用户提出的任何问题。您需要在服务管理项目中创建以下组织，并在每个组织中创建一些客户：

• Kate Price 负责ACME 和 The Widget Co

• Pete Kramer 负责Rain Forest Books

  提示

  要将用户添加到 Jira 以便按照此示例操作，您需要为每个用户提供唯一的电子邮件地址。如果您的邮件服务器支持电子邮件子地址或标签功能，如 Gmail 或 Outlook 365，您可以利用此功能创建唯一的电子邮件地址，并将邮件发送到您的邮箱。例如，如果您的电子邮件地址是your.name@yourcompany.com，使用电子邮件地址your.name+kateprice@yourcompany.com将是唯一的，并且邮件会发送到您的收件箱，同时邮件标签为kateprice。

让我们来创建我们的规则：

1. 在您的服务管理项目中，导航到项目设置，点击自动化标签，然后点击创建规则。

2. 选择问题创建作为触发条件，然后点击保存。

3. 现在，选择报告人

   位于组织中

   ACME, The Widget Co

   您的条件应如下图所示：

   

   图 2.5 – 组织中的报告人用户条件

4. 选择新操作，然后选择管理观察者，在添加这些观察者字段中选择Kate Price，然后点击保存。

5. 添加报告人

   位于组织中

   Rain Forest Books

6. 选择新操作，然后选择管理观察者，在添加这些观察者字段中选择Pete Kramer，然后点击保存。您的规则应如下图所示：

   图 2.6 – 将关系经理添加为观察者

7. 最后，将您的规则命名为将关系经理添加到客户请求，然后点击启用以保存并启用此规则。

在本节中，我们讨论了如何使用用户条件来验证用户的存在以及用户是否属于特定的组、角色或组织。

接下来，我们将查看“相关问题条件”，以及如何使用它来检测与触发问题相关的问题。

相关问题条件

相关问题条件允许你检查在规则上下文中与当前问题相关的其他问题的状态，无论是触发该规则的问题，还是分支规则中的每个问题。

使用此条件，你可以检查相关问题是否存在，是否所有相关问题都匹配给定的 JQL 条件，或者仅有部分相关问题匹配该条件。

让我们来看一个使用相关问题条件的示例规则。

创建规则以便在所有子任务完成时关闭父任务或故事任务

当一个问题有子任务时，我们需要在所有子任务达到完成状态时自动关闭主任务。我们需要使用相关问题条件来实现这一点，如下所示：

1. 在你的软件项目中，进入项目设置，点击自动化标签（如果你使用的是 Jira Server，则点击项目自动化标签），然后点击创建规则。

2. 选择问题已转换触发器，然后在至状态字段中选择完成并点击保存。

3. 然后，选择问题类型

   等于

   子任务

4. 接下来，选择分支规则/相关问题，然后选择父任务作为相关问题的类型。

5. 现在选择子任务

   所有匹配指定的 JQL

   status = Done

   你的规则现在应该类似于以下截图：

   

   图 2.7 – 配置相关问题条件

6. 然后，选择新建操作，接着选择转换问题。在这种情况下，父任务（无论是缺陷还是故事）与子任务共享相同的最终状态，因此我们可以将目标状态保留为从触发问题复制。

7. 点击子任务完成时关闭父任务，然后点击启用以保存并启用该规则。

   提示

   当规则需要与其他项目中的相关问题一起工作时，它需要能够在包含相关问题的项目中执行，因此该规则应该是全局规则或多项目规则。

   这意味着只有 Jira 全局管理员才能创建和管理这些规则。

在这一节中，我们已经了解了如何使用相关问题条件对与触发自动化规则的问题相关的问题执行操作。

在下一节中，我们将详细了解高级比较条件。

高级比较条件

对于大多数规则，问题字段条件已足够；然而，有时你在编写规则时需要更多的灵活性，这时高级比较条件就派上用场了。此条件允许你对智能值、函数和正则表达式进行比较！

我们将在第三章中详细讨论智能值和函数，通过智能值增强规则，所以现在让我们来看一个使用此条件的规则。

让我们看一下如何在一个示例规则中使用高级比较条件。

创建一个规则，当报告者创建评论时重新打开问题

在大多数情况下，当客户创建请求时，服务台团队，或者确切来说是自动化规则，会在没有客户进一步参与的情况下解决该请求。然而，在某些情况下，请求可能没有让客户满意解决，而我们希望在客户添加新评论时重新打开原始请求，而不是创建一个新的请求。

让我们看看如何利用高级比较条件来实现这一点：

1. 在你的服务管理项目中，导航到项目设置，点击自动化标签，然后点击创建规则。

2. 然后，选择问题评论触发器并点击保存。

3. 接下来，选择{{comment.author.accountId}}

   等于

   {{issue.reporter.accountId}}

   你的条件应该如下所示：

   

   图 2.8 – 配置高级比较条件

   提示

   用户的accountId字段仅适用于 Jira Cloud。如果你使用的是 Jira Server 或 Jira Data Center，则需要使用{{comment.author}}和{{issue.reporter}}。

4. 然后，选择状态

   等于

   已解决

5. 现在选择新建操作，然后选择转换问题，接着将目标状态字段设置为进行中并点击保存。

6. 最后，命名你的规则为在报告者评论时重新打开工单，并点击开启来保存并启用规则。

在这一部分，我们讨论了何时使用高级比较条件以及它如何允许我们使用智能值来比较项。

在接下来的部分，我们将探讨如果/否则块，并了解如何基于不同条件执行替代操作。

如果/否则块

如果/否则语句可以说是自动化工具箱中最强大的条件。它允许我们基于指定条件是否匹配执行替代操作。

让我们看一下如何在示例规则中使用如果/否则块。

创建一个规则来定义事件优先级矩阵

正确的事件优先级排序对于确定问题的相对重要性至关重要。依赖用户选择事件的正确优先级，往往会导致大量事件被错误排序。

更常见的做法是根据事件的影响和紧急性来定义优先级。下表展示了基于所选影响和紧急性的一般优先级矩阵，我们将使用这个矩阵来帮助定义我们的自动化规则。

图 2.9 – 事件优先级矩阵

我们将在使用 IT 服务管理模板创建的服务管理项目中创建规则。我们已经调整了自定义字段影响和紧急性，并在前面的事件优先级矩阵中显示了选项。您还需要将这两个字段添加到服务管理项目中的请求表单，适用于事件请求类型。

参考前面的矩阵，我们来创建我们的规则：

1. 在您的服务管理项目中，导航到项目设置，点击自动化选项卡，然后点击创建规则。

2. 我们希望此规则在问题创建时触发，并且如果影响或紧急性字段的任何变化，也能触发该规则，因此我们将选择字段值更改触发器，然后在监控更改的字段下拉菜单中选择影响和紧急性字段。我们还希望仅在创建或编辑事件时触发此规则，因此我们仅在操作类型下拉菜单中选择这两种操作，并保存我们的更改，如下图所示：

   图 2.10 – 事件优先级矩阵触发器

3. 接下来，我们将添加新条件字段，并选择If/else块。

   在If块中，我们将配置第一个条件，用于测试最高优先级，当影响和紧急性都设置为高时。

4. 选择添加条件...，然后选择问题字段条件，将字段设置为影响，条件设置为等于，在值字段中选择高，然后对紧急性字段重复相同的步骤。

   现在您的规则应类似于以下截图：

   

   图 2.11 – 配置 If 块

5. 现在，我们需要添加当前条件满足时要执行的操作，因此选择新建操作，然后选择编辑问题，在选择要设置的字段...下拉菜单中找到优先级字段，将值设置为最高，然后点击保存。

   图 2.12 – 编辑问题优先级字段

6. 接下来，构建矩阵的其余部分。在规则链视图中点击添加 else，然后点击添加条件，接着选择问题字段条件。将字段设置为影响，条件设置为等于，值设置为高。对紧急性字段重复该步骤，将值设置为中，然后点击保存。

7. 我们需要添加当else块条件满足时要执行的操作，因此点击新建操作，然后选择编辑问题。接着，将优先级字段设置为高，与之前的矩阵一致：

   图 2.13 – 添加第一个 Else-if 块

8. 重复第 6 步和第 7 步，以处理前面所示事件优先级矩阵中的其余优先级。最终，您应该得到一个If块，后面跟着八个Else-if块，分别对应优先级矩阵中影响和紧急性的每个交集。

9. 最后，为规则命名为事件优先级矩阵，然后点击启用以保存并启用该规则。

在这一部分中，我们已经学习了如何使用条件来确保规则针对正确的问题，并且我们还学习了如何使用强大的If/else块来控制规则的执行流。

接下来，我们将查看分支规则以及如何处理相关问题。

使用分支规则和相关问题

问题很少是孤立存在的。事实上，在许多情况下，总是有其他问题与任何给定问题相关。这些可以是子任务、与更大史诗相关的故事，或是通过诸如被阻塞、重复等关系链接到其他问题。

因此，在创建自动化规则时，您经常会遇到不仅需要对触发规则的问题执行操作，还需要对与源问题相关的问题执行操作的情况。

在这里，分支规则组件及其配套条件相关问题条件最为有用，使您能够创建跨复杂问题关系工作的规则。

分支规则/相关问题

当我们使用分支规则组件对相关问题或问题列表执行操作时，规则不再按线性方式执行，而是扩展成多个子分支，代表每个相关问题。使用智能值时，我们将在下一章中详细讨论，智能值{{issue}}指的是当前子分支中的相关问题，而触发规则的问题可以通过智能值{{triggerIssue}}找到。

重要提示

多个问题上的分支在不同的进程中并行运行，因此不能保证任何一个分支会在下一个分支之前完成执行。

此外，主分支将在子分支开始之前继续执行。

如果只有一个相关问题，主分支将在子分支执行完成之前被阻塞。

现在让我们看看如何在示例规则中使用分支规则/相关问题组件。

创建规则以使 Epic 任务与其用户故事任务保持同步

在开发项目中，一个常见的需求是当其包含的第一个故事转换为“进行中”时，Epic 也应转换为进行中。这是一个非常适合使用分支规则组件的场景。让我们看看如何实现：

1. 在您的软件项目中，导航至项目设置，点击自动化选项卡（如果您使用的是 Jira Server，则为项目自动化选项卡），然后点击创建规则。

2. 选择问题转换触发器，然后点击保存。

3. 留空从状态字段，选择进行中作为到状态字段，然后点击保存。

4. 接下来，选择Epic

   匹配指定的 JQL

   status != "进行中"

5. 现在选择分支规则/相关问题，并将相关问题的类型字段设置为Epic（父级），然后点击保存。

6. 最后，选择新操作，然后选择转换问题，选择进行中作为目标状态，然后点击保存。

   你的规则现在应该看起来如以下截图所示：

   

   图 2.14 – 在故事变化时将 Epic 移动到进行中

7. 一如既往，最后一步是给你的规则命名为同步 Epic 状态到故事，然后点击开启以保存并启用该规则。

在本节中，我们已经学习了如何利用分支规则组件创建强大的规则，使我们能够定位与触发规则的问题相关的问题。

在下一部分，我们将更详细地讨论编辑问题字段。

编辑问题字段

在你大多数的自动化规则中，你将编辑问题中的信息。在本节中，我们将介绍在创建规则时需要理解的一些常见操作，包括分配、评论、将问题链接到其他问题，以及当然，编辑问题字段。

分配问题

在 Jira 中常见的一项繁琐任务是让团队成员跟踪未分配的问题队列并承担这些问题的责任。另一种常见的方法是让像团队负责人这样的人查看这些问题，并根据某些标准将其分配给团队成员。

我们可以使用自动化来处理这些任务，以下是一些我们在分配问题时可以利用的功能：

• 基于当前工作负载进行分配

• 循环分配

• 分配给先前的指派人或评论者

• 从相关问题或 JQL 查询中分配

让我们看看如何在规则中使用这个功能。

创建一个规则，将新进的 bug 自动分配给开发人员

在这个规则中，我们将根据每个团队成员当前的工作量，将所有新进的 bug 类型问题分配给开发团队，前提是问题尚未有指派用户。开发团队是项目中所有开发角色的成员：

1. 在你的软件项目中，导航到项目设置，点击自动化标签（如果你使用的是 Jira Server，则是项目自动化标签），然后点击创建规则。

2. 选择问题创建触发器，然后点击保存。

3. 接下来，我们需要确保只分配 bug 类型的问题。选择新条件，然后选择问题字段条件。将字段设置为问题类型，条件设置为等于，值设置为Bug，然后点击保存。

4. 现在我们需要执行新的问题分配。通过选择新操作，然后选择分配问题来实现。

5. 在分配问题给字段中，选择角色中的用户。然后，在选择负责人方法字段中选择平衡工作量。

   由于我们不想重新分配已经设置了负责人（assignee）的任何问题，我们需要使用 JQL 添加进一步的限制。在JQL 限制问题字段中输入以下查询：

   assignee = Unassigned
   

   最后，设置角色为开发人员，然后点击保存：

   

   图 2.15 – 使用平衡工作量分配用户

6. 在最终屏幕中，将规则命名为自动分配新问题，然后点击开启以保存并启用规则。

   注意

   如果你使用的是 Jira Server，必须确保规则的执行者拥有分配问题的权限，才能将问题分配给用户。在 Jira Cloud 中，默认的权限设计是确保处于atlassian-addons-project-access角色中的用户，如自动化应用用户，拥有编辑和分配问题所需的权限，除非你修改了默认权限，否则通常不需要进行调整。

在本节中，我们已经看过如何使用分配问题操作，根据不同场景将问题分配给用户，包括基于个人工作量、轮流分配、随机分配或使用与相关问题或查询的输入。

在下一节中，我们将看看如何使用编辑问题字段操作来更新问题。

编辑问题字段

在问题中编辑字段的能力是自动化规则的主要目标之一，许多规则操作都提供此功能，具体包括以下几种：

• 克隆问题

• 编辑问题

• 变更问题状态

字段编辑器非常灵活，允许你清除字段中的值、设置新值，甚至从当前问题、父问题、触发问题、史诗问题或目标问题中复制值。

此外，你可以在单个操作中编辑多个字段，大多数字段支持智能值和函数。

让我们看一个规则，看看如何在实际操作中使用这个功能。

创建规则以对齐用户故事的到期日期和修复版本

在这个示例中，当开始一个冲刺时，我们将更新该冲刺中的所有故事，将到期日期设置为冲刺的结束日期，并将修复版本设置为项目中下一个未发布的版本：

1. 在你的 Scrum 软件项目中，进入项目设置，点击自动化标签（如果你使用的是 Jira Server，则点击项目自动化标签），然后点击创建规则。

2. 选择冲刺开始，从可用看板中选择你的 Scrum 看板，然后点击保存。

3. 接下来，选择分支规则/相关问题组件，并在相关问题类型字段中选择冲刺中的问题。

4. 然后，选择{{sprint.endDate}}

   下一个未发布的版本

   提示

   在这个示例中，我们为截止日期字段使用了智能值，你可以在 support.atlassian.com/jira-software-cloud/docs/smart-values-general 查找可以在规则中使用的智能值列表。我们将在第三章中更详细地讨论智能值和智能值函数，增强规则与智能值。

   你的规则应如下所示：

   

   图 2.16 – 编辑问题字段

5. 最后，将你的规则命名为 Align story version and dates to sprint 并点击 启用 来保存并启用该规则。

在本节中，我们介绍了在创建自动化规则时你会使用的一些常见操作。我们学习了如何使用不同的算法以更智能的方式将问题分配给团队成员，同时我们还学习了如何使用操作来修改问题字段。

在某些情况下，我们可能需要更多的灵活性来编辑问题，接下来我们将探讨如何使用可用的高级字段编辑功能来实现这一目标。

高级字段编辑

并非所有 Jira 中的字段都是相同的，尤其是在第三方应用提供的自定义字段的情况下。在这些无法使用默认功能更新字段的情况下，提供了一个高级字段编辑器，我们可以利用它来应用所需的字段更新。

在本节中，我们将介绍高级字段编辑器以及如何在无法使用标准字段编辑器的情况下利用它。

高级字段编辑器

高级字段编辑器存在于更多选项部分中的多个操作下，允许你使用 Jira 的 REST API 中指定的格式，通过 JSON 对象指定要编辑的字段。

允许进行高级字段编辑的操作如下：

• 克隆问题

• 创建问题

• 创建服务管理请求

• 编辑问题

• 转换问题

在我们了解如何使用高级字段编辑器之前，我们首先需要理解字段编辑器所需的 JSON 对象是如何结构化的。

理解 JSON 对象

我们可以在 JSON 对象中使用两个属性：

• update：你可以在更新属性中使用任何支持的字段操作，如添加、设置或删除。它最适用于具有多个值的字段，在这种情况下，你可以向现有的值集合中添加值，或从中删除值。

• fields：此属性是调用更新属性并执行设置操作的快捷方式。

您在更新或字段属性中使用的字段取决于您是在创建新问题时还是编辑现有问题时使用高级编辑器，这些字段可以通过以下 REST API 调用中的一种来找到：

• createmeta: https://<yourjira.domain.com>/rest/api/latest/issue/createmeta?projectKeys={projectKey}&expand=projects.issuetypes.fields 或

• editmeta: https://<yourjira.domain.com>/rest/api/latest/{issueKey}/editmeta

这些调用的响应将返回一个 JSON 对象，列出在创建或编辑问题时所有可用的字段，包括每个字段的可能操作和数值。您可以在官方文档中了解更多关于如何通过 REST API 查找字段的信息，文档地址为support.atlassian.com/jira-software-cloud/docs/advanced-field-editing-json/。

重要提示

这些 API 调用返回与项目和问题类型配置的相应创建或编辑屏幕上的字段列表。如果在返回的 JSON 中找不到某个字段，您需要首先将其添加到相应的屏幕中。

现在让我们来看看如何在规则中使用高级字段编辑器。

创建一个规则以展示高级字段编辑器

为了演示如何使用高级字段编辑功能，我们将使用一个稍显牵强的情况。

对于此规则，我们将查找summary或description字段中包含的printer一词，然后将打印机组件添加到组件字段中，添加新的标签，并更新描述字段。让我们开始：

1. 在您的服务管理项目中，导航到项目设置，点击自动化标签，然后点击创建规则。

2. 添加问题已创建触发器并点击保存。

3. 添加一个新的问题字段条件，将问题类型设置为服务请求，然后点击保存。

4. 添加一个新的summary ~ printer OR description ~ printer

5. 添加一个编辑问题动作，展开更多选项部分，然后将附加字段设置为以下 JSON：

   {
     "update": {
       "labels": [
         {
           "add": "label-printer"
         }
       ]
     },
     "fields": {
       "description": "{{issue.description}}\n\nUpdated by Automation Rule",
       "components": [
         {
           "name": "Printers"
         }
       ]
     }
   }
   

   提示

   高级字段编辑器使用的 JSON 结构基于 Jira REST API，您可以在developer.atlassian.com/cloud/jira/platform/rest了解有关 Jira Cloud 的更多信息，在developer.atlassian.com/server/jira/platform/rest-apis了解 Jira Server 和 Jira Data Center 的相关信息。

6. 你的规则应该与以下屏幕截图类似：

   图 2.17 – 高级字段编辑规则

7. 最后，点击Advanced field editing example，然后点击开启以保存并启用规则。

在本节中，我们学习了如何使用高级字段编辑器在默认字段编辑器不够用时更新问题字段。我们还学习了如何利用 REST API 了解可用的字段，以及如何在高级编辑器中正确格式化 JSON 数据。

在接下来的部分，我们将学习如何使用自动化将问题通过工作流进行过渡。

过渡问题

无论你是在 Jira 的 Software、Service Management 还是 Business 项目中工作，Jira 的核心是能够跟踪问题在特定工作流中的进展。因此，能够自动化问题在工作流中各个状态之间的过渡，对于完成工作流中的任务至关重要。

在本节中，我们将学习如何使用自动化响应问题在工作流中的状态过渡，以及如何将问题在工作流中的后续状态之间进行过渡。

过渡和工作流

正如我们所提到的，我们可以使用自动化将问题通过工作流进行过渡，并且为了实现这一点，你的规则必须与该问题类型的特定工作流对齐。

如果我们查看以下工作流，它代表了一个 Jira 服务管理项目中的服务请求，我们可以自动将问题从In Progress过渡到Pending；然而，由于从In Progress到Closed没有直接过渡，因此任何尝试执行此过渡的自动化规则都会导致规则失败，并在审计日志中记录错误：

图 2.18 – 一个服务请求工作流

正如你从前面的工作流示意图中看到的，自动化规则只能在工作流中已经存在两个状态之间的过渡时，将问题通过工作流进行过渡。

重要提示

另一个需要考虑的点是，规则执行者必须有权限执行特定的过渡。例如，如果你在工作流过渡中设置了条件，限制了某些用户或组的权限，那么你需要调整该条件，以允许规则执行者也能执行过渡。

让我们看看如何在自动化规则中将问题通过工作流进行过渡。

创建一个规则，自动将请求升级到正确的团队

假设一个服务台团队通常会收到大量请求，因此，为了腾出一些时间，我们希望将我们知道与基础设施相关的任何请求自动升级到基础设施团队的成员。我们将使用图 2.17中的工作流作为指南：

1. 在你的服务管理项目中，进入项目设置，点击自动化标签页，然后点击创建规则。

2. 在To状态字段中选择Waiting for support，然后点击Save。

3. 接下来，我们选择Components

   包含任何

   云存储服务、数据中心服务、办公室网络

4. 现在选择新建操作，然后选择转换问题，并将目标状态设置为已升级。

   此时，我们可以选择将负责人字段设置为某个特定用户；然而，我们希望将任务均匀分配给基础设施团队，因此点击保存。

   您的规则现在应该与以下截图类似：

   

   图 2.19 – 将问题转换为已升级状态

5. 接下来，我们来添加分配。选择用户组中的用户

   循环分配

   基础设施团队

6. 最后，为您的规则命名为 自动升级请求，然后点击启用以保存并启用规则。

在本节中，您已经学习了如何创建响应问题状态转换的规则，以及如何自动将问题转换为其工作流中的下一个状态。

在本章的最后一节中，我们将探讨如何使用自动化来安排定期执行的任务。

任务调度

当提到自动化时，人们首先想到的事情之一就是按计划创建问题，在 Jira 中使用自动化实现这一点是相对简单的任务。结合我们已经讨论的其他组件，它为您提供了巨大的灵活性，能让您实现各种功能。

在本节中，我们将探讨如何使用定时触发器来执行需要在特定时间间隔内完成的各种任务。

定时触发器

定时触发器允许我们在指定的时间间隔内运行规则。我们可以在规则中使用固定间隔，或者使用cron表达式来创建更复杂的调度计划。

固定速率间隔非常简单；您指定规则触发的频率（以分钟、小时或天为单位），自动化引擎会根据间隔启动规则的执行。

重要提示

当您使用小时或天数的固定速率间隔时，自动化引擎会将间隔的起始时间视为您保存或更新规则的时间。例如，如果您设置了每天运行的计划，并且您在 09:21 保存规则，那么它将每天在 09:21 运行，直到您编辑并在不同时间保存规则。

Cron 表达式为您提供了更大的灵活性，可以控制规则触发的时间。使用 cron 表达式，您可以定义计划，例如每周一和周五上午 8:30 执行规则。您可以在 support.atlassian.com/jira-software-cloud/docs/construct-cron-expressions-for-a-filter-subscription/ 找到更多关于如何在 Jira 中创建 cron 表达式的详细信息。

提示

编写 cron 表达式并不总是直观或简单的。我建议你使用像 CronMaker (www.cronmaker.com) 这样的网站，帮助你构建与 Jira 自动化兼容的 cron 表达式。请注意，Jira 的 cron 表达式包含秒字段，而某些 cron 表达式生成器只支持到分钟级别。

让我们先看看如何在调度规则中使用固定速率间隔。

创建一个规则来关闭过时的问题

在这个示例中，我们将看一下如何处理那些等待客户反馈超过 5 天的请求：

1. 在你的服务管理项目中，进入项目设置，点击自动化选项卡，然后点击创建规则。

2. 选择status = "等待客户" AND updated > -5d

   你的规则应该如下所示：

   

   图 2.20 – 调度固定速率规则

3. 接下来，我们将在问题中添加评论，通知客户我们正在自动关闭他们的请求，因此我们将选择亲爱的 {{issue.reporter.displayName}}，

   我们已经有一段时间没有收到你的消息了，所以我们将关闭这个问题。

   如果你觉得这个不正确，请回复此消息，我们将为你重新打开这个请求。

   此致，

   服务团队

4. 然后我们将问题转移到已解决状态。选择新建操作，转移问题，并将目标状态字段设置为已解决。

5. 最后，点击自动解决过时问题，然后点击启用以保存并启用规则。

现在我们已经看到固定间隔规则的工作方式，接下来我们来看一下如何使用 cron 表达式创建更精确的调度。

创建一个规则来生成周期性的周开始任务

接下来，让我们看看如何使用调度触发器每周一早上为服务管理创建任务。我们将创建一个主任务来跟踪此任务，并根据需要为主任务添加子任务。这个任务的到期日期应为 1 天内：

1. 在你的服务管理项目中，进入项目设置，点击自动化选项卡，然后点击创建规则。

2. 选择0 0 9 ? * MON *

   你的触发器应该如下所示：

   

   图 2.21 – 使用 cron 表达式设置调度触发器

3. 选择任务

   周开始检查

   {{now.plusDays(1)}}

4. 接下来，选择分支规则/相关问题，并将相关问题类型设置为所有创建的问题，然后点击保存。

5. 最后，点击新建操作，创建子任务，并根据需要添加多个子任务以执行你想要检查的操作。对于这个示例，我们将添加两个子任务：检查周末访问日志和其他任务。

   你的规则应该类似如下：

   

   图 2.22 – 创建定期的每周任务

6. 最后，点击Start-of-week checks，然后点击开启以保存并启用规则。

在本节中，我们学习了如何使用调度触发器，自动化定期创建任务，以及如何利用调度来在定义的时间间隔执行维护任务。

总结

在本章中，你已经学习了如何使用自动化规则来处理 Jira 中的问题。我们更详细地探讨了规则条件，以及如何利用这些条件精确地定位规则中的问题。

接下来，我们介绍了分支规则，学习了如何编写规则，既可以针对触发规则的问题，也可以针对与之相关的问题，并介绍了处理问题时最常用的操作。

然后，我们学习了如何使用高级字段编辑器，处理标准规则动作不足以应对的情况，并且还学会了如何自动化地将问题在其工作流中转换。

最后，我们了解了如何使用规则的调度功能，通过固定速率调度和 cron 表达式来定期执行任务，以便更精细地控制我们的日程安排。

这些技能构成了在自动化规则中处理问题的基础，接下来我们将在本书的其余部分继续使用这些技能。

在下一章中，我们将学习智能值和智能值函数，以及如何利用这些工具将你的自动化规则提升到一个新的水平。

第二部分：基础之外

在本节中，我们将通过实际案例深入探讨自动化。我们还将介绍一些高级概念，如智能值，并说明如何使用自动化与外部系统集成。

本节包括以下章节：

• 第三章，使用智能值增强规则

• 第四章，发送自动化通知

• 第五章，与外部系统协作

第三章：第三章：使用智能值增强规则

我们在第一章中探讨的可视化规则编辑器，自动化的关键概念，使得创建复杂的自动化规则变得非常简单，且无需了解 Jira API 或任何专业的脚本知识即可开始。

虽然这种方法适用于大多数使用案例，但总有一些情况下，您需要直接访问问题数据并对这些数据执行更复杂的操作。这时，智能值就能派上用场。

本章将介绍智能值。您将学习如何查找智能值，智能函数如何工作，以及如何将您自己的智能值引入自动化规则。您还将概览如何操作日期、数据列表、文本值，以及如何使用数学表达式进行数字计算。

本章将涵盖以下主题：

• 理解智能值

• 使用智能值日期函数

• 使用智能值文本函数

• 使用智能值列表函数

• 使用智能值数学表达式和函数

到本章结束时，您将学会如何使用智能值和函数来操作日期、文本字符串和列表，以及如何使用数学表达式和函数进行涉及数值的计算。

技术要求

本章的要求如下：

• Jira 云环境：如果您还没有 Jira 的访问权限，您可以在www.atlassian.com/software/jira/free创建一个免费的 Jira 云账户，并确保同时选择 Jira 软件和 Jira 服务管理。

• Jira 服务器环境：如果您使用的是 Jira 服务器（可以从www.atlassian.com/software/jira/download下载），请确保您已获得 Jira 软件和 Jira 服务管理的许可证。此外，您还需要确保安装了Jira 自动化应用，可以从 Atlassian Marketplace 获取。

在这两种情况下，您需要至少拥有项目管理员访问权限，才能访问服务管理项目和 Scrum 软件项目，以便跟随本章的示例。在本章的示例中，我们使用了IT 服务管理项目模板来创建服务管理项目，并使用Scrum 软件项目模板来创建软件项目。

您可以从本书的官方 GitHub 仓库下载本章的最新代码示例，网址为github.com/PacktPublishing/Automate-Everyday-Tasks-in-Jira。本章的《实战代码》视频可以在bit.ly/39Hk44d观看。

理解智能值

智能值允许你在自动化规则的上下文中访问和操作几乎所有问题数据。除了让你访问问题数据外，智能值还通过函数提供高级功能，使你能够对问题数据执行复杂操作。

在本节中，我们将探讨哪些智能值对你可用，并了解如何在规则中识别和使用它们。我们还将介绍智能值函数，并解释如何创建你自己的智能值以供在规则中使用。

让我们首先来看一下可以在哪里找到智能值以及如何使用它们。

查找和使用智能值

智能值通常由触发器在规则执行的上下文中设置。除此之外，某些操作（例如发送 web 请求操作）也可以将智能值引入规则上下文。

这些触发器所提供的每个智能值都是包含字段的数据结构。这些字段可以是简单的字段类型，例如文本或数字，或者是更复杂的数据结构，后者又包含其他字段。

例如，触发器可以是{{issue}}，用于当前 Jira 问题的规则上下文。此智能值是一个数据结构，表示 Jira 中的一个问题，并包含简单和复杂字段。

简单字段的示例包括{{issue.summary}}和{{issue.key}}，它们分别允许你访问问题的摘要和关键字。一个复杂字段的示例是{{issue.assignee}}，它本身是一个数据对象，包含进一步的字段，允许你访问被分配者的显示名称、电子邮件地址和账户 ID 字段，例如 {{issue.assignee.displayName}}、{{issue.assignee.emailAddress}}、{{issue.assignee.accountId}} 和 {{issue.assignee.key}}。

提示

要在智能值中访问自定义字段，你可以使用自定义字段的名称或其 ID。例如，如果你有一个名为My Custom Field的自定义字段，ID 为10000，你可以通过{{issue.My Custom Field}}、{{issue.my custom field}} 或 {{issue.customfield_10000}}来访问它。你可以通过编辑自定义字段并从自定义字段管理部分复制结果 URL 中的 ID 来找到自定义字段的 ID。然而，如果出于某种原因，你有多个名称相同的自定义字段，才应该使用这种方法。

在下表中，我们可以看到每个自动化触发器所提供的智能值，你可以在随后的规则组件中使用这些值：

图 3.1 - 根据触发器提供的智能值

上表展示了每个触发器的主要智能值，对于大多数情况，您可以在 support.atlassian.com/jira-software-cloud/docs/smart-values-general 找到适用于 Jira Cloud 的每个智能值的字段列表，或者在 confluence.atlassian.com/display/AUTOMATION/Smart+values 中找到适用于 Jira Server 和 Jira Data Center 的字段列表。

智能值基于 Mustache 模板系统（https://mustache.github.io）。要使用智能值（或 Mustache 中称为标签），您需要将键包围在双大括号中（或称作大胡子符号）。使用这种格式意味着规则引擎需要将给定的值视为智能值，而不仅仅是静态文本。

要访问智能值对象中的字段，可以使用点符号。例如，要访问问题的指派人的显示名称，可以使用如下的点符号：{{issue.assignee.displayName}}。

提示

当您引用某个字段或值，该字段在特定问题中不存在时，智能值将为空。您可以通过使用管道符号（|）指定智能值的默认值。例如，智能值 {{issue.description|没有提供描述}} 如果 描述 字段为空，将返回文本 没有提供描述。

智能值可以在 高级比较条件、JQL 条件 和 用户条件 中使用，也可以在大多数规则动作中使用。

让我们来看一个使用智能值的示例规则。

创建规则，在问题首次被指派时添加评论

在这个示例规则中，我们将在问题首次指派时添加评论，通知报告者我们正在处理他们的请求：

1. 在您的服务管理项目中，导航到 项目设置，点击 自动化 标签，然后点击 创建规则。

2. 选择 问题已指派，然后点击 保存。

3. 然后选择 {{changelog.assignee.fromString}}

   equals

   第二个值：留空

4. 现在，选择 Hi {{issue.reporter.displayName}}

   我们现在正在查看您的问题 {{issue.summary}}。

   我们会尽快为您提供更新。

   {{issue.assignee.displayName}}。

   规则应该如下所示：

   

   图 3.2 - 在规则中使用智能值

5. 最后，命名规则为 在问题指派时给报告者评论，然后点击 启用 来保存并启用该规则。

在本节中，我们了解了如何在规则中使用智能值使其更加灵活，在下一节中，我们将介绍智能值函数。

智能值函数

除了使用智能值访问数据字段的功能外，您还可以通过添加函数来操作这些数据值。

函数通常通过点符号附加到智能值的末尾。例如，若要将问题摘要截断为前 50 个字符并在截断后的摘要末尾添加省略号，我们将使用以下智能函数：{{issue.summary.abbreviate(50)}}。

重要提示

智能值函数只能应用于相应类型的字段。例如，日期和时间函数只能应用于创建时间、更新时间、截止日期、解决日期以及任何具有日期选择器或日期时间选择器类型的自定义字段。

智能函数也可以串联在一起，使我们能够在单个步骤中执行多个转换。例如，以下智能函数链将把摘要转换为小写字母，提取第五到第十个字符，并在末尾附加一个感叹号：{{issue.summary.toLowerCase().substring(5,10).concat("!")}}。

让我们看一个在规则中使用智能值函数的示例。

创建一个规则，要求添加截图评论

在本例中，我们将创建一个手动触发的规则，用户可以调用此规则来在问题上创建定制的评论，请求报告人上传附件以帮助进一步诊断问题：

1. 在您的服务管理项目中，导航到项目设置，点击自动化标签，然后点击创建规则。

2. 选择手动触发并点击保存。

3. 接下来，选择Hi {{issue.reporter.displayName.split(" ").first}}

   我们需要更多的信息以便进一步诊断您的问题。

   请在{{now.plusBusinessDays(2).fullDate}}之前截图并附加到此问题。

   谢谢 :)

   {{issue.assignee.displayName}}

   该规则应该与以下截图类似：

   

   ](https://github.com/OpenDocCN/freelearn-devops-pt7-zh/raw/master/docs/auto-evdy-task-jira/img/Figure_3.3_B16551.jpg)

   图 3.3 - 使用智能值函数

4. 最后，将规则命名为要求报告人附加截图，然后点击开启以保存并启用该规则。

   重要提示

   在 Jira Cloud 中，可以使用创建变量操作，根据其他智能值函数和表达式创建自定义智能值，然后在后续的条件和操作中使用它。

在本节中，我们了解了什么是智能值，以及如何在自动化规则中使用它们访问数据。我们还学习了如何为触发器找到正确的智能值，并如何找到相关的智能值字段。我们还了解了智能值函数，并看到了如何将它们连接在一起，在单个步骤中应用多个转换。

在下一部分，我们将学习如何在自动化规则中使用智能值来操作和格式化日期。

使用智能值日期函数

作为项目管理和跟踪工具，在 Jira 中能够操作日期对于应用程序的正常运行至关重要，而自动化规则中的智能值为我们提供了在规则中使用和操作日期和时间的灵活性。

在本节中，我们将探讨如何使用智能值格式化日期和时间，以便将其包含在其他日期和时间字段中，以及如何将其格式化以便在文本字段、高级字段编辑器或通知中使用。

我们还将探索所有可用的日期格式和函数，并了解如何在自动化规则中使用它们。

提示

你可以使用智能值{{now}}访问当前的日期和时间。所有可以与日期字段一起使用的格式化和日期操作函数，也可以与{{now}}智能值一起使用。

让我们来看一下如何使用智能值函数来格式化日期。

格式化日期

格式化日期和时间的能力使我们可以灵活地展示这些信息，无论是在评论、文本字段还是通知中。它还使我们能够在与需要特定格式日期和时间输入的外部系统进行通信时，指定确切的格式，以及重新格式化从外部系统接收到的日期和时间。

最后，能够控制日期和时间的格式使我们可以使用智能值函数对它们进行操作，并确保可以使用正确的计算结果设置日期或时间字段。

在下表中，我们可以看到如何使用每种可用的日期和时间格式来格式化日期 2019 年 12 月 31 日 星期二 10:25:30 PM CET，这些格式可用于自动化规则：

图 3.4 - 可用的日期格式

从前面的列表中可以看到，日期和时间可以通过多种方式格式化显示，如果没有合适的标准格式，也可以使用自定义模式。

提示

用于自定义格式化器format("pattern")和as("pattern")的模式语法由底层 Java 平台定义，完整的语法描述可以在以下链接中找到：docs.oracle.com/en/java/javase/11/docs/api/java.base/java/time/format/DateTimeFormatter.html，请参阅标题 格式化和解析模式。

使用地区和时区格式化日期

除了我们刚才查看的格式之外，使用智能值还可以根据特定的地区和时区，甚至是特定用户的地区或时区（例如问题的受让人或报告人）来格式化日期和时间。

提供了以下格式化函数，用于实现基于地区和时区的日期和时间格式化：

• {{issue.created.withLocale("fr_CA")}} 用于使用加拿大法语格式化问题创建日期，或者 {{issue.created.withLocale(issue.reporter.locale)}} 用于根据报告者的语言环境格式化问题创建日期。

• {{issue.created.convertToTimeZone("America/New_York")}} 用于将问题创建日期格式化为纽约当前时区，或者 {{issue.created.convertToTimeZone(issue.reporter.timeZone)}} 用于将问题创建日期格式化为报告者的时区。

• setTimeZone(string timezone)：将日期时间字段的时区组件设置为给定的时区。此函数将更改时区而不转换时间。

支持的完整语言环境列表可以在 www.oracle.com/java/technologies/javase/jdk11-suported-locales.html#modules 找到。时区列表由 tz 数据库定义，完整列表可以在 en.wikipedia.org/wiki/List_of_tz_database_time_zones 找到。

让我们看看如何在示例规则中使用日期格式。

创建规则以创建入职子任务

在此规则中，当创建一个新的员工入职请求时，我们需要确保在新员工开始工作之前完成一些任务，例如提供笔记本电脑和桌面电话。

我们希望子任务摘要中包含开始日期，这样被分配到该请求的用户就能立刻看到任务的到期时间：

1. 在你的服务管理项目中，导航到项目设置，点击自动化标签页，然后点击创建规则。

2. 选择问题创建触发器并点击保存。

3. 然后选择 请求类型

   等于

   新员工入职

4. 接下来，选择 在{{issue.duedate.longDate}}之前提供新的笔记本电脑

   在{{issue.duedate.longDate}}之前设置新的桌面电话

   规则应该类似于以下截图：

   

   ](https://github.com/OpenDocCN/freelearn-devops-pt7-zh/raw/master/docs/auto-evdy-task-jira/img/Figure_3.5_B16551.jpg)

   图 3.5 - 使用智能值日期格式

5. 最后，点击创建入职子任务，然后点击启用以保存并启用规则。

现在我们已经看到如何格式化日期和时间，让我们来看看如何使用智能值函数对其进行操作。

操作日期

除了提供格式化日期的功能外，还提供了许多智能值函数，使我们能够对日期进行操作。这些操作允许我们对日期和时间进行比较，进行基本的算术运算，并操作日期和时间的各个组成部分。

让我们来看看在规则中可以使用的日期操作函数。第一组函数涉及日期比较，允许你将一个日期与另一个日期进行比较：

• function 参数。此函数将返回 date 参数，否则返回false。

• function 参数。此函数将返回 date 参数，否则返回false。

• function 参数。此函数将返回 date 参数，否则返回false。

• -1) 当用于调用函数的日期字段早于参数中的日期时，0 如果它们相等，或者当日期字段晚于参数中的日期字段时返回正整数（如1）。

下一组函数允许我们以各种方式操作日期和时间：

• diffDate(date).seconds 将显示日期之间的差异（以秒为单位）。默认输出为prettyPrint，以文字形式显示差异，例如，2 天 3 小时。

• plusDays(int days)/minusDays(int days): 向相应的日期组件添加或减去给定的天数，并返回应用了相关计算的新日期。

• plusHours(int hours)/minusHours(int hours): 向相应的日期组件添加或减去给定的小时数，并返回应用了相关计算的新日期。

• plusWeeks(int weeks)/minusWeeks(int weeks): 向相应的日期组件添加或减去给定的周数，并返回应用了相关计算的新日期。

• plusMillis(int millis)/minusMillis(int millis): 向相应的日期组件添加或减去给定的毫秒数，并返回应用了相关计算的新日期。

• plusMinutes(int minutes)/minusMinutes(int minutes): 向相应的日期组件添加或减去给定的分钟数，并返回应用了相关计算的新日期。

• plusMonths(int months)/minusMonths(int months): 向相应的日期组件添加或减去给定的月数，并返回应用了相关计算的新日期。

• plusSeconds(int seconds)/minusSeconds(int seconds): 向相应的日期组件添加或减去给定的秒数，并返回应用了相关计算的新日期。

• plusYears(int years)/minusYears(int years): 向相应的日期组件添加或减去给定的年份数，并返回应用了相关计算的新日期。

• plusBusinessDays(int days)/minusBusinessDays(int days): 向相应的日期组件添加或减去给定的工作日数，并返回应用了相关计算的新日期。工作日定义为从周一到周五，上午 9 点到下午 6 点。

• toBusinessDay/toBusinessDayBackwards: 分别返回调用函数时的日期之前或之后的第一个工作日。

• toStartOfDay/toDateTimeAtStartOfDay: 使用服务器的默认时区将给定日期的时间组件设置为零（即午夜）。第一个函数用于DateTime字段，而第二个函数会将Date字段转换为DateTime字段，并相应地设置时间组件。

• toCurrentTime/toDateTimeAtCurrentTime：将给定日期的时间组件设置为当前时间。第一个函数用于日期时间字段，而第二个函数将日期字段转换为日期时间字段，并相应地设置时间组件。

• MON, TUE，WED，THU，FRI，SAT，或SUN作为dayOfWeek参数的值。

• dayOfMonth。dayOfMonth参数的有效范围是1到31。

• 0 到 23。

• 0 到 999。

• 0 到 59。

• 1 到 12。

• 0 到 59。

• withYear(int year)：将日期或日期时间字段的年份组件设置为提供的年份。年份参数的有效范围是公历中的任何有效年份。

• dayOfYear。dayOfYear参数的有效范围是1到365。

• startOfMonth/endOfMonth：将日期或日期时间字段的日期组件设置为该字段所在月的第一个或最后一个日历日。

• firstBusinessDayOfMonth/lastBusinessDayOfMonth：将日期或日期时间字段的日期组件设置为该字段所在月的第一个或最后一个工作日。

• 1 到 7，1 代表星期一，7代表星期天。例如，调用{{datefield.firstOfTheMonth(3)}}将日期设置为本月的第一个星期三。

• weekOfMonth参数的范围是1到5，dayOfWeek参数的范围是1到7，1 代表星期一，7代表星期天。例如，要将日期设置为本月的第三个星期一，可以使用{{datefield.ofTheMonth(3, 1)}}。

现在我们已经查看了用于操作日期和时间的各种函数，让我们看几个示例，了解如何在规则中使用它们。

创建一个基于子任务更新到期日期的规则

在此示例中，我们为每个用户故事设置了多个子任务，并希望在最后一个子任务过渡到进行中时，将用户故事的到期日期更新为当前日期后的 5 个工作日：

1. 在你的软件项目中，导航到项目设置，点击自动化标签（如果你使用的是 Jira Server，则为项目自动化标签），然后点击创建规则。

2. 选择问题过渡触发器，并将到状态字段设置为进行中，然后点击保存。

3. 然后选择问题类型

   equals

   子任务

4. 接下来，选择分支规则/相关问题，将相关问题类型设置为父项，然后点击保存。

5. 现在选择子任务

   完全匹配指定的 JQL

   status = "进行中"

6. 在到期日期字段中选择{{now.plusBusinessDays(5)}}并点击保存。

   现在你的规则应该类似于以下截图：

   

   Figure 3.6 - Adding business days to the current date

7. 最后，给你的规则命名为设置用户故事到期日期，然后点击启用以保存并启用该规则。

现在，让我们来看另一个使用智能值函数操作日期的示例。

创建设置截止日期的规则

对于这个示例，我们希望如果问题在本月 15 日之前创建，则将截止日期设置为本月 15 日；如果问题在本月 15 日之后创建，则将截止日期设置为下个月 15 日：

1. 在您的软件项目中，导航至项目设置，点击自动化标签（如果您使用的是 Jira Server，则是项目自动化标签），然后点击创建规则。

2. 选择问题创建，然后点击保存。

3. 接下来，选择新条件，然后选择如果/否则区块，并为“如果”区块添加高级比较条件。

4. 设置{{issue.created}}字段

   greater than

   {{now.startOfMonth.plusDays(15)}}

5. 现在选择{{now.endOfMonth.plusDays(15)}}并点击保存。

   你的规则现在应该如下所示：

   

   图 3.7 - 将日期设置为下个月的中旬

6. 现在我们已经处理了下个月的截止日期，让我们完成本月截止日期的规则。在规则链视图中点击添加其他条件，然后点击保存。

7. 接下来，添加{{now.withDayOfMonth(15)}}并点击保存。

   你的规则应该类似于以下截图：

   

   图 3.8 - 将日期设置为当前月的中旬

8. 最后，命名规则为将截止日期设置为本月中旬，并点击启用以保存并启用此规则。

在本节中，我们已经了解了各种智能值日期和时间函数，并学习了如何使用它们在自动化规则中操作日期。接下来，我们将看看如何使用智能值处理文本。

使用智能值文本函数

类似于操作日期和时间，处理文本字符串的智能值函数允许我们操作任何文本字段类型，包括字段的子属性（如果它们也是文本类型字段）。

在本节中，我们将介绍如何使用文本的智能值函数来操作文本，如何对其进行编码以便在 HTML、JSON、XML 或 URL 中使用，以及如何使用函数测试文本块中的特定特征。

让我们看看在自动化规则中操作文本的可用函数。我们首先要查看的一组函数处理文本比较，并根据检查是否通过返回true或false：

• startsWith(string)/endsWith(string)：分别检查文本字段是否以给定字符串开头或结尾

• equals(string)/equalsIgnoreCase(string)：分别检查文本字段是否完全等于给定字符串，或者忽略大小写地等于给定字符串

• isAlpha：检查文本字段是否仅包含字母

• isNumeric: 检查文本字段是否仅包含数字。

• isAlphaNumeric: 检查文本字段是否仅包含字母和数字。

• isEmpty: 检查文本字段中是否没有数据。

• isNotEmpty: 检查文本字段中是否有数据。

下一组函数允许我们将文本转换为其他类型，如数字、日期或列表：

• asNumber: 将文本字段转换为数字，允许你对转换后的值进行数值操作和计算。

  提示

  在转换之前，请对文本字段使用 isNumeric 测试，确保不会因为尝试转换无法表示为数字的文本而导致错误。

• toDate/toDate(string pattern): 将文本字段转换为日期。使用该函数的第二种形式来指定文本表示中的日期格式。请参阅格式化日期部分，了解如何定义模式的示例。

• split(string separator): 按照分隔符将文本字段拆分成一个项列表。结果列表中的项可以通过智能值列表函数进一步操作。

• match(string regularExpression): 在文本字段上执行正则表达式搜索。正则表达式的多个匹配项将作为项列表返回，可以通过智能值列表函数进一步操作。

  提示

  正则表达式 是描述搜索模式的特殊文本字符串。这些模式通常用于执行文本字符串的查找或查找替换操作，或者验证输入。在 Jira 自动化中，正则表达式基于底层的 Java 实现，可以参考docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html。

以下一组函数允许我们更改文本的显示方式、提取文本片段，甚至替换文本块：

• abbreviate(int maxLength): 将文本字段缩短到指定的最大长度，并在文本末尾添加省略号（"…"）。

• toLowerCase: 将文本字段转换为全小写。

• toUpperCase: 将文本字段转换为全大写。

• capitalize: 将文本字段的第一个字符转换为大写。

• reverse: 将文本字段中的所有字符反转。

• trim: 移除文本字段中所有前导和尾随的空白字符。

• concat(string): 将给定字符串附加到文本字段的末尾。

• 0。

• indexOf(string) / lastIndexOf(string): 查找给定字符串在文本字段中的第一次或最后一次出现的位置。

• length: 返回文本字段的总字符数。

• quote：将文本字段格式化为字面表达式，之后可以在匹配函数的正则表达式中使用。例如，如果文本字段包含正则表达式特殊字符，如*或\，这些字符将被当作普通字符（或字面字符）处理，而不是作为正则表达式。

• remove(string)：从文本字段中移除给定字符串的所有出现。

• replace(string target, string replacement)：将文本字段中的目标字符串替换为替换字符串的值。

• regex与替换字符串。

• left(int length)/right(int length)：分别返回文本字段左侧或右侧指定数量的字符。

• leftPad(int length, string)/rightPad(int length, string)：将给定字符串添加到文本字段的左侧或右侧，直到文本达到指定的总长度。

• substring(int start)：返回从起始索引开始的文本字段部分。

• substring(int start, int end)：返回从起始索引到结束索引之间的文本字段部分。

• substringAfter(string)/substringAfterLast(string)：返回文本字段中首次或最后一次出现提供的字符串后的部分。

• substringBefore(string)/substringBeforeLast(string)：返回文本字段中首次或最后一次出现提供的字符串之前的部分。

• substringBetween(string open, string close)：返回给定起始字符串和结束字符串之间的文本字段部分。

最后一组函数使我们能够对文本进行编码，以符合特定标准。当与外部系统集成或从规则发送电子邮件通知时，这尤其有用：

• htmlEncode：使用此函数确保在将字段包含在 HTML 输出中时，文本字段的值被正确编码。

• jsonEncode：使用此函数确保在将字段包含在 JSON 输出中时，文本字段的值被正确编码。

• urlEncode：使用此函数确保在使用字段创建 URL 链接时，文本字段的值被正确编码。

• xmlEncode：使用此函数确保在将字段包含在 XML 输出中时，文本字段的值被正确编码。

现在我们已经查看了可用于操作文本的各种函数，接下来让我们看看如何在自动化规则中利用这些函数。

创建一个规则以自动关闭问题

许多团队常面临的一个常见场景是，在工单解决后，报告人回复说感谢。这通常会导致工单重新打开，并且有人必须手动再次解决工单。

在这个示例中，我们将使用文本智能值函数检查最新的评论，如果发现“thank you”字样，则自动解决该问题：

1. 在您的服务管理项目中，导航到项目设置，点击自动化选项卡，然后点击创建规则。

2. 选择问题已转移触发器，将来源状态字段设置为已解决，将目标状态字段设置为进行中，然后点击保存。

3. 现在选择{{issue.comments.last.body.trim.toLowercase}}

   contains regular expression

   thank\s+you

   规则现在应如下所示：

   

   图 3.9 - 在条件中使用文本智能值函数

4. 接下来，选择新建操作，然后选择转移问题。将转移问题至设置为选择目标状态，并在目标状态字段中选择已解决，然后点击保存。

5. 将规则命名为自动处理感谢评论，然后点击启用以保存并启用该规则。

在本节中，我们已经了解了如何使用智能值函数比较和操作文本值。在下一节中，我们将看看如何使用智能值和函数来处理项的列表。

使用智能值列表函数

在编写自动化规则时，您会遇到一些场景，这些场景会向您展示一个项的列表。这可能是与问题关联的版本或组件的列表，或者是问题的列表，比如某个问题的所有子任务。

用于列表的智能值函数使我们能够通过对每个项目进行迭代来操作这些项，并能针对项目的属性执行额外的操作。我们还可以使用某些函数，对列表中所有项目进行简单的计算。

在本节中，我们将查看可用于访问和格式化项列表的智能值函数。

在第四章《发送自动化通知》中，我们将通过使用智能值来迭代列表，举例说明如何通过电子邮件和 Slack 发送通知。

现在，让我们来看看可以用于操作列表的智能值函数：

• isEmpty：检查列表是否包含任何项。如果列表为空，该函数返回true；如果列表中包含项，则返回false。

• size：返回列表中项目的数量。

• join(string separator)：将列表中的所有项合并成一个单一的文本值，项与项之间用提供的分隔符分开。

• 列表的两端是0（零）。

• first：获取列表中的第一项。

• last：获取列表中的最后一项。

• average：计算数值列表中所有项目的平均值。

• max：在数值列表中找到最大的项，或者在日期列表中找到最晚的日期。

• min：在数值列表中找到最小的项，或者在日期列表中找到最早的日期。

• sum：计算数值列表中所有项的总和。

让我们来看看如何将我们所学到的列表知识应用到实际示例中，利用智能值列表函数计算子任务中的故事点总和。

创建规则，将子任务的故事点汇总到父任务中

在此示例中，我们正在跟踪子任务的故事点，并希望确保每当其子任务中的故事点发生变化时，父任务始终反映正确的故事点总数。你需要启用故事点自定义字段的配置上下文，以便除了史诗和故事外，还能包含子任务：

1. 在你的软件项目中，导航至项目设置，点击自动化选项卡（如果你使用的是 Jira Server，请点击项目自动化选项卡），然后点击创建规则。

2. 选择字段值已更改，将监视字段变化设置为故事点，然后点击保存。

3. 现在选择问题类型

   等于

   子任务

4. 然后选择父任务，点击保存。

5. 接下来，选择新建操作，然后选择编辑问题。

6. 在{{issue.subtasks.Story Points.sum}}

   你的规则现在应该如下所示，参考以下截图：

   

   图 3.10 - 使用智能值列表函数求和列表项值

7. 最后，为规则命名为保持父任务与子任务故事点同步，然后点击启用以保存并启用该规则。

在本节中，我们学到了如何使用智能值列表函数遍历列表中的项，并对列表中的值执行操作。

接下来我们将查看自动化规则中可用的数学运算。

使用智能值数学表达式和函数

到目前为止，我们已经看到如何使用智能值来处理日期、文本和列表，以及它们如何帮助你创建强大且灵活的自动化规则。

在本节中，我们将研究数学表达式和函数。数学表达式和函数将允许你在数字字段中直接执行计算，并允许你在文本字段中引用数字字段进行计算以显示。在 Jira 中，所有数字字段都是基于浮点数的。

若要使用任何数学表达式，它们需要被包含在以下智能值块中，以便被识别，如下所示：

{{#=}} <数学表达式> {{/}}

{{#=}} 运算符通知自动化引擎，你即将进行计算，这是对底层 Mustache 库的自定义扩展。

重要说明

Jira Cloud 提供了额外的数字处理功能，包括使用地区设置或自定义模式来格式化数字的功能。

让我们首先看看 Jira Cloud 和 Jira Server 之间共有的数学表达式。

数学表达式支持您期望看到的常见运算，如下表所示：

图 3.11 - 基本数学表达式运算符

除了基本运算外，数学表达式还支持布尔运算符，支持的运算符可以在下表中查看：

图 3.12 - 布尔数学表达式运算符

数学表达式还支持多种可用的函数，我们可以在下表中查看支持的完整函数列表：

图 3.13 - 支持的数学函数

这里还有一些常量值可以用于数学表达式，它们列在这里：

图 3.14 - 支持的常量值

除了前述的常见函数和操作外，Jira Cloud 还引入了一些额外的数字运算。这些运算不需要像我们之前学习的智能值块那样被包围，而是可以直接应用于数字智能值或字段。

让我们来看看这些额外的数字运算：

• abs：返回数字的绝对值

• round：返回四舍五入到最接近的整数的数字

• floor/ceil：分别返回数字的下限值或上限值

• plus(value)/minus(value)：将参数中的数字或智能值加到或减去调用该操作的数值或字段

• multiply(value)/divide(value)：将参数中的数字或智能值与调用该操作的数值或字段相乘或相除

• gt(value)/gte(value)：检查数值智能值是否大于或大于等于参数中给定的值

• eq(value)：检查数值智能值是否等于参数中给定的值

• lt(value)/lte(value)：检查数值智能值是否小于或小于等于参数中给定的值

Jira Cloud 还增加了使用智能值函数格式化数值的能力，以下是这些函数：

• format：使用美国地区的数字格式化数字字段。

• fr_CA。

• format(string pattern)：使用自定义模式格式化数字字段。您可以使用的模式依赖于底层的 Java 实现，可以在以下链接找到： https://docs.oracle.com/javase/tutorial/java/data/numberformat.html。

• asPercentage/asPercentage(string locale)：将数字字段格式化为美国地区的百分比，或按指定地区的百分比格式化。

• asCurrency/asCurrency(string locale)：将数值字段格式化为美国地区的货币格式，或者根据指定的地区格式化为相应的货币格式。

如我们所见，我们可以使用大量的智能值函数来执行自动化规则中的高级数学运算。现在，让我们通过一个例子来看看如何使用数学表达式。

创建一个规则，以保持史诗的原始预估与其子问题同步

在这个例子中，每当史诗下的相关问题的时间跟踪字段发生变化时，我们将更新史诗的原始预估。

1. 在您的软件项目中，导航至项目设置，点击自动化标签（如果使用的是 Jira Server，则点击项目自动化标签），然后点击创建规则。

2. 选择字段值更改触发器，在监控变化的字段列表中选择时间跟踪，然后点击保存。

3. 接下来，选择Epic

   Exists

4. 现在选择Epic (parent)并点击保存。

5. 然后，选择原始预估（系统）。

   将以下数学表达式添加到原始预估（系统）字段中，并点击保存：

   {{#=}}{{fieldChange.to}}/60 – {{fieldChange.from}}/60 + {{issue.original estimate}}/60{{/}}
   

   规则现在应该类似于以下截图：

   

   图 3.15 - 在规则中使用数学表达式

6. 最后，命名该规则为保持史诗预估同步，并点击启用以保存并启用该规则。

在本节中，我们看到了可以在自动化规则中使用的智能值数学函数的全面列表，并且学习了如何使用这些函数来操作数值。

总结

在本章中，您学习了如何通过使用智能值和智能值函数来增强自动化规则的功能。

我们学习了各种触发器设置的智能值，以及如何访问它们的属性或字段。此外，您还了解了智能值函数，以及如何在特定字段上单独使用它们，或者将它们链式组合以在单个步骤中对数据执行多个操作。

最后，我们了解了适用于日期、文本、列表和数值的各种智能值函数，以及如何使用这些函数格式化和操作数据，以创建极其强大且灵活的规则。

智能值及其相关函数几乎可以在自动化规则条件和动作中的每个字段中使用，接下来在本书的其余部分中，我们将学习它们如何帮助我们创建更强大、更丰富的规则。

在下一章中，我们将学习如何从自动化规则发送通知到不同的频道。

第四章：第四章：发送自动化通知

在合适的时间发送正确的通知，并附带相关的上下文信息，这是非常重要的。这样可以确保通知的接收者采取期望的行动。

Jira 一直有能力在问题发生变化时向用户发送电子邮件通知。然而，这些通知通常是非常通用的。它们不包含相关的上下文信息，而且定制起来非常困难。

自动化规则让我们能够克服一些限制，通过基于我们要求的任何规则条件发送自定义通知，而且不仅仅是通过电子邮件；我们还可以通过 SMS 向手机发送通知，并向 Slack 和 Microsoft Teams 等聊天应用发送通知。

本章将向你介绍自动化规则中的通知功能，并展示如何向用户、组或任何有效的电子邮件地址发送自定义电子邮件通知。我们还将学习如何向 Slack 渠道和 Microsoft Teams 渠道发送消息。最后，我们将学习如何使用 Twilio 通过 SMS 向移动设备发送文本消息。

在本章中，我们将涵盖以下主题：

• 使用自动化发送电子邮件通知

• 如何向 Slack 发送通知

• 如何向 Microsoft Teams 发送通知

• 使用 Twilio 发送 SMS 通知

技术要求

本章的要求如下：

• Jira Cloud 环境：如果你还没有 Jira 账户，可以在www.atlassian.com/software/jira/free创建一个免费的 Jira Cloud 账户，并确保选择了 Jira Software 和 Jira Service Management；或者

• Jira Server 环境：如果你使用的是 Jira Server（可从www.atlassian.com/software/jira/download下载），请确保你拥有 Jira Software 和 Jira Service Management 的许可证。此外，你还需要确保从 Atlassian Marketplace 安装了 Automation for Jira 应用。

在这两种情况下，你需要至少具有 Jira 项目的项目管理员访问权限。

你还需要访问以下任意工具：

• Slack：如果你还没有访问 Slack 的权限，可以在www.slack.com注册一个账户。

• Microsoft Teams：如果你还没有 Teams 账户，可以在teams.microsoft.com注册一个。

• Twilio：如果你需要账户，可以在www.twilio.com注册。

你可以从本书的官方 GitHub 仓库下载本章的最新代码示例，网址是github.com/PacktPublishing/Automate-Everyday-Tasks-in-Jira。

本章的《行动中的代码》视频可通过以下链接查看：bit.ly/2Y9p0cR

使用自动化发送电子邮件通知

Jira 一直以来都有通过电子邮件向用户发送通知的能力，例如在问题更新或评论添加时。你还可以定期向不同用户发送包含已保存筛选器结果的电子邮件，并且在 Jira Service Management 中，你可以创建自定义模板，通过电子邮件向客户发送通知，取代标准的事件通知。

通过自动化规则中的发送电子邮件操作，我们能够扩展这一能力，在规则被激活时向任何电子邮件地址、用户字段或用户组发送自定义电子邮件通知。

在本节中，我们将探讨如何在自动化规则中引入自定义电子邮件通知，以及这些通知如何为用户提供更具体的上下文。

提示

创建自动化规则中的自定义电子邮件通知时，你应该始终小心。确保不要因为同一事件而向用户发送多次通知，避免造成垃圾邮件。

在我们查看如何在规则中使用电子邮件通知之前，让我们快速看一下发送电子邮件操作本身。

以下截图展示了发送电子邮件操作中的可用字段：

图 4.1 – 发送电子邮件操作

让我们快速看一下发送电子邮件操作中的每个可用字段：

1. 收件人字段是我们配置电子邮件收件人的地方。可以是一个或多个电子邮件地址，或者你可以使用下拉菜单选择一个或多个 Jira 用户或用户组。你还可以使用智能值和智能值函数从问题字段中提取电子邮件地址。

   你还可以通过点击收件人字段下方的相应链接，按照相同的方式设置抄送和密送字段，以显示相关的输入字段。

2. 主题字段是我们配置电子邮件通知主题的地方。你可以在此字段中使用智能值和智能值函数来引用任何问题字段的数据。

3. 内容字段是你提供电子邮件消息的地方。你可以使用 HTML 标签来格式化消息，还可以使用智能值和智能值函数来引用和操作触发自动化规则的任何数据。

4. 在更多选项展开部分，你会找到发件人字段。该字段仅适用于 Jira Server 和 Data Center，在 Jira Cloud 中不可编辑。

   如果你使用的是 Jira Server 或 Data Center，应该确保你在此处输入的电子邮件地址使用有效的发件人域名，因为许多 SMTP 服务器配置为仅接受来自有效域的外发邮件，以防止它们被用作垃圾邮件中继。

5. 发件人名称 字段是邮件通知中显示的可读发件人名称。在 Jira Cloud 中，默认值为 Jira 自动化，而在 Jira Server 和 Data Center 中，该字段不会出现。

6. 可选地，如果你希望用户能够回复邮件，并可能将回复作为对问题的评论，你可以使用 回复至 字段，输入你在 接收邮件 系统配置中为软件和核心项目配置的邮箱地址，或者对于服务管理项目，在项目的 邮件请求 设置中进行配置。

   如果你使用 回复至 功能，还应该确保问题键出现在 主题 行中。

7. 发送方式 字段允许你选择该通知是以纯文本还是 HTML 格式发送。如果邮件通知是发送到其他应用程序，建议将其设置为纯文本。

8. 在 发送方式 字段设置为 HTML 时，每当新的一行出现时，要在消息正文中保留 <br>)。虽然这很方便，但如果忘记考虑这一点，可能会破坏你的 HTML 格式。

   重要提示

   如果你使用的是 Jira Server 或 Jira Data Center，你（或 Jira 管理员）需要在 Jira 管理 | 系统 | 外发邮件 设置中配置一个外发 SMTP 邮件服务器。如果没有配置外发邮件服务器，带有邮件通知的规则仍然会成功执行，但实际上不会发送任何邮件。

让我们来看一个使用邮件通知的规则。

创建一个规则，用于在发布新版本时通知客户

在这个示例中，我们希望能够在发布新软件版本时通知客户，并列出在新发布的版本中修复或添加的项。

所有的客户都属于一个名为 客户 的用户组。这样我们就可以将任何新客户添加到该组中，而无需为每个新客户修改自动化规则。

由于 Jira Cloud 和 Jira Server 在处理多个问题时的自动化规则有所不同，我们将分别展示该规则，以突出这两个环境之间的差异。

使用 Jira Cloud 通知客户当新版本发布时

在 Jira Cloud 中，我们需要使用 查找问题 动作，这将允许我们在一次操作中迭代最多 100 个问题。

让我们看看如何使用 Jira Cloud 构建这个规则：

1. 在你的 Jira Software 项目中，导航到 项目设置，点击项目设置菜单中的 自动化 链接，然后点击 创建规则。

2. 选择 版本发布 触发器并点击 保存。

3. 接下来，选择 新建动作，然后选择 查找问题 动作。

   将以下查询添加到 JQL 字段并点击 保存：

   fixVersion = {{version.name}}
   

   如你所见，我们在这个 JQL 查询中使用了智能值来引用版本名称，因此我们无法验证查询。

4. 然后，选择客户

   {{version.project.key}} 版本 {{version.name}} 已发布！

   内容：

   We have just released Version <strong>{{version.name}}</strong> for {{version.project.key}}.<br/>This version includes the following fixes and features:
   <ul>
   {{#lookupIssues}}
     <li>
       <a href="{{url}}">{{issuetype.name}}: {{key}} - {{summary}}<a/>
     </li>
   {{/}}
   </ul>
   We hope you enjoy it!<br/><br/>
   Regards,<br/>
   The {{version.project.key}} development team
   

5. 接下来，展开更多选项设置，取消勾选将换行符转换为 HTML 换行符选项，因为我们在内容字段中已包含显式的 HTML 换行符，然后点击保存。

   你的规则应类似于以下屏幕截图：

   

   图 4.2 – 在 Jira Cloud 中发送电子邮件通知

6. 最后，给你的规则命名为版本发布客户通知，并点击启用以保存并启用该规则。

现在我们已经学习了如何在 Jira Cloud 中使用查找问题操作发送电子邮件通知，接下来让我们看看如何调整此规则以便在 Jira Server 中使用。

使用 Jira Server 通知客户新版本发布时

Jira Server 中的自动化规则没有查找问题操作。相反，我们可以选择在某些触发器和分支规则中批量处理问题。

让我们看看如何在 Jira Server 中复制版本发布规则：

1. 在你的 Jira 软件项目中，导航到项目设置，点击项目设置菜单中的项目自动化链接，然后点击创建规则。

2. 选择版本发布触发器并点击保存。

3. 接下来，选择分支规则/相关问题，在相关问题类型字段中选择版本中修复的问题。

4. 展开更多选项设置，确保勾选批量处理此触发器产生的所有问题选项，然后点击保存。

5. 现在，选择客户

   {{version.project.key}} 版本 {{version.name}} 已发布！

   内容：

   We have just released Version <strong>{{version.name}}</strong> for {{version.project.key}}.<br/>This version includes the following fixes and features:
   <ul>
   {{#lookupIssues}}
     <li>
       <a href="{{url}}">{{issuetype.name}}: {{key}} - {{summary}}<a/>
     </li>
   {{/}}
   </ul>
   We hope you enjoy it!<br/><br/>
   Regards,<br/>
   The {{version.project.key}} development team
   

6. 接下来，展开更多选项设置，取消勾选将换行符转换为 HTML 换行符选项，因为我们在内容字段中已包含显式的 HTML 换行符，然后点击保存。

   你的规则应类似于以下屏幕截图：

   

   图 4.3 – 在 Jira Server 中发送电子邮件通知

7. 最后，给你的规则命名为版本发布客户通知，并点击启用以保存并启用该规则。

在本节中，我们已经学习了如何使用发送电子邮件操作通过自动化规则向用户发送自定义通知。

在下一节中，我们将看看如何在我们的自动化规则中集成 Slack 通知。

如何向 Slack 发送通知

Slack 是一个流行的工作空间通信工具，允许用户在所谓的频道中或通过直接消息互相聊天。

我们可用于自动化规则的一个操作是发送 Slack 消息操作，它使我们能够向 Slack 频道或个人用户发送消息。

在本节中，我们将学习如何与 Slack 集成，从自动化规则中发送通知。

与 Slack 集成

在我们开始通过自动化规则发送 Slack 通知之前，我们首先需要在 Slack 中设置传入 Webhook，以便能够接收来自 Jira 的消息。

我们可以通过两种方式来实现这一点。第一种是通过在 Slack 中创建一个自定义应用并配置一个传入 Webhook，然后选择将接收通知的频道。

将 Slack 与自动化规则集成的第二种且最简单的方式是创建一个传统的传入 Webhook，它还允许覆盖配置的频道。

重要提示

如果您使用 Slack 自定义应用方法创建传入 Webhook，您需要为每个需要发送通知的频道创建一个 Webhook，因为此方法不允许覆盖您创建 Webhook 时选择的默认频道。更好的方法是使用传统的 Webhook，我们将在本节中介绍它。

让我们来看看如何使用传统的传入 Webhook 选项在 Slack 中建立一个传入 Webhook，然后在自动化规则中使用它将消息发布到 Slack 中的#general频道：

1. 在浏览器中导航至以下网址：my.slack.com/services/new/incoming-webhook/。

   在要求登录后，您应该看到一个与以下截图相似的屏幕：

   

   图 4.4 – 将传入的 Webhook 添加到 Slack

2. 在发布到频道字段中，选择#general频道并点击添加传入 WebHooks 集成按钮。

3. 在以下屏幕中，您将看到您的新Webhook URL。您还可以使用此页面自定义集成时使用的图标、标签和用户名。现在，记录下生成的Webhook URL，因为稍后我们将需要它来完成自动化规则的设置。

现在我们已设置 Slack 通过 Webhook 接收传入消息，接下来我们需要设置一个自动化规则来利用这个集成。

创建一个规则来通知 Sprint 中的未解决问题

在本示例中，我们希望每天将开发团队的#sprint-update频道中的当前 Sprint 仍未解决的问题发送到 Slack：

1. 在您的 Jira 软件项目中，导航至项目设置，点击项目设置菜单中的自动化链接，然后点击创建规则。

2. 在每隔此规则运行字段中选择1 天，然后点击保存。

3. 接下来，选择新建操作，然后选择查找问题操作。

   在JQL字段中输入以下查询并点击保存：

   Sprint in openSprints() AND status != Done
   

4. 然后，选择#sprint-updates

   自动化规则应该类似于以下截图：

   

   图 4.5 – 发送 Slack 消息

5. 最后，给规则命名为 在冲刺中打开问题通知，并点击 开启 以保存并启用规则。

6. 现在你已经设置好了自动化规则，每天在你创建规则的时间，应该会在你配置的 Slack 频道中收到类似下面截图的通知：

图 4.6 – 在 Slack 频道接收通知

提示

在 Jira Server 中创建这个规则时，你需要在触发器配置中输入 JQL 查询，而不是使用 查找问题 动作，展开 更多选项，并确保选中 批量处理触发器产生的所有问题 选项。

在本节中，我们学习了如何将 Slack 通知集成到自动化规则中，并如何向 Slack 频道发送通知。在接下来的章节中，我们将探讨如何与 Microsoft Teams 集成，以类似于 Slack 的方式向 Teams 频道发送通知。

如何向 Microsoft Teams 发送通知

Microsoft Teams 是微软的协作平台，属于 Microsoft 365 套件的一部分。与 Slack 类似，它允许团队通过频道或直接消息与其他人进行协作。

正如我们在上一节中看到的，自动化提供了 发送 Microsoft Teams 消息 动作，允许我们向 Microsoft Teams 频道发送消息。

在本节中，我们将学习如何与 Microsoft Teams 集成，通过自动化规则向频道发送通知。

与 Microsoft Teams 集成

在我们能够在自动化规则中使用 Microsoft Teams 之前，首先需要设置传入 Webhook，这样我们的规则才能向 Teams 频道发送消息。

在 Microsoft Teams 中，我们需要将传入 Webhook 连接器添加到团队中，才能通过自动化规则向频道发送消息。

让我们来看一下如何使用 传入 Webhook 连接器 在 Microsoft Teams 中配置团队和频道：

1. 打开你的 Microsoft Teams 应用，并从侧边栏打开 Teams 应用商店。

2. 从菜单中选择 连接器，然后找到 传入 Webhook 连接器。

3. 在弹出的窗口中，点击 添加到团队，然后选择你想要添加连接器的团队和频道，并点击 设置连接器。

4. 在下一个界面中，给你的传入 Webhook 连接器命名，例如 Jira 通知，如果需要，可以上传新的图片，并点击 创建。

   下图显示了你新建的传入 Webhook 连接器的 URL，你需要复制它，以便在配置自动化规则时使用：

图 4.7 – 设置 Microsoft Teams 传入 Webhook 连接器

现在我们已经在 Microsoft Teams 中设置了传入 Webhook 连接器，可以在自动化规则中使用它来向我们配置的渠道发送通知。

创建规则以便在高优先级问题被提出时通知 Microsoft Teams 渠道。

在本示例中，我们将使用自动化规则监控提出的高优先级或最高优先级警报问题，并通过Microsoft Teams将通知发送到团队渠道：

1. 在你的 Jira 服务管理项目中，导航到项目设置，点击项目设置菜单中的自动化链接，然后点击创建规则。

2. 接下来，选择问题已创建触发器并点击保存。

3. 然后，选择新建 条件，接着选择问题字段条件。

4. 按照以下步骤完成字段设置，并点击Priority。

   是其中之一

   Highest, High

5. 接下来，选择新建操作，然后选择发送 Microsoft Teams 消息操作。

6. 按照以下步骤完成操作字段设置，并点击High Priority Ticket。

   消息：

   {{issue.key}} - {{summary}} has just been created with *{{issue.priority.name}}* priority.
   Your urgent attention is required.
   

   提示

   如果勾选了在消息中包含问题摘要选项，Microsoft Teams 中的通知将包括问题状态、问题类型和指派人信息，以及一个在 Jira 中查看按钮，点击后将打开 Jira 工单的网页。

   你的规则应与以下截图类似：

   

   图 4.8 – 使用 Microsoft Teams 发送消息

7. 最后，将规则命名为高优先级问题通知，点击启用以保存并启用该规则。

8. 在你的服务管理项目中创建一个新的高优先级或最高优先级问题时，将向你配置的 Microsoft Teams 渠道发送类似于以下截图的通知：

图 4.9 – 在 Microsoft Teams 渠道接收通知

在这一部分，我们学习了如何在 Microsoft Teams 中设置传入 Webhook 连接器，并如何在自动化规则中使用它向配置的团队渠道发送通知。

在下一部分，我们将讨论如何使用Twilio向手机发送短信通知。

使用 Twilio 发送短信通知

Twilio 是一个提供云服务的通信平台，允许开发者通过REST API将语音、视频和文本通信集成到他们的应用程序中。

在我们的自动化规则中使用发送 Twilio 通知操作，可以利用 Twilio 平台向手机发送短信。

在实际操作中，您通常会使用集成了 Jira 的专用值班工具，该工具能够通过各种方式，包括通过手机短信，使用可自定义计划联系正确的团队成员。然而，发送 Twilio 通知操作将允许您使用自动化规则构建一个简单的值班计划。

在本节中，我们将学习如何通过自动化规则集成 Twilio，以便将通知作为短信消息发送。

与 Twilio 集成

与 Twilio 集成是一个相对简单的过程。您需要一个 Twilio 账号和一个从中发送 SMS 消息的电话号码。

重要提示

Twilio 账户免费设置，并且您可以免费获得试用号码。但是，您将需要支付通过平台发送的每条 SMS 消息的费用，并且您需要为您选择的国家购买电话号码。

让我们看看如何设置 Twilio，以便我们可以从我们的自动化规则发送短信消息：

1. 导航至www.twilio.com，注册一个账号或者登录您现有的账号。

2. 如果您还没有电话号码，请在项目仪表板上点击获取试用号码按钮。

   一旦您有了电话号码，您的 Twilio 仪表板应该看起来类似以下的截图：

   

   图 4.10 – 设置 Twilio 账号

3. 当我们配置自动化规则时，您需要从 Twilio 仪表板复制您的试用号码、账户 SID 和授权令牌信息。要复制您的账户 SID和授权令牌字段，您可以点击各字段右侧的图标。

现在我们有了 Twilio 账号和电话号码，我们可以创建一个自动化规则来发送短信到手机上。

创建一个规则以通过短信消息发送工作时间外通知

在这个例子中，对于任何优先级为最高或高，并且在早上 8 点之前或下午 6 点之后提出的事件，我们将使用Twilio向手机发送短信通知。

为了简单起见，我们假设有一个单独的移动设备，由负责在工作时间外值班的团队成员使用。

让我们创建一个发送短信消息的规则：

1. 在您的 Jira 服务管理项目中，导航至项目设置，点击自动化链接在项目设置菜单中，然后点击创建规则。

2. 接下来，选择问题创建触发器并点击保存。

3. 然后，选择问题类型

   等于

   事故

4. 现在点击保存，这样我们就可以添加我们的下一个条件。

5. 选择优先级

   是其中之一

   最高，高

   点击保存，这样我们就可以继续我们的最后一个条件。

6. 然后选择新条件，然后选择JQL 条件，输入以下JQL查询并点击保存：

   NOT(created > startOfDay("+8h") AND created < endOfDay("-6h"))
   

7. 接下来，选择新操作，然后选择发送 Twilio 通知操作。

   按如下方式填写字段，然后点击 保存：

   Account SID：从你的 Twilio 仪表板复制账户 SID。

   Auth token：从你的 Twilio 仪表板复制认证令牌。

   From：从你的 Twilio 仪表板复制试用号码或电话号码。

   To：以国际格式填写要发送短信的手机号码。

   消息正文：

   A new incident, {{issue.key}} - {{issue.summary.abbreviate(100)}}, requires urgent attention!
   

   你的自动化规则应类似于以下截图：

   

   图 4.11 – 通过 Twilio 发送短信

8. 最后，命名规则为 高优先级非工作时间通知，然后点击 开启 以保存并启用规则。

9. 在 Service Management 项目中创建一个优先级为高或最高的 issue 时，应该会发送一条短信，内容与以下截图相似：

图 4.12 – 通过 Twilio 接收短信通知

在本节中，我们已经学习了如何使用 Twilio 平台通过 SMS 向手机号码发送短信通知。发送短信通知的能力为你提供了另一种渠道，确保通知能够及时送达，并传达预期的紧急程度。

概述

在本章中，你已学会了如何使用自动化规则向用户、用户组或任何有效的电子邮件地址发送自定义电子邮件通知。

你还学会了如何向两个最广泛使用的聊天系统，Slack 和 Microsoft Teams 发送通知。

最后，我们已经学习了如何与 Twilio 集成，通过 SMS 向手机发送文本消息。

凭借这些技能，你现在可以利用自动化规则在恰当的时间发送定制通知，并附带相关的上下文信息，这将鼓励用户采取预期的行动。

在下一章中，我们将探讨如何使用自动化规则与可以接受 web 请求的外部系统集成，以及如何接受来自外部系统的请求。

第五章：第五章：与外部系统的交互

应用程序很少是孤立存在的。它们通常专注于做一件事，但为了真正有用，它们需要与组织中的其他应用程序共同存在。

这尤其适用于 Jira，这一点可以在 Atlassian Marketplace 中看到，在大量可用应用程序中，数百个仅用于将 Jira 与其他应用程序和系统集成。

即使有许多与各种应用程序的集成插件可供 Jira 使用，仍然会有一些情况，所需的集成未被涵盖，或者现有的集成无法完全满足你的特定需求。

近年来，许多应用程序和系统都采用了基于 JSON 的 REST API，以便使第三方系统能够与它们集成，而 Jira 中的自动化规则为我们提供了利用这些 API 所需的组件。

在本章中，我们将学习如何通过自动化规则向外部系统发送请求，并如何处理从这些请求返回的数据。此外，我们还将探讨如何使用自动化规则设置传入的 Webhooks，以便监听来自外部系统的请求并触发规则。

本章将涵盖以下主题：

• 如何向外部系统发送请求

• 处理从请求中返回的数据

• 如何使用传入 Webhooks 接收请求

• 处理传入 Webhooks 中的数据

技术要求

本章的要求如下：

• Jira Cloud 环境：如果你还没有访问 Jira 的权限，可以在www.atlassian.com/software/jira/free创建一个免费的 Jira Cloud 账户，并确保选择了 Jira Software 和 Jira Service Management。

• Jira Server 环境：如果你使用 Jira Server（可以从www.atlassian.com/software/jira/download下载），确保你拥有 Jira Software 和 Jira Service Management 的许可证。此外，你还需要确保安装来自 Atlassian Marketplace 的Automation for Jira应用。

• Confluence Cloud 环境：如果你还没有访问 Confluence 的权限，可以通过 Jira Cloud 实例中的应用切换菜单在你的云账户中设置 Confluence 网站。如果你没有 Jira Cloud 账户，可以在www.atlassian.com/software/confluence/free设置一个免费的 Confluence Cloud 账户。

• Confluence Server 环境：如果你使用 Jira Server，可以从www.atlassian.com/software/confluence/download下载并安装 Confluence Server，或者你可以创建并使用 Confluence Cloud 账户。

在这两个实例中，你需要至少拥有项目管理员权限，才能按照本章的示例进行操作，权限要求分别是 Service Management 项目和 Scrum Software 项目。我们在本章示例中使用了IT 服务管理项目模板来创建 Service Management 项目，并使用Scrum 软件项目模板来创建软件项目。

你可以从本书的官方 GitHub 仓库下载本章的最新代码示例，地址为github.com/PacktPublishing/Automate-Everyday-Tasks-in-Jira。本章的《代码实战》视频可以在bit.ly/2LJAJvN找到。

如何向外部系统发送请求

从自动化规则中向外部系统发送请求，打开了一个全新的极其强大的可能性领域。此功能可以用来发送通知，或将数据或任何自定义数据发送到任何接受通过 HTTP 或 HTTPS 进行网络请求的应用程序或系统。例如，你可以使用此功能触发在构建工具（如 Bamboo 或 Jenkins）中的构建过程，或在支持此功能的集中式用户目录系统中发起密码更改。

在本节中，我们将了解发送网络请求组件，并如何在自动化规则中使用它来向外部系统发送请求。我们将从查看操作中可用的各种配置选项开始。

在下方的截图中，我们可以看到发送网络请求操作的配置选项：

图 5.1 – 配置发送网络请求操作

让我们逐一查看配置屏幕中的每个字段，并了解我们如何使用它：

1. 使用urlEncode确保智能值正确编码。例如，你应该在字段中插入{{issue.key.urlEncode}}。

2. Headers字段是你添加外部系统所需的任何 HTTP 请求头的地方，例如Authorization头，允许你向远程系统提交凭证或授权令牌，或Content-Type头，它告知远程系统你将要发送的数据的性质。在我们的示例中，我们将在发布版本说明到 Confluence 时使用这两个头。

   提示

   请求头名称通常不区分大小写。然而，你应始终确保使用官方规范中定义的大小写，以避免任何意外结果。维基百科维护了一份标准请求头的便捷列表，包含每个头部的示例接受输入，网址为en.wikipedia.org/wiki/List_of_HTTP_header_fields。

   你可以通过点击 名称 字段下方的 添加 链接，添加尽可能多的 HTTP 请求头。如果你需要删除一个头部，可以通过使用 值 字段右侧的垃圾桶图标来删除。

3. HTTP 方法 字段允许你选择外部资源执行所选操作所需的正确方法。发送网络请求 操作支持以下标准 HTTP 方法：

   获取: 通常用于从外部系统中检索资源。

   发布: 通常用于使用请求体中的数据在外部系统中创建资源。

   替换: 通常用于替换资源，或者在资源不存在时创建它，资源数据位于请求体中。

   修补: 通常用于更新资源，更新后的数据位于请求体中。

   删除: 通常用于从外部系统中删除资源。

4. 在以下链接获取问题：developer.atlassian.com/cloud/jira/platform/rest/v3/api-group-issues/#api-rest-api-3-issue-issueidorkey-get。

   自定义数据: 选择此选项将显示 自定义数据 字段（6）。通常在使用 发布、替换 或 修补 方法时，如果外部系统不期望 Jira 问题格式的数据，就需要此选项。

5. {{webhookResponse}} 智能值字段。我们将在下一节中详细探讨这一点，处理来自请求的返回数据。

6. {{issue.description.abbreviate(255).jsonEncode}} 以确保描述字段的内容得到正确编码。

   提示

   始终确保在发送自定义数据时，使用 Headers 字段指定正确的内容类型，并通过 Content-Type 头名称告知外部系统。例如，如果你发送的是 JSON 数据，将 Content-Type 设置为 application/json，或者对于 XML 数据，设置为 application/xml。

7. 一旦你已经配置了正确的 URL、头部、方法和可选数据，你应该始终测试生成的请求和接收到的响应是否符合预期。

   你可以通过展开 验证你的 Webhook 配置 并点击 验证 链接来完成此操作。提供一个可选的问题密钥将确保在验证过程中替换任何智能值。

   当你点击 验证 链接时，将会生成一个包含你配置的选项和数据的请求，并发送到外部系统，接收到的响应会被捕获并呈现给你，类似于以下截图：

图 5.2 – 验证网络请求配置

如你所见，验证请求将返回从外部系统接收到的响应，以及生成并发送到外部系统的请求。展开负载（Payload）部分将显示通过 Web 请求接收和发送的实际数据，让你确保双向数据符合预期。

现在我们已经了解了发送 Web 请求的各种配置选项，让我们看看如何在自动化规则中使用这些选项。

创建一个规则，将发布说明发布到 Confluence

在第四章《发送自动化通知》中，我们向你展示了如何创建规则，在 Jira 发布软件版本时向各个相关人员发送电子邮件通知。

我们将在本示例中重新审视该规则。然而，我们将不再在发布版本时发送电子邮件通知，而是通过发送 Web 请求操作将页面发布到 Confluence。

在这个示例中，我们创建了一个新的 Confluence 空间和一个发布页面。各个发布说明页面将作为“发布”页面的子页面创建。

为了简化操作，我们将在 Confluence 中创建一个发布说明模板页面，页面中填充了所有相关的智能值。我们有了模板后，需要复制该页面的存储格式，以便将其包含在自动化规则中的发送 Web 请求主体中。

在下图中，我们可以看到已完成的模板，并且可以查看页面的存储格式：

图 5.3 – 获取发布说明模板页面源代码

将存储格式视图中的所有代码复制到文本编辑器中，然后我们将按如下方式修改{{#lookupIssues}}部分，以确保智能值替换按预期工作：

<ul>
{{#lookupIssues}}
<li><p>{{key}} - {{summary}} </p></li>
{{/}}
</ul>

接下来，我们将通过在代码中的双引号前添加反斜杠来转义所有双引号字符，并删除所有换行符，这样整个代码就会在一行内。

提示

当我们与 Confluence 配合使用时，采用存储格式，这样我们可以访问页面的底层 HTML 格式，包括用于定义页面中各种 Confluence 宏的 XML，并且能更灵活地调整发布页面时显示的最终内容。

最后，我们需要确保你拥有一个有效的 API 令牌，该令牌将在规则中授权 Web 请求时使用：

1. 访问id.atlassian.com/manage-profile/security/api-tokens，点击创建 API 令牌。

   重要提示

   你不能在自动化规则中使用的账户启用双重身份验证。双重验证是为有访问辅助设备的人类用户设计的，无法在自动化系统中实现。

2. 给你的令牌起个标签，比如 自动化规则，然后点击 创建。

3. 将令牌保存在安全的地方，因为关闭弹出窗口后你将无法检索它。

4. 我们现在需要对凭证进行编码，以便在自动化规则中使用。你可以使用像 www.base64encode.org 这样的在线工具进行编码。

   输入你的电子邮件地址，紧跟其后输入冒号（:），然后输入你的 API 令牌，点击 编码 按钮，然后将生成的编码值保存在安全的地方。

   提示

   如果你使用的是 Confluence Server，你只需要一个可以在 Confluence 空间中创建页面的用户的用户名和密码。要对凭证进行编码，将前面的 第 4 步 中的电子邮件地址替换为用户名，将 API 令牌替换为用户的密码。

现在，让我们开始构建自动化规则：

1. 在你的 Jira 软件项目中，导航到 项目设置，点击 项目设置 菜单中的 自动化 链接，然后点击 创建规则。

2. 选择 版本发布 触发器，然后点击 保存。

3. 接下来，选择 fixVersion = "{{version.name}}"

4. 然后，选择 https://<your_site>.atlassian.net/wiki/rest/api/content

   第一步 Content-Type

   application/json

   第二步 Authorization

   Basic <你的 base64 编码凭证>

   POST

   自定义数据

5. 我们需要获取发布说明页面的页面 ID，因为它将作为我们发布页面的父页面。为此，导航到 Confluence 中的发布说明页面，然后点击 JSON 中的 ancestors 项。

   你还需要确保使用正确的 Confluence 空间密钥。在我们的示例中，这是 MA。

   {
       "type": "page",
       "title": "Version {{version.name.jsonEncode}}",
       "space": {
           "key": "MA"
       },
       "ancestors": [
           {
               "id": "33051"
           }
       ],
       "body": {
           "storage": {
               "value": "<table data-layout=\"default\"><colgroup><col style=\"width: 212.0px;\" /><col style=\"width: 416.0px;\" /></colgroup><tbody><tr><th><p><strong>Version</strong></p></th><td><p>{{version.name.jsonEncode}}</p></td></tr><tr><th><p><strong>Release Date</strong></p></th><td><p>{{version.releaseDate.jiraDate}}</p></td></tr><tr><th><p><strong>Issues in this release</strong></p></th><td><p>{{lookupIssues.size}}</p></td></tr></tbody></table><h1>Summary</h1><p>{{version.description.jsonEncode}}</p><h1>Issues</h1><p>This release contains the following updates and fixes:</p><ul>{{#lookupIssues}}<li><p>{{key}} - {{summary.jsonEncode}}</p></li>{{/}}</ul>",
               "representation": "storage"
           }
       }
   }
   

   如果 JSON 结构与上面的代码类似，将 JSON 复制到 自定义数据 字段中，之后你的规则应该类似以下截图：

   

   图 5.4 – 配置发送 Web 请求

6. 最后，点击 发布发布说明到 Confluence，然后点击 开启 以保存并启用该规则。

   当你在 Jira 软件项目中发布版本时，你应该在 Confluence 中的 发布说明 下有一个类似以下截图的已发布页面：

图 5.5 – 自动化规则发布的发布说明

我们现在已经学习了如何使用自动化规则向外部系统发送 Web 请求。在下一节中，我们将扩展这一点，看看如何将从外部系统返回的数据纳入后续规则组件中。

使用请求返回的数据

许多系统在集成时不仅会接收你发送的数据，还会根据请求返回额外的数据。通过自动化规则，我们能够获取请求的响应，并在后续的条件和操作中利用这些数据。这个功能让我们的规则更加灵活和强大，因为我们现在可以根据外部系统返回的具体内容来做决策和执行操作。

在配置{{webhookResponse}}时，使用来自外部系统的响应。

{{webhookResponse}}智能值包含许多字段，你可以在后续的规则组件中访问这些字段，具体如下：

• 成功请求返回200或201，重定向和错误则在300到599范围内。你可以在en.wikipedia.org/wiki/List_of_HTTP_status_codes查找更多关于 HTTP 响应代码的信息。

• {{webhookResponse.headers.Content-Type}}将获取外部系统返回的Content-Type头信息。

• {{webhookResponse.body}}：body 字段将包含外部系统返回的响应主体。如果外部系统的响应是 JSON 对象，你可以使用点符号访问任何字段。

• {{webhookResponses}}：如果你的规则中有多个发送 Web 请求动作，每个响应（如果有）都会被添加到这个列表中，你可以使用我们在第三章《使用智能值增强规则》中讲解的智能值列表函数来处理列表项。

现在，让我们来看一下如何将来自 Web 请求的响应纳入自动化规则。

创建一个规则，将事件管理者添加为观察者

在这个例子中，我们将在第一章，《自动化的关键概念》中，添加我们在 VIP 组中创建的成员作为观察者，给那些优先级设置为最高的、无论是已创建还是已更新的问题。

由于 Jira 本身具有强大的 REST API，我们可以将其视为自动化规则中的外部系统，获取通常无法访问的数据，并将其用于我们的规则中。

让我们来看一下规则：

1. 在你的 Jira 服务管理项目中，导航至项目设置，点击项目设置菜单中的自动化链接，然后点击创建规则。

2. 选择问题创建和问题更新，然后点击保存。

3. 现在选择问题类型

   equals

   事件

4. 然后选择优先级

   equals

   最高

5. 接下来，选择https://<your_site.domain.com>/rest/api/3/group/member?groupname=VIP

   授权

   基本 <your base64-encoded credentials>

   GET

   空

   等待响应：选择复选框

   这个 API 调用的响应会返回一个包含属于我们在查询参数中指定的groupname的用户列表，这个列表位于values数组中，类似于以下内容：

   {
     "values": [
       {
         "self": "https://<your-site>.atlassian.net/rest/api/3/user?accountId=5b10a2844c20165700ede21g",
         "name": "Joe Soap",
         "key": "jsoap",
         "accountId": "5b10a2844c20165700ede21g",
         "emailAddress": "joe.soap@company.com",
         "avatarUrls": {},
         "displayName": "Joe Soap",
         "active": true,
         "timeZone": "Europe/London",
         "accountType": "atlassian"
       }
     ]
   }
   

   您可以在 developer.atlassian.com/cloud/jira/platform/rest/v3/api-group-groups/#api-rest-api-3-group-member-get 找到有关此 API 调用的更多信息。

6. 要完成规则，选择{{webhookResponse.body.values.accountId}}

   您的规则应类似于以下截图：

   

   图 5.6 – 在规则中使用 webhookResponse 数据

7. 最后，点击Add watchers to Highest priority incidents，然后点击Turn it on以保存并启用规则。

在本节中，我们学习了如何暴露外部系统请求返回的响应，并且我们可以如何利用这些数据创建更强大的自动化规则。

在下一部分，我们将学习如何监听来自外部系统的 web 请求，以及如何利用这些请求来触发我们的自动化规则。

如何通过传入的 webhook 接收请求

在前两节中，我们学习了如何使用自动化规则向外部系统发送通知和数据，并且如何处理从外部系统接收到的响应数据。

此外，自动化规则还允许我们使用Incoming webhook触发器接收来自外部系统的通知和数据。该组件将为每个触发器创建一个唯一的 URL，外部系统可以调用该 URL，并触发自动化规则的运行。这些传入的 webhook 可以接收待处理的 issue 列表以及以 JSON 对象形式提供的自定义数据，后者可用于后续规则组件中，通过条件作出决策，或使用提供的自定义数据创建或更新 issues。

以下截图显示了Incoming webhook触发器的配置选项：

图 5.7 – 配置传入的 webhook 触发器

现在让我们来看一下每个配置选项的工作原理：

1. Webhook URL 是唯一的 URL，当外部系统向它发送 HTTP POST 请求时，将触发规则的运行。

   此 URL 是自动生成的，使用时无需认证。如果 URL 被泄露，您可以使用Regenerate链接生成一个新的 URL，并更新任何使用该 URL 的外部系统。

   重要提示

   传入的 webhook 仅支持 HTTP POST 方法。它们不会响应 HTTP GET 或任何其他方法。此外，您需要确保发送请求到 webhook 的外部系统将 Content-Type 请求头设置为 application/json。

2. issue，例如，https://automation.atlassian.com/pro/hooks/<unique-webhook-token>?issue=MAPP-1。要指定多个 issue，应在 JSON 格式的请求体中包含一个名为 "issues" 的列表，并在该列表中包含 issue 键或 issue ID，如下所示：

   {
       "issues": [
           "MAPP-1",
           "MAPP-2",
           "10123"
       ]
   }
   

   通过运行以下 JQL 查询提供的问题将显示JQL字段（3），允许你输入 JQL 查询来搜索相关问题。

   Webhook 没有问题意味着 Webhook 不期望操作任何现有问题。如果需要在 Webhook 调用时创建问题，可以使用此选项。

3. 如上所述的第 2 步，当你使用通过运行以下 JQL 查询提供的问题选项时，会显示JQL字段，允许你定义一个 JQL 查询，以返回在调用 Webhook 时将被更新的问题。你可以在查询中使用智能值和函数。然而，使用这种方法时，你无法通过验证查询链接验证查询。

现在让我们来看看如何使用传入 Webhook 触发我们所看到的自动化规则，以便配置传入 Webhook。

使用自动化 Webhook 创建解决开放问题的规则

许多软件项目都有某种形式的自动化构建和部署工具，用于自动化构建、测试和部署代码。

在这个例子中，我们假设开发人员在完成开发后，会将问题移动到等待部署状态。当我们的自动化部署开始时，我们希望通过让我们的构建和部署工具在 Jira 中创建一个自动化规则，自动解决当前开放冲刺中所有等待部署的问题。

在我们的 Jira 软件项目中，我们使用的是简化软件工作流程，因此我们将从项目设置屏幕编辑工作流程，添加一个新的等待部署状态，并允许所有状态过渡到此状态。此外，添加解决问题屏幕到完成过渡，以便在解决问题时允许添加评论。

既然我们已经调整了工作流程以考虑到这个新状态，接下来让我们创建自动化规则：

1. 在你的 Jira 软件项目中，导航到项目设置，点击项目设置菜单中的自动化链接，然后点击创建规则。

2. 选择通过运行以下 JQL 查询提供的问题

   sprint in openSprints() AND status = "Waiting for deploy"

3. 现在，在目标状态字段中选择完成。

4. 此外，我们还希望向这些问题添加评论，表明问题是由构建系统自动解决的。

   为此，展开更多选项面板，在附加字段编辑器中添加以下 JSON，然后点击保存：

   {
       "update": {
           "comment": [
               {
                   "add": {
                       "body": "Issue automatically resolved by build system"
                   }
               }
           ]
       }
   }
   

   你的规则现在应该类似于下图所示：

   

   图 5.8 – 配置带有传入 Webhook 的规则

5. 最后，将你的规则命名为Release issues waiting for deploy，并点击开启以保存并启用规则。

在这一部分中，我们学习了如何创建和使用传入的 webhook 来触发自动化规则。在下一部分中，我们将学习如何利用外部系统提供的数据进一步增强我们的自动化规则。

在传入 webhook 中处理数据

能够从外部系统触发 Jira 中的操作使您能够创建非常强大的自动化规则集成。

正如我们在前一部分看到的，您可以通过将特定问题包括在传入请求体中来对其进行操作。但是，借助{{webhookData}}智能值，您可以使用点表示法访问任何 JSON 对象字段。

这个强大的功能将使您能够与任何可以发送 web 请求的外部系统进行集成，并提取有价值的数据以用于您的问题。例如，您可以设置监控工具，在事件发生时向自动化规则发送通知，并使用它提供的数据创建一个新事件，并根据哪个资产导致事件来设置受影响的组件。

现在让我们看看如何配置一个自动化规则，利用传入的 web 请求中的自定义数据。

创建一个规则，通过自动化 webhook 来提升新的问题

当发生错误时，能够收集关于已部署软件的信息对许多开发者来说是非常宝贵的，许多软件应用程序允许用户在发生错误时提交反馈。

在这个示例中，我们将创建一个自动化规则，使用传入的 webhook 接收一个错误报告，并自动在我们的 Jira 项目中创建一个错误来跟踪它。

我们将期望处理一个具有以下结构的 JSON 对象来处理这些传入的信息：

{
    "summary": "some summary text",
    "bugDescription": "some descriptive text",
    "softwareVersion": "version string"
}

如果您将其包括在产品中，您可能还可以向 JSON 结构中添加更多相关数据，如堆栈跟踪，以使错误报告更具上下文。

现在让我们看看如何构建这个自动化规则：

1. 在您的 Jira 软件项目中，导航到项目设置，点击项目设置菜单中的自动化链接，然后点击创建规则。

2. 选择No issues from the webhook，因为我们将使用此规则来创建一个问题。然后点击保存。

3. 接下来，选择Same project

   Bug

   {{webhookData.summary}}

   {{webhookData.bugDescription}}

4. 我们还希望捕获在提交此错误时部署的软件版本，并希望向问题添加一些标签，以便更容易地找到通过产品内反馈收集器提出的错误。

   为此，展开更多选项，然后将以下 JSON 添加到附加字段编辑器：

   {
       "fields": {
           "versions": [
               { "name": "{{webhookData.softwareVersion}}" }
           ],
           "labels": [
               "bugfix",
               "feedback"
           ]
       }
   }
   

   现在您的规则应该类似于以下屏幕截图：

   

   图 5.9 – 消费传入的 webhook 数据

5. 点击In-product bug collector，然后点击开启以保存并启用该规则。

你现在已经学会了如何在传入的 Web 钩子中获取外部系统的请求数据。

能够消费来自外部系统的传入数据，并利用这些数据做出决策，使用自动化规则对问题进行更改，给你提供了在 Jira 中自动化项目的一些强大选项。

总结

在本章中，你已经学会了如何通过发送 Web 请求将外部系统集成到自动化规则中，并且了解了如何使用智能值和智能值函数将自定义数据包含在这些请求中。

我们还学会了如何确保我们能够接收到来自外部系统请求的响应，并且如何提取数据以便在后续的规则组件中使用。

接下来，我们学习了如何使用自动化规则设置传入的 Web 钩子，监听来自外部系统的请求，并且如何可选地处理请求体中发送的数据，并在后续的规则组件中使用这些数据。

正如我们在本章中所看到的，通过使用自动化规则与外部系统集成的能力为你的 Jira 项目开辟了无限可能。例如，当你在 Jira Software 中发布版本或完成冲刺时，你可以通过构建工具启动软件构建或部署。在 Service Management 中，你可以集成用户目录服务，根据服务请求自动创建新账户或自动重置密码（如果支持的话）。

在下一章，我们将探讨如何运用本章以及前几章中学到的技能，在 Service Management 实例中帮助构建自动化。

第三部分：带自动化的高级用例

在本节中，我们将专注于针对 Jira Service Desk 和 Jira Software 的高级用例，随后我们将介绍最佳实践和一些故障排除技巧。最后，我们将简要介绍如何在 Jira 云和 Jira 服务器上使用脚本进行高级自动化。

本节包含以下章节：

• 第六章，自动化 Jira 服务管理

• 第七章，自动化 Jira 软件项目

• 第八章，与 DevOps 工具的集成

• 第九章，最佳实践

• 第十章，故障排除技巧与方法

• 第十一章，超越自动化：脚本简介

第六章：第六章：自动化 Jira Service Management

今天，许多组织使用 Jira Service Management 提供客户支持门户、人力资源（HR）服务以及信息技术（IT）服务台等。

然而，Jira Service Management 最常见的使用案例是作为IT 服务管理（ITSM）解决方案，帮助高效提供组织内的 IT 服务。

提高效率、降低 IT 服务台请求每票成本的最佳方法之一是尽可能自动化琐碎的任务和流程。

一些最常见的任务，自动化能够提供即时的好处，包括票据分类与路由、实时更新客户请求状态、维护服务水平协议（SLA）的合规性、解放支持人员从重复性任务中脱身，并关闭过时的请求，确保它们不会堵塞请求队列。

在本章中，我们将涵盖以下主题：

• 处理来往请求

• 监控 SLA 合规性

• 自动化常见的重复任务

在本章结束时，你将更好地理解如何在 Jira Service Management 中使用自动化规则来提高服务台的效率。此外，减少完成常见任务所需的人为干预，也将降低每个服务台请求的成本。

技术要求

本章的要求如下：

• Jira Cloud 环境：如果你尚未访问 Jira，你可以在www.atlassian.com/software/jira/free创建一个免费的 Jira Cloud 账户，并确保你选择了Jira Software和Jira Service Management。

• Jira Server 环境：如果你使用的是 Jira Server（可从www.atlassian.com/software/jira/download下载），请确保你拥有 Jira Software 和 Jira Service Management 的许可证。此外，你还需要确保安装来自 Atlassian 市场的Automation for Jira应用。

• Microsoft Azure Active Directory（Azure AD）：Azure AD 是微软的基于云的身份服务。你可以在azure.microsoft.com/free注册一个免费的 Azure 账户。

在这两种情况下，你需要至少具有项目管理员权限，才能在服务管理项目和 Scrum 软件项目中执行本章中的示例。对于本章中的示例，我们使用了IT 服务项目模板来创建服务管理项目，并使用Scrum 软件项目模板来创建软件项目。

你可以从本书的官方 GitHub 仓库下载本章的最新代码示例，链接为github.com/PacktPublishing/Automate-Everyday-Tasks-in-Jira。请访问以下链接查看 CiA 视频：bit.ly/2NhMFp9

处理传入请求

服务台中较为耗时的任务之一是将收到的请求分类并将其分发到正确的团队。

拥有一个成熟的服务请求目录，并将其作为基础在 Jira 服务管理门户中创建相关的请求类型，可以解决客户创建请求时的初步分类问题；然而，在许多组织中，仍然通过电子邮件接收请求，这些请求通常需要人工干预来分类并将其路由到相关团队。

在本节中，我们将探讨自动化规则，自动处理传入的请求，并将其路由到正确的团队进行处理。

在第一个示例中，我们将查看如何使用自动化规则来处理来自电子邮件的请求。

创建一个规则来处理电子邮件请求

拥有一个结构良好的客户门户的好处之一是，你可以利用组织的服务请求目录，通过请求类型推动正确的服务请求选择，同时使用每个服务请求中的预选组件来缩小请求的分类范围。

提示

要为请求类型中的任何字段预定义一个值，可以将该字段添加为请求表单中的隐藏字段。这样做会强制你为该字段提供一个默认值，之后可以在自动化中使用这个默认值。

这种方法确保了到达服务台队列的票据已经按正确的组件进行了分类，我们可以利用这些组件来推动自动化流程。

然而，电子邮件请求仍然被广泛用于创建服务台请求，这些请求通常会进入一个服务队列，需要人工干预以进行初步分类和正确归类。

在这个例子中，我们将使用一个自动化规则来处理并根据电子邮件中某些特定关键词的出现对传入的电子邮件进行分类。为了简化起见，我们只检查问题摘要，这个摘要是从电子邮件主题设置的。

让我们来看看这个规则，如下所示：

1. 在你的 Jira 服务管理项目中，导航到项目设置，点击项目设置菜单中的自动化链接，然后点击创建规则。

2. 选择问题已创建触发器并点击保存。

3. 然后，选择请求类型

   equals

   电子邮件请求

4. 接下来，选择摘要

   contains

   vpn

5. 从VPN 服务器组件中选择组件字段并点击保存。

6. 点击摘要

   contains

   password

7. 现在，从Active Directory组件中选择组件字段并点击保存。

8. 规则现在应该与以下截图中的规则类似：

   图 6.1 – 处理来邮件请求

9. 你可以继续为需要的每个组件添加 else-if 块；不过，在这个例子中，我们就此停止，命名规则为Triage email requests，然后点击启用来保存并启用该规则。

现在我们已经学会了如何分类通过电子邮件接收到的来请求，让我们看看如何将这一过程扩展到路由和分配请求给正确的团队。

创建自动路由请求的规则

使用自动化规则自动分类来请求将有助于缩短工单处理的响应时间。然而，我们可以更进一步，自动将请求路由并分配给正确的团队，进一步缩短响应和解决时间。

在这个例子中，我们将利用为每种请求类型预定义组件的功能，并使用这些组件将来请求分配给正确的团队。此外，我们将确保我们之前创建的自动分类规则能够输入到此规则中。

我们将提到网络团队和系统管理员团队用户组，因此你需要在你的实例中创建这些用户组，以确保规则能够正常工作。

让我们开始创建规则，如下所示：

1. 在你的 Jira Service Management 项目中，导航至项目设置，点击项目设置菜单中的自动化链接，然后点击创建规则。

2. 选择问题已创建和问题已更新，然后点击保存。

3. 接下来，选择组件

   包含任何

   VPN 服务器

4. 然后，选择用户在组中

   平衡工作负载

   网络团队

5. 点击组件

   包含任何

   Active Directory

6. 点击Summary

   不包含

   密码

7. 现在，选择用户在组中

   平衡工作负载

   系统管理员团队

8. 你可以继续添加更多的 Else-If 块来路由更多的请求；不过，在这个例子中，我们只会创建这两个条件。

9. 在我们保存此规则之前，我们需要确保它能够通过分类来邮件的规则触发。

10. 点击Route incoming requests

    允许规则触发：确保勾选此框

    你的规则现在应该与以下截图中的规则类似：

    

    图 6.2 – 路由来请求

11. 最后，点击保存，然后点击启用来保存并启用规则。

在这一部分，我们学会了如何使用自动化规则来处理 Jira Service Management 中的来请求，首先在适当的情况下对它们进行分类，然后将它们路由到正确的团队进行解决。

在接下来的部分，我们将了解如何使用自动化规则来监控 SLA 合规性。

监控 SLA 合规性

服务水平协议（SLA）是重要的衡量指标，旨在确保 IT 服务在约定的时间内，根据其优先级和性质进行交付。

为了维持约定的 SLA 合规率，我们需要确保在可能的情况下，当请求即将违反其 SLA 时，会自动提升其优先级，从而增加其 SLA 得到满足的可能性。

此外，这应伴随适当的通知，通知给受托代理、服务台团队和服务台经理，以便在代理未能在 SLA 内提供解决方案时，做出适当反应。

在本节中，我们将学习如何使用自动化规则来跟踪 SLA，并在 SLA 违约时管理请求。

通过创建一个规则来监控首次响应时间SLA，并根据适用情况通知相关人员，来看一个示例。

创建规则来监控 SLA 违约

为了保持 SLA 的成功率，我们希望尽量避免请求在首次时违反其 SLA。

在此示例中，我们将监控高优先级请求的首次响应时间SLA，并在请求未分配时通知 Slack 频道，或者如果请求已被自动分配，则向受托代理发送消息。此外，我们还将向服务台经理发送通知，提醒他们 SLA 即将违反，以便他们采取适当的措施。

让我们开始创建规则，具体步骤如下：

1. 在你的 Jira 服务管理项目中，导航到项目设置，点击项目设置菜单中的自动化链接，然后点击创建规则。

2. 选择首次响应时间

   将在接下来的 30 分钟内违反

3. 接下来，选择优先级

   是其中之一

   最高、高

4. 无论我们是发送常规的 Slack 通知，还是通知请求的受托人，服务台经理都需要被通知，因此我们将首先发送此通知。

   选择经理

   {{issue.key}} 即将违反其 SLA

   一个未分配的高优先级问题，{{issue.key}} - {{issue.summary}} 即将在 30 分钟内违反其“首次响应时间”SLA。

   通知已发送到#service-desk Slack 频道。

   此致，

   你的友好的 SLA 机器人。

5. 然后，选择受托人

   为空

6. 现在，选择 :fire: <{{issue.toUrl}}|{{issue.key}} - {{issue.summary}}> 当前未分配，并将在 30 分钟内违反其“首次响应时间”SLA。

   #service-desk

7. 然后，在左侧规则链视图中点击添加其他条件，接着点击保存。

8. 选择受托人

   {{issue.key}} 即将违反其首次响应时间 SLA

   嗨，{{issue.assignee.displayName.split(" ").first}}， 你已被分配 {{issue.key}} - {{issue.summary}}，该问题将在 30 分钟内违反其首次响应时间 SLA。 请采取适当的措施，确保我们达到 SLA 目标。 谢谢， 你的友好的 SLA 机器人。

   现在你已经配置了发送电子邮件动作，你的规则应该与下面截图中的样式相似：

   

   图 6.3 – 监控 SLA 违约情况

9. 最后，将你的规则命名为Time to first response monitor，然后点击启用来保存并启用规则。

在这一部分中，我们学习了如何监控那些 SLA 即将违约或已经违约的请求，以及如何自动优先处理和升级这些请求。

接下来，我们将探讨如何通过自动化规则来提升服务台效率，自动化常见且重复的任务。

自动化常见的重复性任务

IT 服务台每天收到许多重复且琐碎的请求，这些请求是自动化的理想候选。

通过自动化任务，你不仅减少了人工干预和完成这些任务时可能出现的错误，还通过减少完成请求的时间，提高了最终用户的生产力。

在这一部分中，我们将了解如何通过自动化来处理密码重置请求，这很可能是服务台处理的最常见请求之一。

我们来看一个自动化规则，当用户在服务台提交密码重置请求时，自动重置用户密码。

创建一个规则来自动重置密码

IT 服务台面临的一个常见且耗时的任务是重置用户密码的请求，这使得它成为自动化的理想候选任务。

为了展示我们如何通过 Jira Service Management 中的自动化规则实现这一目标，我们将利用微软的 Azure AD服务，该服务拥有定义良好的表现性状态转移 应用程序编程接口（REST API）。

重要提示

我们假设 Jira Cloud（或 Jira Server）和 Azure AD 之间唯一的公共信息是用户的电子邮件地址，因为 Jira Cloud 不允许访问用户账户名。

首先，我们需要确保 Jira 已经作为应用注册到 Azure AD，并且拥有适当的权限。

首先，我们需要完成在 Azure AD 中所需的配置，如下所示：

1. 在你的 Azure 门户中导航到Azure Active Directory组件，选择应用注册，然后点击新建注册。

2. 将你的新应用命名为Service Desk Autobot，然后点击注册。

   你现在应该会看到一个类似于下面截图的界面。你需要复制应用程序（客户端）ID（1）和目录（租户）ID（2），以便稍后在我们的规则中使用：

   

   图 6.4 – 在 Azure AD 中将 Jira 注册为应用

3. 下一步是创建一个客户端密钥，用于通过自动化规则进行身份验证。为此，请在菜单中导航到证书与秘密，并在客户端密钥部分点击新建客户端密钥。

   添加可选描述并选择你希望该密钥有效的时间长度，然后点击添加。

   你的屏幕现在应该看起来类似于以下屏幕截图。将新添加的客户端密钥 (1) ID 复制到安全位置，以便稍后在自动化规则中使用：

   

   图 6.5 – 在 Azure AD 中为 Jira 创建客户端密钥

4. 现在我们需要为我们的新应用授予正确的权限，以便能够在 Azure AD 中重置密码。

5. 导航到API 权限菜单项，然后点击添加权限。接着，选择Microsoft Graph。

6. 接下来，选择Directory，并勾选Directory.ReadWrite.All权限。最后，点击添加权限，如以下屏幕截图所示：

   图 6.6 – 为 Jira 添加正确的 Azure AD 权限

7. 为了简化与自动化规则的交互，我们希望预先授权我们刚刚授予的权限，所以点击<tenant>。

   现在，两个Microsoft Graph API 权限的状态应该都有一个绿色勾选，表示它们已获得管理员同意，正如以下屏幕截图所示：

   

   图 6.7 – 授予 API 权限的管理员同意

8. 在 Azure 门户中的最后一步是授予你的应用公司管理员角色。为此，请点击搜索栏右侧的 Cloud Shell 图标，并将以下命令复制到 PowerShell 终端中：

   Connect-AzureAD
   $displayName = "Service Desk Autobot"; $objectId = (Get-AzureADServicePrincipal -SearchString $displayName).ObjectId
   $roleName = "Company Administrator"; $role = Get-AzureADDirectoryRole | Where-Object {$_.DisplayName -eq $roleName}
   Add-AzureADDirectoryRoleMember -ObjectId $role.ObjectId -RefObjectId $objectId
   

   你的屏幕现在应该看起来类似于以下屏幕截图：

图 6.8 – 将公司管理员角色授予 Jira

现在我们已经在 Azure AD 中配置了应用，并且你已经配置了一些与 Jira 邮件地址匹配的用户邮箱地址，我们可以创建自动化规则，当 Jira Service Management 接收到请求时，自动重置用户密码。为此，请按照以下步骤操作：

1. 在你的 Jira Service Management 项目中，导航到项目设置，点击项目设置菜单中的自动化链接，然后点击创建规则。

2. 选择Issue Created和Issue Updated，然后点击保存。

3. 然后，选择Components

   contains any of

   Active Directory

4. 选择Summary

   contains

   password

5. 接下来，我们将使用www.passwordrandom.com外部网页服务为用户生成一个随机的临时密码，因此我们将选择GET

   Empty

   等待响应：确保选择了此项

6. 如果您验证了 webhook 配置，应该会收到一个类似以下内容的响应：

   {
     "char": [
       "LoyKI6;09jd"
     ]
   }
   

   点击保存继续。

7. 在下一步中，我们需要登录到 Microsoft Azure 并获取身份验证令牌。为了完成此步骤，我们需要resource、client_id、client_secret和grant_type。

   为了对数据进行 URL 编码，字段和值通过=分隔，每个字段值对再使用&分隔；最后，需要对整个文本字符串进行 URL 编码，您可以通过将完整字符串粘贴到像www.urlencoder.org这样的服务中来完成此操作。

8. 选择 https://login.windows.net/<目录 (租户) ID>/oauth2/token

   Content-Type

   application/x-www-form-urlencoded

   POST

   自定义数据

   <应用程序 (客户端) ID>

   <客户端密钥>

   client_credentials

   到此为止，您的规则应该类似于以下截图所示：

   

   图 6.9 – 配置登录到 Azure AD 的网页请求

9. 成功的 Microsoft Azure 登录请求将返回token_type和access_token，您将分别使用以下的{{webhookResponse.body.token_type}}和{{webhookResponse.body.access_token}}智能值，来完成密码重置请求：

   {
     "token_type": "Bearer",
     "expires_in": "3599",
     "ext_expires_in": "3599",
     "expires_on": "1602958671",
     "not_before": "1602954771",
     "resource": "https://graph.microsoft.com",
     "access_token": "xxxxxx"
   } 
   

10. 现在我们已成功登录到 Microsoft Azure，我们可以使用身份验证响应和报告者的电子邮件地址，查找 Azure AD 中用户的 ID。为此，我们需要选择 https://graph.microsoft.com/v1.0/users?$filter=startsWith(mail,'{{reporter.emailAddress.urlEncode}}')

    Authorization

    {{webhookResponses.get(1).body.token_type}} {{webhookResponses.get(1).body.access_token}}

    GET

    Empty

    {{webhookResponse.body.value.id}}智能值，如下所示：

    {
      "@odata.context": "https://graph.microsoft.com/v1.0/$metadata#users",
      "value": [
        {
          "businessPhones": [],
          "displayName": "Joe Bloggs",
          "givenName": "Joe",
          "jobTitle": null,
          "mail": "joe.bloggs@company.com",
          "mobilePhone": null,
          "officeLocation": null,
          "preferredLanguage": "en",
          "surname": "Bloggs",
          "userPrincipalName": "jblogs@tenant.onmicrosoft.com",
          "id": "2aa3af1f-c91f-4feb-89dc-de4d200da185"
        }
      ]
    }
    

    提示

    当自动化规则接收到多个网页请求的响应时，每个响应会按照在规则中调用的顺序，添加到{{webhookResponses}}智能值列表中，从位置零（0）开始。因此，我们可以使用智能值列表函数，在后续需要引用时获取单个的 webhook 响应。例如，{{webhookResponses.get(1).body}}将获取来自第二个网页请求的 JSON 响应，而{{webhookResponses.first.body}}将获取第一个请求的响应。

11. 现在我们拥有了身份验证数据、Azure AD 中用户的 ID 和我们从第一个网页请求中获取的临时密码，我们可以将这些信息结合起来，实际执行密码重置。

    选择 https://graph.microsoft.com/v1.0/users/{{webhookResponse.body.value.id}}

    首先 Authorization

    {{webhookResponses.get(1).body.token_type}} {{webhookResponses.get(1).body.access_token}}

    第二个 Content-Type

    application/json

    POST

    自定义数据

    自定义数据：

    {
        "passwordProfile": {
            "forceChangePasswordNextSignIn": "true",
            "password": "{{webhookResponses.first.body.char}}"
        }
    }
    

    等待响应：确保选中此选项，以便只有在响应成功时，我们才会继续执行该规则。

    本示例中的自定义数据使用了微软 Graph API 中定义的用户 REST API 的 Azure AD 密码配置结构，详细信息请参见docs.microsoft.com/en-us/graph/api/resources/passwordprofile?view=graph-rest-1.0。

    您的规则应类似于以下截图所示：

    

    图 6.10 – 配置密码重置请求

12. 要完成该规则，我们需要通知用户他们的密码已被重置，并告知他们新的临时密码，以便他们重新登录并将密码更改为他们选择的密码。

    选择 报告人

    您的密码重置请求已完成。

    亲爱的 {{issue.reporter.displayName.split(" ").first}}，

    您的密码重置请求已完成。

    为您生成的新临时密码是：

    {{webhookResponses.first.body.char}}

    下次登录时，系统将提示您更改密码。

    谢谢，

    服务台团队。

13. 最后，选择 密码重置机器人，并确保选中允许规则触发复选框。点击保存，然后点击开启以启用该规则。

在本节中，我们学习了如何使用自动化规则来自动化服务台团队面临的常见和重复性任务，通过查看最常见的重复性任务之一——重置密码。

如我们所见，使用自动化规则来自动化这些重复且耗时的任务将提高您的服务台的整体效率，减少每个工单的成本，并提高最终用户的满意度。

总结

在本章中，您学习了如何通过将自动化添加到 Jira 服务管理中，提升 IT 服务台的效率，降低每个工单的成本，并提高整体用户满意度。

我们学到了如何在请求生命周期的早期对传入的请求进行分类和处理，这可以提高请求的响应和解决时间，因为不再需要人工干预进行初步筛选，并且我们现在了解了如何通过适当的升级监控 SLA 合规性，以帮助我们保持对重要问题的掌控。

最后，我们了解到，使用自动化机器人执行常见且重复的任务（如重置用户密码）可以显著提高请求解决的时间和最终用户的生产力，因为他们不再需要等待服务代理手动执行这些任务。

通过运用本章所学的技能，并将其应用于服务台中的更多流程，你不仅能够让服务代理集中精力处理更有意义和紧急的任务，还将提升整个组织对 IT 服务的整体用户满意度。

在下一章，我们将探讨如何使用自动化有效管理 Jira 软件项目。

第七章：第七章：自动化 Jira 软件项目

跟踪软件开发任务和 Bug 是 Jira 最为人所知的功能之一；然而，它一直伴随着管理开销，需要保持问题对齐并确保跨项目的工作同步。

在 Jira 中处理管理任务有时会令人沮丧，通常意味着无法投入更多时间进行实际开发工作。引入自动化可以减少许多手动任务，从而让团队成员更快乐、更高效。

在本章中，我们将学习如何利用自动化规则，为 Jira 软件项目提供简单而有效的生产力提升，例如如何保持跨项目的版本同步。

我们还将看到，如何通过自动化对问题层级的状态进行对齐，从而减少大量手动操作，提升在软件项目中处理问题的效率。

本章将涵盖以下主题：

• 跨项目管理版本

• 确保史诗和故事保持一致

• 管理 Sprint 范围

技术要求

本章的要求如下：

• Jira 云环境：如果你尚未获得 Jira 访问权限，可以在www.atlassian.com/software/jira/free创建一个免费的 Jira 云账户，并确保选择了 Jira Software 和 Jira Service Desk。

• Jira 服务器环境：如果你正在使用 Jira 服务器（可从www.atlassian.com/software/jira/download下载），确保你拥有 Jira Software 和 Jira Service Desk 的许可证。此外，你还需要确保安装 Automation for Jira 应用，该应用可从 Atlassian 市场获取。

在这两种情况下，你至少需要拥有 项目管理员 访问权限，才能在 Service Desk 项目和 Scrum 软件项目中跟随本章的示例进行操作。对于本章中的示例，我们使用了 IT 服务管理项目模板 来创建 Service Desk 项目，并使用 Scrum 软件项目模板 来创建软件项目。

你可以从本书的官方 GitHub 仓库下载本章的最新代码示例，地址是github.com/PacktPublishing/Automate-Everyday-Tasks-in-Jira。请访问以下链接查看 CiA 视频：https://bit.ly/3quqjil

跨项目管理版本

一个常见的 Jira 软件项目使用场景是，拥有一个面向公众的项目，客户可以在其中提交缺陷和功能请求，针对已发布的软件，另有一个内部项目供开发团队追踪工作。

拥有这种设置可以让团队筛选传入的请求，并选择相关的问题进行处理，而不会将实际项目中堆积成成千上万的问题。

然而，从这种设置中获得好处要求两个项目中的软件版本保持同步，以便客户能够针对发布的软件的正确版本报告问题。

在本节中，我们将探讨如何使用自动化规则来管理项目之间的版本同步。

为了做到这一点，我们需要确保当我们在内部项目中发布版本时，创建一个对应的版本在面向公众的项目中，客户可以在报告错误或创建功能请求时使用该版本。

让我们来看一个规则，它可以帮助我们在多个项目之间保持版本同步。

创建一个规则以保持跨项目版本同步

在这个例子中，我们将创建一个规则，该规则会在我们内部项目发布版本时触发，并在面向公众的项目中创建并发布对应的版本，客户可以在报告问题时使用该版本。

重要提示

创建跨多个项目的自动化规则要求用户创建规则时拥有 Jira 管理员权限。项目管理员不能创建跨项目的规则。

在这个例子中，我们将在规则中使用两个软件项目。对于第一个软件项目，我们将创建一个使用 Scrum 软件模板的项目，命名为我的应用程序，项目键为MAPP。对于面向公众的支持项目，我们将创建一个使用 Bug 跟踪软件模板的项目，命名为我的应用程序支持，项目键为MAPS。

让我们来看看如何构建这个规则：

1. 由于我们处理的是多个项目，这个规则需要由拥有 Jira 管理员权限的用户设置。

2. 进入设置（顶部菜单中的齿轮图标），选择系统，点击左侧菜单中的自动化规则选项卡，然后点击创建规则。

3. 选择版本发布触发器并点击保存。

4. 由于这个规则中配置的两个项目都可能触发规则，我们需要确保只有当 MAPP 项目触发时，规则才继续执行。为此，选择{{version.project.key}}。

   equals

   MAPP

5. 接下来，选择{{version.name}}智能值，以选择触发规则的版本名称。

   展开更多选项，在项目字段中选择您的应用支持项目。对于这个例子，它是我的应用支持 (MAPS)。

6. 点击{{version.name}}智能值以确保发布正确的版本。

7. 接下来，点击保持支持项目版本同步。

   设置多个项目，并在我的应用程序和我的应用程序支持中进行选择。

8. 最后，点击保存，然后点击开启来发布并启用该规则。

在本节中，我们学习了如何使用自动化规则来保持多个项目之间的版本同步，使客户能够在开发项目之外提出错误和功能请求。

在接下来的部分，我们将了解如何确保软件项目中的史诗状态与项目中的基础故事保持一致。

确保史诗和故事保持一致

使用Scrum 敏捷框架进行软件项目工作通常涉及一套问题类型的层级结构。

在典型的基于 Scrum 的敏捷层级中，你会有史诗来定义较大的工作任务或业务需求，这些任务可能跨越多个迭代周期。

这些被分解为故事（或用户故事），它们是需求的高层次定义，可以在限定的时间周期或迭代中交付。

然后，故事可以被分解为任务，作为故事的子任务，这些任务是完成故事所需的具体、可衡量的工作项。

在本节中，我们将查看如何使用自动化规则来保持这个层级中问题的状态同步，这样当子任务开始工作时，子任务上方的相关问题将自动转换到正确的状态，无需人工干预。

创建一个规则以保持史诗和故事的同步

在这个例子中，我们将创建一个规则，当子任务转换到新的状态时触发，并根据子任务的状态，如果需要，规则会自动将其父级故事转换到正确的状态。

此外，我们还将使用相同的规则，当故事转换到新状态时，自动将与故事相关联的史诗转换到正确的状态，因此我们需要允许规则通过其他规则触发。

重要提示

允许规则通过其他规则触发可能会无意中导致执行循环，其中规则可能会被无限触发。自动化规则引擎包括循环检测机制，以防止无限循环；然而，配置不当的规则仍然可能导致执行循环，最多可达到 10 层深度，之后规则执行会被终止。

现在我们来看看这个规则：

1. 在你的 Jira 软件项目中，导航到项目设置，点击项目设置菜单中的自动化链接，然后点击创建规则。

2. 选择问题转换触发器并点击保存。保持从状态和到状态字段为空，因为我们希望规则在每次转换时都能触发。

3. 我们首先要检查的是子任务是否已经开始进展，并将其父级故事转移到issueType = Sub-task AND statusCategory = "In Progress"。

4. 现在，选择分支规则/相关问题，在相关问题类型字段中选择父级，然后点击保存。

5. 然后，选择新建操作，接着选择转换问题。对于这个例子，确保目标状态字段设置为从触发问题复制，然后点击保存。

6. 规则的下一个阶段是确保当所有子任务完成时，用户故事能够转换为完成状态。为此，点击issueType = Sub-task AND statusCategory = Done。

7. 接下来，选择分支规则/相关问题，在相关问题类型字段中再次选择父级，然后点击保存。

8. 此时，我们需要检查子任务中选定父级问题的所有子任务。

   所有匹配指定的 JQL

   statusCategory = Done

9. 如果在第 8 步中提到的条件匹配，并且故事的所有子任务的状态类别为完成，那么我们需要将故事本身转换为完成状态。为此，选择新建操作，然后选择转换问题，并确保目标字段设置为从触发问题复制，然后点击保存。

   重要说明

   当你使用从触发问题复制来处理状态时，你需要确保两种问题类型使用相同的工作流，或者这些工作流共享相同的状态。如果不是这种情况，你将需要选择你希望转换到的实际状态。

10. 现在我们已经处理好了将故事与其子任务同步的问题，接下来我们需要处理将 Epic 与其底层故事同步的问题。

    首先，我们将处理将 Epic 移动到issueType = Story AND status = "In Progress"。

11. 然后，选择分支规则/相关问题，在相关问题类型字段中选择Epic（父级），然后点击保存。

12. 接下来，选择新建操作，然后选择转换问题。确保目标字段设置为从触发问题复制（对于本示例），然后点击保存。

13. 该规则中的最终条件分支将确保当所有底层故事完成时，Epic 自动转换为完成状态。

    通过点击issueType = Story AND statusCategory = Done来完成此操作。

14. 现在，选择Epic（父级）并点击保存。

15. 像我们为子任务做的那样，我们需要确保 Epic 中的所有故事都完成后，才能自动将 Epic 转换为完成状态。

    我们通过选择Stories（或此 Epic 中的其他问题）来完成此操作。

    所有匹配指定的 JQL

    statusCategory = Done

16. 为了真正地转换 Epic，我们需要添加一个操作，选择新建操作，然后选择转换问题。

    确保目标字段设置为从触发问题复制（对于本示例），然后点击保存。

17. 这个规则的一个要求是它能够触发自身，确保层级中的所有问题都更新到正确的状态。

    为了实现这一点，我们需要设置一个允许规则由其他规则触发的规则选项。

    在左侧的规则链视图中选择规则详情。在名称字段中，将规则名称设置为保持问题层级状态同步，并确保选中允许规则触发复选框。

    你的规则应该类似于以下两张截图：

    

    ](https://github.com/OpenDocCN/freelearn-devops-pt7-zh/raw/master/docs/auto-evdy-task-jira/img/B16551_Figure_7.2.jpg)

    图 7.2 – 保持史诗与故事同步的规则（第一部分）

    在前面的截图中，我们可以看到规则的详细信息，以及处理保持故事与子任务同步的规则链的第一部分。

    

    ](https://github.com/OpenDocCN/freelearn-devops-pt7-zh/raw/master/docs/auto-evdy-task-jira/img/B16551_Figure_7.3.jpg)

    图 7.3 – 保持史诗与故事同步（第二部分）

    在这张截图中，我们可以看到规则链的第二部分，它处理保持史诗与其底层用户故事同步的问题。

18. 最后，点击 保存，然后点击 启用 以保存并发布规则。

在这一节中，我们学习了如何使用自动化规则保持问题层级之间的同步，以及如何允许规则触发自身来实现这一目标。

在下一节中，我们将看看如何通过将关联问题自动添加到当前冲刺中来调整冲刺的范围，并在冲刺范围发生变化时通知团队。

管理冲刺的范围

在任何开发生命周期中，难免会在某些时刻由于需求的临时变化或需要包括紧急 bug 修复，导致冲刺范围的变化。

在这一节中，我们首先将探讨如何通过将一个新关联的问题添加到冲刺中来改变冲刺的范围。

我们还将探讨如何使用自动化规则监控冲刺，并在冲刺范围变化时通知团队。

创建规则以将关联问题添加到冲刺中

在这个例子中，我们将利用我们拥有的两个项目：一个是私有的内部软件开发项目（我的应用程序，关键字 MAPP），另一个是公共支持项目（我的应用程序支持，关键字 MAPS），客户可以在该项目中提交请求和报告错误。

我们还将假设有一个团队在监控公共支持项目，并处理收到的请求。

这部分处理包括检查由组织的顶级客户提交的高优先级 bug，如果验证通过，将在私有开发项目中创建一个关联 bug，并将其添加到当前冲刺中。

让我们看看如何通过自动化规则实现这一目标：

1. 由于我们正在处理的不仅仅是一个项目，因此这个规则需要由具有 Jira 管理员权限的用户来设置。

2. 转到 设置（顶部菜单中的齿轮图标），选择 系统，然后点击左侧菜单中的 自动化规则 标签，并点击 创建规则。

3. 选择 待办

   进行中

4. 接下来，我们需要添加一些条件，确保我们只选择支持项目中优先级最高的 bug。

   在这个例子中，我们将使用多个问题字段条件，因为它们比使用 JQL 条件具有性能优势。

5. 通过选择 项目 来检查正确的项目

   等于

   我的应用程序支持（MAPS）

6. 接下来，我们将确保此规则仅适用于 bug 类型的问题。

   选择 问题类型

   等于

   Bug

7. 最后的条件是检查该 bug 是否为最高优先级。

   选择 优先级

   是其中之一

   最高

8. 此规则的最后一步是创建关联问题并将其添加到当前的开发项目和冲刺中。

   选择 My Application (MAPP)

   相同问题类型

   与...相关

   触发问题

   当前冲刺（My Application Scrum Board）

   你的规则现在应该类似于以下截图：

   

   图 7.4 – 在当前冲刺中创建关联问题

9. 最后，选择 将关键 bug 添加到当前冲刺。

   将 范围 字段设置为 多个项目，在 限制为项目 字段中，选择你的内部和支持项目。在这个例子中，我们将选择 My Application 和 My Application Support。

10. 最后，点击 保存，然后点击 启用 来发布并启用规则。

在这个示例中，我们学会了如何使用自动化规则创建项目中的关联问题并将其添加到当前冲刺。

在下一个示例中，我们将展示如何监控当前冲刺的范围变化，并在发生变化时通知开发团队。

创建一个规则，当范围发生变化时通知团队

当当前冲刺的范围发生变化时，我们希望让团队保持知情，这样团队中的每个人都能了解发生了什么。

为了实现这一点，我们将创建一个规则，监听问题中 冲刺 字段的变化，如果该冲刺当前是激活的冲刺，我们将向团队的 Slack 渠道发送通知。

在这个示例中，我们将通过我们在 第四章 中设置的 Slack 集成，将通知发送到 #sprint-updates Slack 渠道，发送自动化通知。

让我们看看这个规则是如何工作的：

1. 在你的 Jira Software 项目中，导航至 项目设置，点击 项目设置 菜单中的 自动化 链接，然后点击 创建规则。

2. 由于没有直接的方式来监控当前冲刺的变化，我们将设置规则，在问题的 冲刺 字段发生更改时触发。

   为了实现这一点，我们将选择 字段值更改 触发器。在 监控更改的字段 下拉菜单中选择 冲刺。

   保持 For 字段为空，选择 所有问题操作，然后点击 保存。

3. 我们需要确保问题添加到的冲刺与当前激活的冲刺相对应。

   我们可以通过选择 冲刺在 openSprints() 来实现此功能

4. 接下来，我们将选择 #sprint-updates。

   你的规则应类似于以下截图：

   

   图 7.5 – 监控冲刺范围变化

5. 我们还需要确保这个规则可以被其他自动化规则触发；否则，其他规则所创建的范围变更将不会触发通知。

   在规则链视图的左侧选择规则详情。在名称字段中，将规则名称设置为当冲刺范围变化时发送通知到 Slack，并确保勾选了允许规则触发复选框。

6. 最后，点击保存，然后点击启用以发布并启用该规则。

在这个示例中，我们学习了如何使用问题中的冲刺字段来监控冲刺的范围变化，并保持团队对这些变化的知情。

通过使用自动化减少手动操作，保持问题同步并及时更新团队，你将使团队更高效，因为他们不再需要管理项目工具，而可以专注于实际任务。

摘要

在本章中，我们学习了如何使用自动化规则来最小化管理和操作 Jira 软件项目时通常涉及的管理开销，事实上，这些规则可以应用于 Jira 中的大多数项目类型。

特别是，我们学习了如何在项目之间保持版本同步，当你有一个跨多个 Jira 项目的软件项目时，这一点尤其有用，无论这些项目是内部团队项目，还是像我们示例中的那样，供客户记录和跟踪请求的公共项目。

保持问题层次结构同步是 Jira 项目中非常常见的任务，在本章中，我们学习了如何使用循环规则来实现这一点，利用 Jira 软件项目中最常见的层次结构。最后，我们学习了如何保持对冲刺范围变化的可见性，并且如何使用自动化调整冲刺范围。

除了我们所看到的与冲刺相关的示例，本章中讨论的主题同样适用于任何其他类型的软件开发，包括看板和瀑布流，只需做一些小的调整。

将本章中学到的知识应用到你的项目中，使用自动化规则将有助于减少手动和重复的行政工作，从而使用户更加高效和富有生产力。

在下一章，我们将探讨如何利用自动化规则与 GitHub 和 Bitbucket 等工具集成，以支持 DevOps 流程。

第八章：第八章：与 DevOps 工具集成

DevOps 的核心原则之一，在于在组织内培养相关文化的同时，通过使用技术来自动化和优化流程。通过在 Jira 中使用自动化规则，我们可以通过将 Bitbucket 和 GitHub 等 DevOps 工具与 Jira 中的问题连接，优化软件开发流程，从而实现问题状态的自动同步。

除了自动将问题状态与代码提交同步外，我们还可以利用自动化来跟踪和同步拉取请求，创建任务来追踪这些请求，并向团队发送通知，以确保过程的最大可见性。所有这些都能使开发人员更多时间专注于编写和交付软件，而减少管理行政任务的时间。

虽然通过工作流触发器在 Jira 中集成某些 DevOps 流程（过去和现在）是可能的，但在本章中，我们将探讨如何使用自动化规则来创建比以往更加灵活的集成方式。这将保持你的工作流配置简洁，并防止冗长的工作流更新，尤其是当工作流影响大量问题时。

本章将涵盖以下主题：

• 同步问题和 Git 提交

• 跟踪拉取请求

• 使用 GitHub 自动发布版本

• 与冲刺完成同步部署

技术要求

本章的要求如下：

• Jira Cloud 环境：如果你还没有 Jira 访问权限，可以在www.atlassian.com/software/jira/free创建一个免费的 Jira Cloud 账户，并确保选择了 Jira Software 和 Jira Service Management。

• Jira Server 环境：如果你使用的是 Jira Server（可以在www.atlassian.com/software/jira/download下载），请确保你拥有 Jira Software 和 Jira Service Management 的许可。此外，你还需要确保安装Automation for Jira应用，该应用可以在 Atlassian Marketplace 中找到。

对于 Jira，你需要至少拥有项目管理员权限，才能访问 Scrum 软件项目并跟随本章的示例。在本章的示例中，我们使用了Scrum 项目模板来创建软件项目。

你还需要访问以下工具：

• Bitbucket Cloud：Bitbucket Cloud 是 Atlassian 提供的托管 Git 版本控制服务。你可以在bitbucket.org注册 Bitbucket 账户，或者通过你的 Jira Cloud 账户使用应用切换器。

• GitHub：GitHub 是微软提供的托管软件开发和基于 Git 的版本控制服务。你可以在github.com注册 GitHub 账户。

• Jenkins：Jenkins 是一个流行的免费开源自动化服务器，用于通过自动化构建、测试和部署软件项目来促进持续集成（CI）和持续交付（CD）。你可以从 www.jenkins.io 下载 Jenkins。

你可以从本书的官方 GitHub 仓库下载本章的最新代码示例，网址是 github.com/PacktPublishing/Automate-Everyday-Tasks-in-Jira。请访问以下链接查看 CiA 视频：bit.ly/2XWeuW7

同步问题和 Git 提交

在编写软件的正常过程中，开发者通常会将一个故事或任务移动到进行中状态，进行实际的代码编写，将更改提交到如 Bitbucket 或 GitHub 等源代码仓库，然后返回 Jira，将故事或任务移至工作流中的下一个状态。

所有这些手动操作都需要不必要的上下文切换，而且由于这一过程要求开发者记得在不同工具之间切换，因此很可能有时问题没有得到更新，这使得追踪项目的实际进展变得更加困难。

Jira 已经具备了与 Bitbucket 和 GitHub 等工具集成的能力，允许管理员通过在各种工作流转换上配置触发器来设置底层的 Jira 工作流。

虽然这种方法确实可以自动化过程，并解放开发者不需要手动更新任务状态，但它仅限于触发器配置的转换。此外，调整工作流并不总是一个简单的任务。

通过使用自动化规则，我们在同步代码提交与对应 Jira 问题时获得了更多的灵活性。

让我们来看看如何利用自动化规则实现这一点。

创建一个规则以在代码提交时转换问题

在本例中，我们将创建一个规则，监听通过 Bitbucket Cloud 创建的提交，如果对应的问题还没有处于进行中状态，则将其转换为该状态。

此外，我们会为每次提交发送消息到 #sprint-updates Slack 频道，这个频道是在第四章中设置的，发送自动通知。但实际上，你可能并不想用提交通知骚扰开发者，而是希望等到更重要的事件，比如创建拉取请求时，再发送通知。

小贴士

为了让自动化规则识别需要更新的问题，提交信息需要包含问题键。如果你的开发人员为他们工作的每个问题创建一个分支，则问题键需要作为分支名称的一部分。在这两种情况下，问题键必须遵循 Jira 的标准格式，即项目键后跟一个短横线，再加上问题编号。例如，如果项目键是 PROJ，问题编号是 123，则问题键将是PROJ-123。

首先，让我们看看在Jira Cloud中如何使用可用于自动化规则的 DevOps 触发器来构建此规则：

1. 在你的 Jira 软件项目中，进入项目设置，点击项目设置菜单中的自动化链接，然后点击创建规则。

2. 选择提交创建触发器，然后点击保存。

   提示

   如果你还没有为项目配置 Git 提供者，提交创建触发器将提示你创建连接，你可以点击立即连接链接来创建连接。

3. 接下来，我们将发送一条 Slack 消息到#sprint-updates

4. 在此步骤中，我们将添加一个条件来检查问题的当前状态是否不是状态

   不等于

   进行中

5. 接下来，如果步骤 4中的条件满足，我们将把问题转换为进行中。

   点击新动作，然后选择转换问题。将目标字段设置为进行中，然后点击保存。

   你的规则现在应该类似于以下截图：

   

   图 8.1 – 使用 DevOps 触发器来同步提交

6. 最后，命名规则为Transition to In Progress on commit，然后点击开启以保存并发布该规则。

Jira Server 和 Data Center 的自动化规则目前不包括 DevOps 触发器，因此我们需要利用传入 Webhook 触发器来实现类似的结果。

在本示例中，我们将首先在 Jira 中设置传入的 Webhook 自动化规则，然后复制生成的 Webhook URL，这将在设置 Bitbucket Cloud 仓库中的传出 Webhook 时使用。

现在，让我们来看看如何在Jira Server或Jira Data Center中构建此规则：

1. 在你的 Jira 软件项目中，进入项目设置，点击项目设置菜单中的项目自动化链接，然后点击创建规则。

2. Bitbucket Cloud 在创建提交时会发送一个推送Webhook，并发送一个 Webhook 负载，更多信息请查看support.atlassian.com/bitbucket-cloud/docs/event-payloads/#EventPayloads-entity_repository。

   在这个例子中，我们假设问题键存在于提交消息中而不是分支名称中。我们需要从提交消息中提取问题键，以便查找正确的 Jira 问题。根据前述链接中详细的 Bitbucket 负载结构，我们可以找到提交消息并使用以下智能值提取问题键：

   {{webhookData.push.changes.first().new.target.message.match("([A-Z][A-Z0-9]+-\d+)")}}
   

   提示

   如果你是按问题使用分支，并且问题键编码在分支名称中，你可以使用以下智能值从分支名称中提取问题键：{{webhookData.push.changes.first().new.target.name.match("([A-Z][A-Z0-9]+-\d+)")}}。

   选择通过运行以下 JQL 查询提供的 Issue

   key = {{webhookData.push.changes.first().new.target.message.match("([A-Z][A-Z0-9]+-\d+)")}}

3. 接下来，我们将向#sprint-updates发送一条 Slack 消息。

4. 在此步骤中，我们将添加一个条件，检查问题的当前状态是否不是状态。

   不等于

   进行中

5. 接下来，如果第 4 步的条件满足，我们将把问题状态转换为进行中。

   点击新建操作，然后选择转换问题。将目标字段设置为进行中，然后点击保存。

   你的规则现在应该类似于下图所示：

   

   图 8.2 – 使用传入的 Webhook 触发器同步提交

6. 将规则命名为在提交时转换为进行中，然后点击启用以保存并发布该规则。

7. 接下来，我们需要在 Bitbucket Cloud 中配置出站 Webhook。

   导航到 Bitbucket Cloud 中的仓库，点击提交时转换 Jira 问题，并将步骤 2 中生成的传入 Webhook URL 粘贴到URL字段中。

   保持其他字段为默认值并点击保存。

   你的 Bitbucket Cloud Webhook 应该类似于下图所示：

图 8.3 – 在 Bitbucket Cloud 中配置推送 Webhook

现在，我们已经完成了 Bitbucket Cloud 中的 Webhook 设置，任何推送到 Bitbucket 仓库的提交都会向第 2 步中自动生成的Webhook URL发送请求，触发我们的自动化规则并转换与该提交相关的问题状态。

在这一部分，我们已经学会了如何使用 Jira Cloud 中的 DevOps 触发器，自动将 Jira 问题与 Bitbucket Cloud 中托管的 Git 仓库提交同步。

重要提示

Jira Cloud 中的 DevOps 触发器，如 Commit 创建，适用于大多数主流 Git 仓库，包括 Bitbucket Cloud、GitHub 和 Gitlab，我们之前看过的 Jira Cloud 示例也可以在这些工具中直接使用。

我们还看了如何通过专门在提交消息中使用问题关键字的 Bitbucket Cloud 传入 Webhook 来为 Jira Server 和 Jira Data Center 实现类似的结果。

在下一节中，我们将讨论如何使用自动化规则来跟踪在基于 Git 的仓库中创建的拉取请求。

跟踪拉取请求

DevOps 实践的一个常见特点是使用所谓的基于主干的开发方法，这是持续集成和持续交付或开发（CI/CD）应用于软件开发过程的关键推动力。

实现这一点的方式之一是使用从主分支（或主干）分出的短生命周期分支来执行开发任务。Jira 通过允许开发者在配置了像 Bitbucket 或 GitHub 这样的源代码管理仓库时，自动为每个开发任务创建分支，来方便这一点。

这些短生命周期的分支通常通过拉取请求（pull requests）合并回主干/主分支，拉取请求允许开发者在合并到主分支之前，审查软件中引入的变更。

在本节中，我们将看到如何使用自动化规则来跟踪这些拉取请求，这些请求通常直接发生在源代码控制仓库中，并自动同步和过渡 Jira 中的相关问题。

我们还将看到如何创建自动化任务来跟踪拉取请求。这些跟踪任务将使产品负责人和团队能够快速查看哪些问题已经合并而没有拉取请求，或者哪些问题存在未解决的拉取请求，而无需离开 Jira。

让我们来看一下第一个规则，它将同步开发问题并创建跟踪任务。

创建一个规则来跟踪新的拉取请求

在这个示例中，当管理拉取请求时，我们首先想要实现的是将相应的开发问题转换为等待审查状态，然后在 Jira 中创建一个与正在审查的开发问题相关联的跟踪任务。

提示

为了使这个示例正确工作，等待审查状态需要添加到你的工作流中。如果你使用了Scrum 软件项目模板的默认工作流，你可以通过在看板配置中向 Scrum 看板添加一个新列来完成。如果你使用的是自定义工作流，则需要编辑工作流以添加此状态。

此外，我们会向团队发送 Slack 消息，通知他们已经创建了一个新的拉取请求任务。这样开发团队的任何成员都可以接手并审查该拉取请求。

让我们来看一下如何构建这个规则：

1. 在你的 Jira 软件项目中，导航到项目设置，点击项目设置菜单中的自动化链接，然后点击创建规则。

2. 选择拉取请求已创建触发器，然后点击保存。

3. 接下来，我们要将开发问题的状态转换为等待审查。

   选择新动作，然后选择转换问题，接着在目标状态字段中选择等待审查选项，然后点击保存。

4. 然后我们需要创建 Jira 任务来跟踪此拉取请求。

   选择同一项目

   任务

   审查 PR：{{pullRequest.title}}

   需要审查的 PR：{{pullRequest.title}}

   源分支：{{pullRequest.sourceBranch}}

   目标分支：{{pullRequest.destinationBranch}}

   访问 PR 链接：{{pullRequest.url}}

   阻塞

   触发问题

5. 要通过 Slack 向团队发送通知，我们将选择:bellhop_bell: 一个新的拉取请求已创建并准备好审查 <{{createdIssue.url}}|{{createdIssue.key}}>

   #slack-updates。

   你的规则应类似于以下截图：

   

   图 8.4 - 跟踪新拉取请求的规则

6. 最后，将规则命名为跟踪新拉取请求，然后点击启用以保存并启用该规则。

在此示例中，我们学习了如何使用 Jira Cloud 中内置的 DevOps 触发器，在连接的 Git 工具（如 Bitbucket 和 GitHub）中创建新的拉取请求时触发规则，前提是这些工具已在 Jira 中配置并与软件项目连接。

本节中我们要查看的第二个规则将通过处理拉取请求已批准并合并的情况来完成管理拉取请求的循环。

创建一个管理已合并拉取请求的规则

在这个示例中，我们将创建一个自动化规则，当拉取请求被合并时触发。此时，我们希望将开发问题的状态从等待审查转换为等待部署。

提示

为了使此示例正确工作，需要在你的工作流中添加等待部署状态。如果你使用的是Scrum 软件项目模板的默认工作流，可以通过在看板配置中添加新列来实现。如果你使用的是自定义工作流，则需要编辑工作流以添加此状态。

此外，我们还希望自动将我们在跟踪新拉取请求规则中创建的跟踪任务状态转换为已完成。

现在让我们来看一下如何构建一个规则来实现这个目标。

1. 在你的 Jira 软件项目中，导航到项目设置，点击项目设置菜单中的自动化链接，然后点击创建规则。

2. 选择拉取请求已合并触发器，然后点击保存。

3. 由于我们只希望在问题处于等待审查状态时才进行转换，因此需要设置一个条件来检查这一状态。

   选择状态

   等于

   等待审查

4. 接下来，选择新动作，然后选择转换问题，接着在目标状态字段中选择等待部署，然后点击保存。

5. 现在我们想要自动过渡我们在创建规则以跟踪新的拉取请求部分中创建的跟踪任务到关联问题

   被阻塞

6. 由于可能会有其他任务通过相同的链接类型与此问题关联，我们希望确保只自动过渡跟踪任务，因此我们需要另一个条件。

   选择摘要

   以...开始

   审查 PR:

7. 现在选择新动作，然后选择过渡问题。在目标状态字段中，选择已完成，然后点击保存。

   该规则现在应该与以下截图类似：

   

   图 8.5 – 用于管理拉取请求合并的规则

8. 最后，给规则命名为管理拉取请求合并，然后点击启用以保存并启用规则。

我们现在知道如何通过自动化规则将拉取请求与 Jira 集成。首先，确保开发问题与开发团队实际执行的工作同步，其次，跟踪哪些问题已经或仍然需要合并到主分支。在下一部分，我们将看到如何具体使用自动化规则与 GitHub 中的发布功能进行集成。

使用 GitHub 自动发布版本

版本控制工具允许开发者对源代码的特定修订进行标记，这实际上创建了一个时间点上的代码库快照。标签的最常见用途是标识构成特定版本或发布的软件的源代码组件和文件，像 GitHub 和 GitLab 这样的工具进一步推动了这一点，它们允许开发者基于特定标签创建一个发布版本。这些版本通常包含适用于该版本的变更列表，形式为发布说明。它们还可以包含指向构成发布的资产列表的链接，这些资产通常是可下载的二进制包。

发布可以通过工具的用户界面创建，但最常见的是通过构建工具（如 Bitbucket Pipelines 或 Jenkins）在成功完成部署构建后自动创建。这些工具反过来可以触发 webhook 事件，在发布被创建时通知其他工具。

使用 Jira 中的自动化规则，我们可以使用传入的 webhook 接收这些通知，并自动发布 Jira 中的相应版本，同时将所有与该版本关联的受影响问题过渡到已完成。现在让我们来看一个可以帮助我们实现这一目标的规则。

创建一个规则以同步版本发布到 GitHub 发布

在这个规则中，我们将创建一个可以被 GitHub 调用的传入 webhook，当发布被创建时，GitHub 发布 webhook 会包含一个 JSON 负载，我们将能够从中提取出标识发布的标签名称。反过来，这个标签名称应该与 Jira 软件项目中的版本相对应。

GitHub 发布负载的结构类似于以下内容，我们将在规则中使用action和tag_name字段：

{
  "action": "published",
  "release": {
    ...
    "tag_name": "1.0",
    ...
  }
}

你可以在以下网址阅读更多关于事件负载的信息：docs.github.com/en/free-pro-team@latest/developers/webhooks-and-events/webhook-events-and-payloads#release。

你还可以在以下网址了解更多关于 GitHub webhook 和事件的内容：docs.github.com/en/free-pro-team@latest/developers/webhooks-and-events/about-webhooks。

让我们来看一下创建自动化规则所需的步骤，以便在从 GitHub 发布版本时同步 Jira 版本的发布：

1. 在你的 Jira 软件项目中，导航到项目设置，点击项目设置菜单中的自动化链接，然后点击创建规则。

2. 选择传入 webhook触发器，并在使用此自动化规则时字段中选择没有来自 webhook 的问题选项，然后点击保存。

   请确保复制自动生成的 webhook URL，因为我们稍后需要它来配置 GitHub webhook。

3. GitHub 会为发布的不同状态发送 webhook 事件；但是，对于此规则，我们只关心在发布版本时执行该事件，具体可以通过查看{{webhookData.action}}来判断。

   equals

   published

4. 如果步骤 3中的条件匹配，首先要做的是自动将所有属于该版本并且当前等待部署的问题转移到JQL

   fixVersion = {{webhookData.release.tag_name}} AND status = "Waiting for deploy"

5. 然后我们选择新建操作，接着选择转移问题，在点击保存之前，将目标状态字段设置为完成。

6. 接下来，我们希望发布与 GitHub 版本的标签名称对应的 Jira 版本。

   我们需要在{{webhookData.release.tag_name}}之外执行此操作，然后点击保存。

   规则现在应该看起来像以下屏幕截图：

   

   图 8.6 – 从 GitHub 自动发布 Jira 版本

7. 最后，将规则命名为与 GitHub 发布同步版本，然后点击启用以保存并启用此规则。

现在我们在 Jira 中有了自动化规则，我们需要使用步骤 2中生成的 webhook URL 完成 GitHub 配置。

现在，让我们配置我们的 GitHub 仓库，将发布通知发送到 Jira 中的自动化规则：

1. 导航到你在 GitHub 中的仓库，点击设置，从左侧菜单选择Webhooks标签，然后点击添加 webhook按钮。

2. 按如下方式填写 Webhook 字段：

   application/json

   启用 SSL 验证

3. 为了确保我们在自动化规则中接收到正确的事件，请在您希望触发此 Webhook 的事件字段中选择让我选择单独的事件选项。

   确保取消选择Pushes选项，选择Releases选项，然后点击添加 Webhook。

   您的 GitHub 配置应类似于以下屏幕截图：

图 8.7 – 配置 GitHub 中的 Releases Webhook

我们现在已经学习了如何将 Jira 与 GitHub Releases 集成，并且如何在将所有受影响的开发任务转移到完成状态后，使用自动化规则在 Jira 中发布相应版本。在下一节中，我们将学习如何在冲刺完成时，使用 Jenkins 自动启动部署构建。

与冲刺完成同步部署

在敏捷 Scrum 中，一个在冲刺期间创建的工件是产品增量，它是通过完成产品待办事项中的任务所产生的可交付成果。在本节中，我们将学习如何通过自动化规则与 Jenkins 集成，以便在 Jira 中的冲刺关闭时自动启动最终部署构建。

在一个冲刺期间，在基于主干的开发模型中，开发人员会将代码提交到与开发任务相关的源代码库中的分支，这通常会启动自动化测试，以验证新代码不会对构建过程产生负面影响。当创建并合并拉取请求时，可以进一步启动自动化测试，随后是自动化部署到 QA 或预发布服务器。到冲刺完成时，所有这些过程最终会导致将生成的产品增量部署到生产环境，或者通过像 GitHub 这样的工具创建发布。

让我们看看如何通过自动化规则实现这一目标。

创建启动部署构建的规则

在本例中，我们将创建一个规则，每当冲刺完成时，都会启动一个软件项目的生产构建。为了实现这一目标，我们首先需要在 Jenkins 中配置作业，以允许通过脚本远程触发构建。

提示

如果你还没有 Jenkins 实例，可以在 aws.amazon.com 注册一个 AWS 账户，并基于 Jenkins Certified by Bitnami AMI 启动一个新的 EC2 实例。此 AMI 包含了如何在 AWS 中启动并运行 Jenkins 的完整说明。

我们将从导航到 Jenkins 中的项目开始。在项目的配置屏幕中，选择构建触发器选项卡，然后选择远程触发构建选项。Jenkins 需要提供一个身份验证令牌，以确保只有知道此令牌的远程系统才能启动构建作业。

这个令牌可以是您选择的任何文本字符串。在我们的示例中，我们将使用 MY_SECURE_AUTH_TOKEN 作为 身份验证令牌。配置好 Jenkins 后，构建触发器部分应该类似于以下截图：

图 8.8 – 配置 Jenkins 以允许远程触发构建

现在我们已经配置好了 Jenkins，接下来我们来构建一个自动化规则，在冲刺完成时启动部署：

1. 在您的 Jira 软件项目中，导航到 项目设置，点击 项目设置 菜单中的 自动化 链接，然后点击 创建规则。

2. 选择 冲刺完成 触发器，在 看板 字段中选择您的项目的 Scrum 看板，然后点击 保存。在这个例子中，我们将选择 我的应用程序 Scrum 看板。

3. 向 Jenkins 发送 API 请求需要我们从 Jenkins 令牌颁发服务获取一个 API 令牌。该服务返回一个令牌，我们随后需要在与 API 交互时使用，格式如下：

   {
       "_class": "hudson.security.csrf.DefaultCrumbIssuer",
       "crumb": "18b1846…",
       "crumbRequestField": "Jenkins-Crumb"
   }
   

   为此，选择 https://<your_jenkins_host>/crumbIssuer/api/json

   Authorization

   Basic <your base64-encoded credentials>

   GET

   空

   {{webhookResponse}} 智能值。

4. 接下来，我们需要调用 Jenkins API 来启动我们在 Jenkins 中配置的部署构建。

   我们还需要在 步骤 3 中通过 Jenkins-Crumb 头发送我们获取到的 Jenkins 令牌。

   再次选择 https://<your_jenkins_host>/job/<your_job_name>/build?token=<YOUR_AUTHORIZATION_TOKEN>

   在第一个 Authorization 中填写以下内容

   Basic <your base64-encoded credentials>

   填写以下第二个 Jenkins-Crumb

   {{webhookResponse.body.crumb}}

   POST

   空

   {{webhookResponse}} 智能值。

5. 如果在 Jenkins 中成功启动构建，我们希望将所有在冲刺中等待部署的问题转换为 {{webhookResponse}} 智能值，该值始终包含来自最新 {{webhookResponses}} 列表的响应，该列表将按 Web 请求操作的顺序包含响应，从位置零（0）开始。还请注意，只有在您检查了 {{webhookResponse.status}} 后，响应才会添加到此列表中。

   完全匹配正则表达式

   2\d\d

6. 接下来，选择 分支规则 / 相关问题，然后在 相关问题类型 字段中选择 冲刺中的问题，然后点击 保存。

7. 然后，选择 Status

   等于

   等待部署

8. 现在，我们需要根据 步骤 7 中的条件转换这些问题。

   选择 新建动作，然后选择 转换问题。在 目标状态 字段中，选择 已完成，然后点击 保存。

   您的规则应类似于以下截图：

   

   图 8.9 – 冲刺关闭时启动 Jenkins 部署的规则

9. 最后，将规则命名为开始部署（冲刺关闭时），然后点击启用以保存并启用规则。

这就结束了本章的最后一部分，在这一部分中，我们学习了如何使用自动化规则与 Jenkins 集成，在冲刺完成时自动启动部署构建，并将所有受影响的开发任务转移到已完成。

总结

在本章中，我们已经学会了如何通过使用自动化规则，通过优化我们的开发和运维流程，来帮助我们改进 DevOps 实践。

我们介绍了如何使用 Jira Cloud 中内置的 DevOps 自动化触发器，与我们的源代码仓库（如 Bitbucket 或 GitHub）进行集成。这使我们能够将 Jira 中的开发任务与提交到源代码仓库的代码保持同步。

此外，我们还学会了如何在使用 Jira Server 或 Data Center 时，通过在规则中使用传入 Webhook 来实现类似的集成，而不是使用 Jira Cloud 中的 DevOps 触发器。

接下来，我们学习了如何使用 Jira Cloud 中可用的 DevOps 拉取请求触发器，自动同步 Jira 中的开发任务。我们还学会了如何创建和管理跟踪任务，这些任务为 Jira 中的整体开发过程提供了更大的可视性。

接着我们学习了，在使用 GitHub 管理软件发布时，如何利用自动化规则将受影响的 Jira 问题转移到已完成状态，并在创建 GitHub 发布时，如何自动保持 Jira 中的版本同步。最后，我们学会了如何在 Jira 中完成冲刺时，自动启动 Jenkins 中的软件项目部署构建。

通过将自动化规则引入我们的 Jira 流程，我们可以简化我们的 DevOps 流程，并大幅减少开发人员在多个工具中执行任务所需的时间。

在下一章中，我们将探索在 Jira 中创建自动化规则时需要遵循的一些最佳实践。

第九章：第九章：最佳实践

在 Jira 中自动化任务和流程的能力，为简化项目和提升生产力打开了全新的可能性。

这反过来又带来了自己的复杂性，如果方法不当，你可能最终会有一堆规则，这些规则不仅没有提升生产力，反而比开始之前带来更多的麻烦。

本章的重点是提供一套指南，帮助你在自动化过程中获得最大收益。

我们将学习从规划规则开始，然后再深入实施规则，并了解如何编写规则以确保最大化性能。最后，我们将讨论一些最佳实践，帮助你组织规则，使其更易于管理和维护。

本章将涵盖以下主题：

• 规划你的规则

• 考虑性能

• 组织你的规则

技术要求

本章的要求如下：

• Jira 云环境：如果你尚未使用 Jira，可以在www.atlassian.com/software/jira/free创建一个免费的 Jira 云帐户，并确保选择了Jira Software 和 Jira Service Management。

• Jira 服务器环境：如果你使用的是 Jira Server（可从www.atlassian.com/software/jira/download下载），请确保你拥有 Jira Software 和 Jira Service Management 的许可证。此外，你还需要确保安装了Jira 自动化应用， 可从 Atlassian Marketplace 获取。

你需要是全局的 Jira 管理员，才能跟随本章中的示例。此外，我们使用了Scrum 软件项目模板来创建这两个软件项目，以便进行示例演示。

你可以从本书的官方 GitHub 仓库下载本章的最新代码示例：github.com/PacktPublishing/Automate-Everyday-Tasks-in-Jira。请访问以下链接查看 CiA 视频：bit.ly/3oVOYw1

规划你的规则

在你开始创建自动化规则之前，应该明确你想要自动化的目标，以及如何达成期望的结果，这些都是你在规划阶段需要思考的问题。

首先制定自动化策略，将确保你的自动化规则符合目的、有效率，并达到组织的目标。

在这一节中，我们将讨论一些规划规则的最佳实践。

规划你的自动化策略

值得记住的是，自动化的主要目的是简化你的业务流程，确保你的流程更高效地运行。

在计划自动化内容时，首先要做的事情之一是与用户互动。这将揭示出关于他们花费大量时间执行哪些任务以及如何利用自动化规则来提高他们的生产力的宝贵见解。

您还应考虑系统中现有请求的使用模式，以确定是否有可以应用于提高整体效率的自动化机会。

通过提前计划您的规则，并确保它们与您的整体业务和流程目标一致，您将清楚地了解到应自动化什么以确保自动化工作的整体成功。

接下来，我们将看看在规则规划期间应考虑使用适当的范围的原因。

设定规则的范围

正如我们在第一章中所看到的，自动化的关键概念，Jira 中的规则可以适用于四种范围之一：

• 单一或特定项目的规则：当在项目内创建规则时，此范围会自动应用。在此范围中的一个示例规则是按计划创建特定项目的任务。

• 多项目规则：通过指定适用规则的特定项目名称来启用此范围，并且只能由 Jira 管理员应用。在此范围中的一个规则示例是保持两个项目之间软件版本的同步。

• 全局规则：当管理员从全局管理视图创建规则时，此范围会自动应用。这个范围中的规则适用于实例中的每个项目。例如，在此范围中的一个规则是当一个问题被标记为重复时关闭它。

• Jira 云中特定项目类型的规则：这个范围仅适用于 Jira 云，并允许将规则应用于特定类型的所有项目。例如，一个规则可以关闭一个客户请求，如果该请求在 5 个工作日内未更新。

这是规划自动化规则的重要方面之一。

使用自动化的主要目的之一是提高流程效率，当决定如何设置自动化规则本身时，这一点是正确的。

在 Jira 实例中，多个项目共享工作流程和其他常见配置是很常见的。在一个规则也在多个项目中共享的情况下，维护单一规则比维护各自的重复规则更为高效。

当然，这需要与全局和多项目规则只能由具有全局 Jira 管理员权限的用户维护而不是项目管理员的事实进行平衡。

思考规则设计

一旦确定了规则如何与组织的整体业务和流程战略相适应，接下来要关注的是设计实际的自动化规则本身。

自动化的一个关键原则是简化流程并减少重复性工作，因此你应尽量避免创建过于复杂且难以理解的规则。

你的规则应该是原子的，并且应该尽可能简单，以完成既定任务。始终记住，自动化规则通常会在原作者转向其他事务后长期存在，因此它们应该足够直观，便于其他人理解规则如何工作以及它们如何协同工作。

这引出了下一个要点：文档化你的规则。文档化每个规则始终是一个良好的做法。您应该在文档中包含规则的业务案例，并确保它与现有的业务目标一致。

规则的文档还应包括该规则依赖于其他规则或外部系统的任何信息。例如，如果该规则可以通过另一个规则的完成来触发，则应在文档中包含这一点。

确保规则文档完备可以实现以下几个目标：

• 这确保了业务的连续性。当原规则的作者离开时，他们的继任者可以快速理解规则背后的目的。

• 它促进了可见性。其他项目管理员可以快速看到是否有任何现有规则可以在他们的项目中使用，而不必重新发明轮子。

最后，您应该将规则的副本保存在像 Bitbucket 或 GitHub 这样的版本控制系统中。这不仅能确保您有每个规则的备份，还能让您追踪每个规则的变更历史。

您无疑会遇到有人对规则进行更改的情况，最好会导致一些小错误，最坏的情况会引发重大事件。

具备将有问题的规则快速回滚到已知的正常版本的能力，可以帮助您高效地解决这类事件。

Jira 的自动化功能允许您导出每个规则的副本，该副本可以以 JSON 格式下载，然后您可以将其保存在自己选择的版本控制系统中。

在下面的截图中，我们可以看到，点击每个规则右侧的省略号（…）按钮，您可以选择导出该规则：

](https://github.com/OpenDocCN/freelearn-devops-pt7-zh/raw/master/docs/auto-evdy-task-jira/img/Figure_09.1_B16551.jpg)

图 9.1 – 导出单个规则到 JSON

Jira 管理员还可以选择将系统中所有的自动化规则导出为一个单独的可下载 JSON 格式文件。

定期执行此操作并将结果文件存储在版本控制中，可以让管理员在更广泛的事件发生时快速恢复所有项目中的自动化规则。

Jira 管理员可以通过访问全局管理界面，在齿轮图标下选择系统菜单，然后从左侧菜单中选择自动化规则标签，执行此操作。

你可以使用创建规则按钮右侧的省略号（…）按钮来访问菜单选项，从而导出所有规则，如下图所示：

图 9.2 – 将所有规则导出为 JSON

现在我们已经理解了规划规则的一些最佳实践，让我们通过一个示例来说明这一点。

创建一个规则来同步高优先级的错误

对于这个示例，我们将使用以下场景。

我们在 Jira 中有两个软件项目，My Application，项目键为 MAPP，开发团队使用该项目来跟踪他们的开发工作；另一个是 My Application Support，项目键为 MAPS，该项目允许客户报告错误并提出其他请求，而不会让开发项目淹没在无关问题中。

与应用支持团队沟通后，我们发现手动分类优先级最高的错误并创建关联的开发错误既耗时又容易出错。我们还确认已经采取了严格的检查措施，以限制创建优先级最高的错误。如果需要，支持团队也可以提升错误的优先级。

我们将使用这些信息创建一个自动化规则来处理这些特定的错误：

1. 我们将创建一个全局规则，因为涉及多个项目，所以只有 Jira 管理员才能创建此规则。

   点击顶部菜单栏中的设置（齿轮）菜单，选择系统。然后，在左侧菜单中选择自动化规则选项卡，最后点击创建规则。

2. 该规则需要在问题创建时以及手动提高优先级时都能生效，因此选择多事件触发，在问题事件字段中选择问题创建和问题更新。点击保存。

3. 该规则应仅适用于 MAPS 项目中优先级最高的错误。

   选择新条件，然后选择JQL 条件。在JQL字段中输入以下查询并点击保存：

   Project = MAPS AND type = Bug AND priority = Highest
   

4. 为了确保在多次更改优先级时不会在开发项目中创建多个错误，我们需要为规则添加一个额外的条件。

   选择关联问题

   relates to

   Are not present

5. 接下来，我们想要在 MAPP 项目中创建一个关联错误。

   选择受影响的版本、优先级和关联问题字段。

   按照如下字段完成填写，然后点击My Application (MAPP)

   相同问题类型

   relates to

   触发问题

   该规则应该类似于以下截图所示：

   

   图 9.3 – 用于在项目之间创建关联错误的规则

6. 最后，命名该规则为同步最高优先级支持错误并点击开启以保存并启用该规则。

我们已经在本节中学习了如何提前规划规则，并确保它们符合你的整体业务和流程策略，同时得到适当的文档记录和控制，这将确保你的自动化工作取得最终成功。

提示

Atlassian 提供了一个模板库，你可以使用这些模板作为规则的起点。此外，还提供了一个自动化游乐场，你可以在其中探索各种规则组件并创建虚拟规则。你可以通过www.atlassian.com/software/jira/automation-template-library访问这两个资源。

在接下来的部分，我们将介绍一些最佳实践，确保你编写的规则能够高效运行，保持你的 Jira 实例响应快速并顺利运行。

考虑性能

在为任何系统规划自动化规则时，你应该确保它们能够高效执行，并且不消耗超过绝对必要的资源。这对于保持系统的良好运行和响应性至关重要。

你正在引入自动化来提高生产力和优化耗时的流程。你最不希望看到的就是自动化本身对系统性能产生负面影响。

Jira 中的自动化引擎旨在尽可能最大化性能；然而，在编写规则时，有一些考虑因素可以确保它们表现最佳。我们将在本部分中探讨其中的一些考虑事项。

使用项目特定的规则

规则的范围在性能方面起着重要作用。它决定了给定规则最初排队的执行次数。

比如，如果你有 50 个项目，并且有一个使用创建问题触发器的全局规则，那么当“创建问题”事件被触发时，规则引擎会排队 50 次执行，每个匹配项目 1 次。

如果你使用“创建问题”触发器添加另一个全局规则，100 次执行将被排队，也就是说，每个匹配触发器的每个匹配项目都会有 1 次执行。

如你所见，应用过宽的范围很容易导致潜在的性能问题。

一般来说，你创建的大多数规则通常是特定于某个项目的，因此规则的范围应该限于该项目。

将规则的范围限定为实际需要的项目，将确保每个事件只排队最少数量的规则执行。

在接下来的部分，我们将探讨如何选择适当的触发器，以优化规则的性能。

使用适当的触发器

另一种确保最大性能的方法是为你的规则使用合适的触发器。这一点在你的规则依赖于特定字段的更改时尤其重要。

例如，如果你有一个规则，应该将子任务的所有故事点总和加到父任务中，你可以使用问题更新触发器，正如下面截图所示：

图 9.4 – 使用问题更新触发器来触发规则

虽然这种方法并不错误，且可以正常工作，但更高效的方法是使用字段值更改触发器，并进一步将其限制为编辑问题操作，如下截图所示：

图 9.5 – 使用更高效的字段值更改触发器

这样做的原因再次在于，当 Jira 中的事件被触发时，自动化引擎将排队与触发器匹配的规则执行。

在前面的示例中，使用问题更新触发器将匹配所有配置了问题更新触发器的规则。例如，如果你有 10 个规则使用问题更新触发器，在子任务中更改故事点字段将导致 10 个规则执行被排队等待处理。这是因为规则引擎无法确切知道哪个问题更新规则是相关的。

将规则更改为使用字段值更改触发器，并仅监控故事点字段的编辑问题操作，将仅排队一个规则执行，前提是没有其他规则使用完全相同的触发器配置。

选择正确的条件

条件用于通过限制哪些问题会受到规则中后续操作的影响，来缩小规则的作用范围。

最有效的规则是那些对执行额外操作的任务数量最少的规则，因此尽早在规则执行链中排除不需要处理的问题，将确保你的规则尽可能高效地运行。

此外，并非所有条件都是平等的。在决定使用哪个条件时，最佳的做法是尽可能早地考虑使用最有效且性能最好的条件。

按性能排序的条件，性能从高到低依次为：

• 问题字段条件

• 高级比较条件

• JQL 条件

问题字段条件适用于在条件评估时规则中已经存在的数据，并使用简单的比较将字段与常量值或一组值进行比较。由于不需要进一步处理来评估，这是最有效的条件，可以用于你的规则。

当你有多个字段需要比较时，你可以将多个问题字段条件链式连接，以执行更复杂的比较，并且仍然保持整体性能。

按性能顺序排列，下一个条件是高级比较条件。该条件允许使用智能值和正则表达式，因此这些需要先被解析，然后才能评估该条件。

类似于问题字段条件，你可以将多个高级比较条件串联在一起，以执行更复杂的比较。

最后，JQL条件是这三种条件中最昂贵的。它还允许你在比较中使用 Jira 搜索功能的全部能力。JQL 条件还可以包含智能值，如果使用这些值，它们需要先被评估，然后查询才能发送到 Jira 执行。

让我们重新审视一下我们在规划规则部分中介绍的同步最高优先级 bug 的规则，看看我们如何优化其性能。

优化规则性能

在该规则的第一次迭代中，我们使用多个问题事件触发器创建了一个全局规则。正如我们所了解到的，这可能会对我们的 Jira 实例造成性能影响。

这是因为我们为规则使用了全局范围，因为它适用于多个项目。我们还使用了多个问题事件触发器来监听问题的创建和更新事件。最后，我们使用了JQL 条件来缩小规则的适用范围，而我们已经了解到，这是最不高效的条件。

让我们更新规则，以考虑这些性能问题：

1. 作为 Jira 管理员，点击顶部菜单栏中的设置（齿轮）菜单，选择系统。然后，选择左侧菜单中的自动化规则标签，最后点击同步最高优先级支持 bug规则。

2. 首先，我们将更新触发器为字段值更改触发器。

   点击规则链视图左侧的当：规则触发时组件。

   接下来，点击多个问题事件右侧的铅笔图标以更改触发器。

3. 选择优先级

   创建问题和编辑问题

4. 接下来，我们将用更高效的问题字段条件替换JQL 条件。我们将使用if/else 块来使规则更易读。

   选择新条件，然后选择If/else 块。

5. 点击项目

   等于

   我的应用支持（MAPS）

6. 点击问题类型

   等于

   Bug

7. 点击优先级

   等于

   最高

8. 点击关联问题

   相关

   未出现

9. 删除If: 问题匹配 JQL条件。你可以通过点击规则链视图中组件右上角的X，或选择组件并点击组件名称右侧的垃圾桶图标来删除该条件JQL 条件。

10. 通过点击规则链视图中组件右上角的X，或选择组件并点击组件名称右侧的垃圾桶图标，删除If: 未关联问题条件。

11. 然后，我们需要将创建问题动作移到If…else 块中。这是通过在规则链视图中点击并拖动该动作，然后将其放置在If: all match component和Add component链接之间来实现的。

12. 最后一步是更改规则的范围。点击多个项目

    我的应用支持（MAPS）和我的应用（MAPP）

    规则现在应该类似于以下截图：

    

    图 9.6 – 为性能优化规则

13. 最后，点击发布更改以保存我们对规则所做的更改。

在这一节中，我们学到了使用正确的规则范围对性能的影响。我们还学习了如何选择适当的触发器和条件，通过选择最有效的组件来保持规则的最佳性能。

在下一节中，我们将看看如何组织规则，使它们更易于跟踪和管理。

组织你的规则

随着时间的推移，随着你在更多项目中自动化更多任务，管理和跟踪所有自动化规则将变得更加复杂。

处理越来越多的自动化规则和配置的最佳方法是逻辑地组织每个规则。

在这一节中，我们将探讨一些最佳实践，以保持规则的最佳组织方式，使它们更容易查找和管理。

我们将从一个应该对任何曾经处理过大量系统配置的人员来说都很熟悉的概念开始：命名约定。

使用命名约定

使用明确定义的命名约定可以让用户一致地识别规则，并帮助你以有意义的方式组织规则。

一个好的命名约定需要提前规划、文档化，并对所有管理自动化规则的人可见。

Jira 中的自动化规则列表按字母顺序排列，在设计命名约定时应充分利用这一点，这样可以将相关项目分组在一起。

注意

你可以按工作列表中的任何列来排序你的自动化规则。然而，排序顺序总是默认按名称的字母升序排列。

例如，您的命名约定可以规定每个规则应以其适用的事务类型为前缀。在软件项目中，这可能类似于Bug、Epic、Story、Task等。这样一来，规则的适用对象一目了然，而且这些规则在按名称排序时总是会被分组在一起。

除了建立命名约定外，还有一个良好的实践是详细描述每个规则的作用，使用描述字段。这将使查看规则列表的任何人立即了解到规则实际上在做什么，而无需检查每个规则。

在下面的屏幕截图中，您可以看到使用命名约定如何将规则分组在一起：

图 9.7 – 应用命名约定的规则列表

此外，您可以看到通过使用规则描述清楚地记录规则实际执行的操作，可以更轻松地导航和管理自动化规则列表。

为您的规则打标签

除了使用命名约定外，您还可以并且应该定义标签来分类和标识您的自动化规则。

在自动化规则的上下文中，标签是一个带有颜色编码的关键字，您可以分配给自动化规则以更轻松地识别它们。

理想情况下，您应该为您的标签使用简短的功能术语；以下是一些功能性标签的示例：

• 客户通知: 发送通知给客户的规则

• 内部通知: 发送通知给团队成员的规则

• 支持: 处理支持问题的规则

• 同步: 处理保持问题或其他项同步的规则

• 软件发布: 处理软件项目中版本控制的规则

上述列表只是您项目中可能使用的功能性标签名称的小样本。

此外，自动化规则可以分配给多个标签。例如，将一个从支持项目创建链接错误到开发项目的规则可以同时标记为支持和同步标签。

要创建新标签，或者使用之前定义的现有标签，请按照以下步骤进行：

1. 在左侧的规则列表视图中，点击添加标签按钮。

2. 在输入标签名称字段中输入标签名称。

3. 可选地，通过点击字段右侧的彩色块来选择颜色。

   如果标签已经定义，当您开始输入时，它将显示在标签名称字段下面的列表中。

4. 要使用之前定义的标签，只需点击其名称。

5. 一旦定义了标签名称和颜色，点击完成。

   您可以看到如何在下面的屏幕截图中创建标签：

图 9.8 – 添加新标签

现在您已经定义了标签，您需要将规则分配给相应的标签。通过点击并拖动规则到适当的标签上完成此操作。

一旦你创建了标签并相应地分配了规则，通过选择合适的标签来缩小规则列表的范围，就能更轻松地管理大量的自动化规则，正如下图所示：

图 9.9 – 使用标签快速查找合适的规则

现在我们已经获得了一些关于如何组织规则的见解，让我们将其应用于我们在优化规则性能部分优化过的规则。

规则的命名和标签

让我们完成我们的规则，通过使用命名约定来同步最高优先级的问题。我们还将使用描述字段来描述规则的功能，然后适当标签化它：

1. 作为 Jira 管理员，点击顶部菜单栏中的设置（齿轮）菜单，然后选择系统。接着，在左侧菜单中选择自动化规则标签，最后点击同步最高优先级支持 Bug规则。

2. 在Bug – 同步最高优先级支持 Bug

   当 MAPS 项目中的一个 Bug 被创建为最高优先级，或者其优先级被更新为最高时，在 MAPP 项目中创建一个关联的 Bug。

3. 点击发布更改以保存规则，然后点击返回列表以返回规则列表。

4. 创建两个标签，分别命名为同步和支持，然后依次点击并拖动Bug – 同步最高优先级支持 Bug规则到每个标签上。

   现在，当与其他规则一起列出时，该规则应该看起来类似于以下截图：

图 9.10 – 使用命名约定和标签组织规则

我们已经学到，通过使用命名约定来组织规则，可以更容易地找到并管理它们。此外，使用描述字段创建规则的叙述帮助你快速识别规则的作用。最后，结合使用功能标签将在长期维护规则时节省时间并减少困扰。

使用检查清单

在创建规则时，你不可能总是记得我们在本章中讨论的所有要点，以确保你的规则遵循最佳实践。

拥有一个可以快速参考的检查清单有助于确保你遵循了本章中呈现的最佳实践以及你所制定的任何组织指导原则。

因此，我们整理了一份基本的检查清单，可以作为你创建适合你需求格式的清单的起点：

• 该规则的作用范围正确，仅限于受影响的项目或项目组。

• 该规则已被记录，并包含了业务案例和实施方法。

• 该规则已经导出并存储在如 GitHub 或 Bitbucket 等版本控制系统中。

• 使用了适当的触发器，例如“字段值已更改”而不是“问题已更新”。

• 该规则使用了最有效的条件，例如“问题字段”条件，并且只有在规则中确实需要时才依赖更昂贵的条件。

• 该规则根据文档中规定的命名约定命名。

• 规则描述充分说明了规则的作用。

• 该规则已分配到适当的功能标签。

现在，您已拥有了检查清单，您可以用它快速识别规则是否遵循了您制定的所有准则。这将确保您的规则既易于管理，又不太可能在长期内导致性能问题。

总结

在本章中，我们学习了一些规划、实施和组织自动化规则时应遵循的最佳实践。

我们了解到，在 Jira 中，你应该提前规划自动化策略，以便与业务和流程目标对齐，从而确保自动化工作的最终成功。

我们还了解到，为了确保业务连续性并避免不必要的重复工作，您的规则应该在外部系统（如 Confluence）中妥善记录，并向相关团队成员公开。

此外，您还应该理解将规则的外部副本保存在版本控制系统（如 Bitbucket 或 GitHub）中的重要性，以确保当规则发生意外的破坏性更改时，可以通过导入最后已知的工作版本迅速解决问题。

接下来，我们学习了如何在编写规则时考虑性能，使用适当的项目范围来定义自动化规则，并了解为何使用正确的触发器和条件对确保自动化规则的最佳性能至关重要。

最后，我们了解了如何定义并使用命名约定，通过默认按字母顺序组织规则，将规则进行分组。我们还学习了如何使用标签功能，通过功能性标签来组织我们的规则。

在下一章中，我们将介绍一些调试自动化规则的技巧和方法，以及如何理解和使用服务限制与性能洞察来监控 Jira 实例中的自动化规则。

第十章：第十章：故障排除技巧和方法

不可避免的是，某个时刻你的自动化规则将会因错误或无法解释的原因而失败或变慢。即使是精心规划和实施的规则，也终会遭遇无法预见的错误。在这些情况下，了解如何主动监控、故障排除和调试规则，将帮助你更快地解决这些问题。

在本章中，我们将向你介绍一些技巧和方法，以更好地理解你的规则发生了什么以及如何调试它们。我们将查看审计日志，并介绍如何利用它来更好地理解规则执行过程中发生的事情，以及如何利用它进行调试。

我们还将了解为防止不合规的规则对实例性能产生负面影响而设定的服务限制，以及如何主动监控你的规则，以避免违反这些限制。

最后，你将学习如何使用性能洞察指标来概览系统中自动化规则的性能。这将帮助你识别可能导致性能问题的规则，从而能够维持和改进你的 Jira 实例的性能。

在本章中，我们将覆盖以下主题：

• 调试自动化规则

• 了解服务限制

• 获取性能洞察

技术要求

本章的要求如下：

• Jira Cloud 环境：如果你尚未访问 Jira，你可以在www.atlassian.com/software/jira/free创建一个免费的 Jira Cloud 账户，并确保选择了 Jira Software 和 Jira Service Management。

• Jira Server 环境：如果你使用的是 Jira Server（可从www.atlassian.com/software/jira/download获取），请确保你拥有 Jira Software 和 Jira Service Desk 的许可证。此外，你还需要确保安装来自 Atlassian Marketplace 的 Automation for Jira 应用。

在这两种实例中，你需要至少拥有 项目管理员 权限才能跟随本章中的示例。为了演示本章中的示例，我们使用了 IT 服务管理项目模板 来创建服务台项目。

你可以从本书的官方 GitHub 仓库下载本章的最新代码示例，网址为github.com/PacktPublishing/Automate-Everyday-Tasks-in-Jira。请访问以下链接查看 CiA 视频：bit.ly/2XSttjY

调试自动化规则

自动化规则失败的原因有很多。这些可能是由于 Jira 中的基础配置更改，或者规则的创建者在规划和实施规则时未预见到某些边缘情况。

当规则开始失败时，必须了解是什么导致规则失败，并修复潜在原因或调整自动化规则以考虑到导致失败的变化。

然而，调试不仅仅是找到并修复自动化规则或 Jira 配置中的不足之处。我们可以在规划和开发过程中使用相同的技术，确保我们交付的规则更为健壮，从而更可能成功。

在本节中，我们将了解如何使用审计日志来帮助自动化规则识别问题，以及在调试自动化规则时如何利用它。

首先，让我们看看审计日志及其如何帮助我们了解规则的执行情况。

理解审计日志

每个自动化规则都有一个相关的审计日志，包含从规则创建开始，按时间顺序排列的所有影响该规则的条目。

这些项不仅跟踪规则的创建、修改和删除事件，还记录规则的每次执行，包括受影响的事务和规则中每个动作的结果。

有三种查看审计日志的方式：

• 全局审计日志：全局审计日志允许 Jira 管理员查看系统中每个项目和规则的所有审计日志。作为 Jira 管理员，你可以通过点击顶部菜单栏的设置（齿轮）图标，然后选择系统，找到全局审计日志。在左侧菜单中选择自动化规则标签页，然后在 Jira Cloud 中选择审计日志标签页。在 Jira Server 或 Jira Data Center 中，点击省略号（…）按钮并选择显示审计日志。

• 项目审计日志：项目审计日志允许项目管理员查看该项目中每个规则的所有审计日志。作为项目管理员，要找到项目审计日志，请导航至项目设置。在 Jira Cloud 中，选择左侧菜单中的自动化标签页，然后选择审计日志标签页。在 Jira Server 或 Jira Data Center 中，选择左侧菜单中的项目自动化标签页，然后点击省略号（…）按钮并选择显示审计日志。

• 规则审计日志：规则审计日志让你仅查看该特定规则的所有日志项。要查看规则审计日志，选择一个规则，然后点击审计日志项，位于规则链视图上方。

以下截图显示了全局审计日志的示例，展示了跨所有项目的规则审计日志：

图 10.1 – Jira Cloud 中的全局审计日志视图

在全局审计日志和项目审计日志视图中，点击规则名称将带您进入该规则的审计日志视图。在每个规则视图中，点击操作列中的显示更多链接，将展开该事件的审计日志详细信息。

以下截图展示了项目审计日志视图，其中一些单独的审计项已展开，显示了详细的审计日志：

图 10.2 – 审计日志详细信息

让我们看一下审计日志中的每一项：

1. 每个审计日志都有一个关联的日期和时间戳，准确到秒，显示该事件发生的具体时间。审计日志按日期和时间降序排列，最新的事件显示在列表的顶部。日期和时间戳旁边的括号中的数字是规则的标识号。

2. 这是与该审计日志相关联的规则名称。在全局审计日志和项目审计日志视图中，点击规则名称将带您进入该规则的审计日志。您还可以在全局或项目审计日志视图中查看已删除规则的审计日志历史。已删除的规则很容易识别，因为它们没有指向规则定义的超链接。

3. 在这一列中，您可以看到规则是否成功执行。此外，它还显示了规则的配置更改，这在调试规则失败时非常有帮助。

4. 每次规则执行时，运行所花费的时间都会被记录并显示在这一列中。

5. 对于规则执行，相关项显示哪些问题被添加到规则执行中，以及由哪个规则组件添加。点击该组件将直接带您到负责该操作的组件配置。对于配置事件，它将显示执行操作的用户。

6. 规则执行所执行的所有操作都在这里列出，并按操作分组。对于规则中配置的每个操作，您将看到一个成功的任务列表。如果操作失败，则会显示错误信息。点击任何操作将直接带您到该操作的配置屏幕。

7. 展开不同状态代表的含义选项将列出所有可能的状态代码及其含义。

现在我们已经了解了如何读取审计日志，接下来我们来看一下如何利用它来调试规则。

使用审计日志进行调试

查看智能值中存储的内容或检查智能值函数的结果，可以让您了解规则中发生的情况。这在设计规则或调试行为不符合预期的规则时尤其有用。

为此目的，可以在您的规则中使用一个自动化动作组件——日志动作。该组件的唯一目的是将消息注入到审计日志中，您可以在调试规则时查看这些消息。

让我们来看一个使用 Log 操作组件的示例。

使用 Log 操作记录消息

Log 操作组件允许你将消息注入到审计日志中，这样你就可以添加调试语句，帮助你理解规则执行时发生了什么。

在此示例中，我们将使用 Log 操作组件，在调用创建子任务操作之前和之后，将时间戳添加到审计日志中：

1. 在你的 Service Desk 项目中，导航到项目设置，点击自动化标签页，然后点击创建规则。

2. 选择问题创建触发器，然后点击保存。

3. 然后选择Request Type

   equals

   Onboard new employees

4. 现在选择{{now}} 开始创建子任务

5. 接下来，选择Provision new laptop by {{issue.duedate.longDate}}

   Setup new desk phone by {{issue.duedate.longDate}}

6. 再次选择{{now}} 结束创建子任务

7. 接下来，给你的规则命名为Create onboarding sub-tasks with debug logging，然后点击启用，以保存并启用规则。

   规则应类似于以下屏幕截图：

图 10.3 – 使用调试日志创建规则

现在我们已经设置好规则，使用提出请求链接，从你的 Service Desk 项目中创建一个新的问题，选择Onboard new employees请求类型，然后返回到使用调试日志创建入职子任务规则，点击审计日志项。

展开审计日志项后，你应该能看到类似以下屏幕截图的内容：

图 10.4 – 带有调试日志消息的审计日志

你可以在审计日志中看到我们在创建子任务操作前后插入的消息：

1. 第一个日志操作消息会在调用创建子任务操作之前。

2. 第二个日志操作消息会在创建子任务操作之后被调用。

从中，你现在可以确定Sub-task问题类型的持续时间。

使用调试智能值功能记录消息

使用 Log 操作将消息插入审计日志，使得调试你的规则变得更加容易。然而，如果你有太多 Log 操作组件来记录像智能值函数的输出这类信息，你就必须重复你的智能值，以便创建调试日志。

为了解决这个问题，你可以使用调试智能值功能。这涉及将你的智能值包裹在{{#debug}}函数中。

让我们来看一个示例规则，使用调试智能值功能来实现这个目标：

1. 在你的Service Desk项目中，导航到项目设置，点击自动化标签页，然后点击创建规则。

2. 选择Waiting for customer

3. 现在，选择新建操作，然后选择评论问题。将以下消息添加到评论字段中，然后点击保存：

   Hi {{issue.reporter.displayName}}
   We require some additional information from you to complete your request.
   Please update this issue by {{#debug}}{{now.plusBusinessDays(5).fullDate}}{{/}}.
   Kind regards,
   The Service Desk Team
   

   你的规则应类似于以下屏幕截图：

   

   图 10.5 – 使用调试智能值函数

4. 最后，命名规则为带调试日志的等待客户评论，然后点击启用以保存并启用该规则。

创建一个服务请求类型的问题，将其转换为等待客户状态，然后返回到带调试日志的等待客户评论规则，点击审计日志项。

展开顶层审计日志项后，您的审计日志应如下所示：

图 10.6 – 使用调试智能值函数的审计日志

使用{{#debug}}智能值函数导致调试消息被打印到审计日志中，并附带评论问题操作输出的信息，而无需向规则中添加单独的日志操作组件。您可以在图 10.6中标记为(1)的项中看到这一点。

我们在本节中学习了如何从全局、项目和规则角度理解和使用审计日志，以及日志中的各种项目能告诉我们什么。

我们还学习了如何从规则中发送消息到审计日志，以帮助调试规则。

在下一节中，我们将查看服务限制，这些限制是为了防止规则对 Jira 实例的性能产生负面影响。

理解服务限制

自动化规则的服务限制是确保自动化规则不会对 Jira 实例的性能产生负面影响的关键。

在本节中，我们将查看现有的服务限制以及它们如何影响您的规则。我们还将讨论如何在这些服务限制内工作，以及如何使用自动化规则来监控其中一些限制。

让我们首先了解有哪些服务限制可用。

了解服务限制

服务限制适用于 Jira Cloud 和 Jira Server/Data Center 版本的自动化规则。

适用于所有规则的服务限制列出了每个限制可能被突破的描述：

• 每个规则的组件数：65

  包含超过 65 个条件、分支和操作的规则。

• 每个操作的新子任务：100

  尝试创建超过 100 个子任务的规则。

• 搜索到的问题：1,000

  返回超过 1,000 个项目的 JQL 查询将导致此限制被突破。

• 并发调度规则执行：1

  如果规则被调度为每 5 分钟运行一次，但执行时间超过 5 分钟，导致此限制被突破，因为在第一次执行仍在处理时，后续执行无法开始。

• 规则排队的项目：Jira Cloud 为 5,000，Jira Server/Data Center 为 25,000

  任何单一规则，若导致排队的问题超过指定数量，将违反此限制。

• 全局队列中的项：Jira Cloud 为 50,000，Jira Server/Data Center 为 100,000

  在任何时刻，队列中的问题总数不得超过指定的限制。

• 每日处理时间：每 12 小时 60 分钟

  每个执行时间超过 5 秒且每 5 分钟执行一次的单个规则将违反此限制。

• 每小时处理时间：100 分钟

  如果 Jira Cloud 每小时的规则执行次数超过 2,000 次，或 Jira Server/Data Center 每小时的规则执行次数超过 5,000 次，将触发此限制。这种情况可能会发生在执行批量操作时，导致多个规则同时触发。

• 循环检测：10

  一个规则如果在短时间内触发自己或其他规则超过指定次数，将触发此限制。

处理服务限制违反

当规则违反其服务限制时，自动化引擎会限制受影响的规则。审计日志将包含更多信息，并使用已限制状态来帮助更容易地识别。

因违反服务限制而被限制的规则也将被禁用，以防止进一步的性能问题。

重要提示

在设置规则时，您可以选择在规则首次失败时或每次失败时向规则所有者发送电子邮件通知。请注意，当通知发送时，规则已经被限制并禁用。

在常规执行的规则即将超出其处理时间限制的情况下，存在一个特殊触发器——服务限制违反触发器，您可以使用它来监控您的规则。您可以在规则被限制和禁用之前，利用此触发器设置自动化规则，以便提前通知您。

让我们快速了解如何设置自动化规则，监控规则何时达到处理时间限制的 80%，并通知您：

1. 在您的 Jira 项目中，导航到项目设置，点击项目设置菜单中的自动化链接，然后点击创建规则。

2. 选择已使用超过 80%的服务限制

   每小时一次

3. 接下来，选择管理员

   规则即将违反其服务限制

   即将违反其 80%处理时间限制的规则：{{breachedSummary}}。

   以下规则即将违反：

   {{breachedRules}}

   该规则应类似于以下截图：

   

   图 10.7 – 监控处理时间服务限制的规则

4. 最后，将规则命名为服务限制 80%通知，然后点击开启以保存并启用该规则。

现在，每当规则达到其处理时间限制的 80%时，将向管理员发送电子邮件通知，提醒他们在规则被限制和禁用之前采取行动。

处理队列项限制

Jira 中的自动化规则通过使用规则处理队列来工作。例如，如果您的 Jira 实例中有 50 个项目，并且存在一个使用问题更新触发器的全局自动化规则，每次任何项目中的一个问题被更新时，都会创建并排队 50 次规则执行。

添加第二个使用问题更新触发器的全局自动化规则将导致创建并排队 100 次规则执行；也就是说，每个规则在每个项目中执行一次。

如果每个规则仅适用于单个项目，则只会创建并排队两个规则执行。

正如您可以想象的那样，如果规则作用域过于宽泛且触发条件不具体，过多的错误作用域规则会迅速导致性能瓶颈，这只是其中一个例子。

在计划触发器或使用分支规则/相关问题组件的相关问题分支中使用 JQL 查询，也可能导致每个规则队列中的问题数量超过服务限制。

重要说明

超过队列项目限制的规则会被规则引擎自动禁用，以防止进一步执行，且违规的详细信息会记录在审计日志中。

为了防止规则队列中积压过多项目，您应该考虑以下指导原则：

• 对于您的规则，请使用尽可能狭窄的作用域。如果规则仅需要在单个项目或少数项目上操作，请相应地限制作用域。

• 当您的规则只对某个特定字段的变化感兴趣时，使用像字段值已更改触发器，而不是问题创建或问题更新触发器。

• 通过尽可能使查询更具体，限制 JQL 查询返回的结果数。

• 节制使用分支规则/相关问题组件。

在本节中，我们学习了自动化规则引擎所施加的各种服务限制，以及如何利用这些知识编写更高效的规则。在接下来的章节中，我们将学习如何使用性能洞察来概览自动化规则的整体性能。

获取性能洞察

为确保自动化规则的整体成功并保持性能在满意的水平，您需要留意可能长期引发问题的任何事项。

我们已经看到审计日志可以为您提供关于规则是否成功运行、是否出现错误、是否导致性能问题并被限制的洞察。除此之外，能够监控并主动通知管理员当规则可能超出服务限制时，有助于您及时关注这些问题。

虽然这确实有帮助，但检查审计日志可能会很耗时，特别是当您有大量规则频繁执行时。

在本节中，我们将介绍自动化规则的性能洞察功能，它将为你提供规则整体性能的鸟瞰图。

性能洞察对项目管理员和全局管理员均可用。项目管理员可以查看项目内所有规则的性能，而全局管理员则能查看系统中每个自动化规则的性能概况。

作为项目管理员访问性能洞察，首先进入项目设置，然后从左侧菜单中选择自动化链接（如果你使用的是Jira Server或Jira Data Center，请使用项目自动化链接）。然后，点击省略号（…）按钮，选择查看性能洞察菜单项。

要访问全局性能洞察，请点击顶部菜单栏中的设置（齿轮）图标，然后选择系统。接着，在左侧菜单中点击自动化规则，最后点击省略号（…）按钮，选择查看性能洞察菜单项。

性能洞察屏幕如下图所示，项目和全局性能洞察的界面类似：

图 10.8 – 查看性能洞察

让我们快速浏览一下性能洞察的各个方面：

1. 使用时间分辨率选项来选择图表显示过去一小时、一天、一周或一个月的规则执行数据。点击圆形箭头图标刷新屏幕上的数据。

2. 对于每个数据点，图表显示了规则的总执行次数、成功执行的次数、出错执行的次数以及被限制的执行次数。将鼠标悬停在图表上时，你将看到每个数据点的实际数字。

3. 位于表格上方的下拉菜单允许你选择在表格右侧的规则状态栏中显示哪些数据。可选项包括执行次数、平均持续时间（秒）和总持续时间（秒）。

4. 图表下方的表格显示了图表中的前 20 个规则。这些规则默认按执行次数降序排列。

   你可以通过点击每个相应列标题，按执行次数、总持续时间或平均持续时间进行升序或降序排序。

   点击规则名称将带你到该规则的审计日志，你可以在这里更详细地查看日志内容。

如你所见，性能洞察功能可以让你快速了解规则的表现，并能深入分析存在问题的规则。

使用按平均持续时间排序的性能洞察，将帮助你看到哪些规则在每次执行时花费的时间更长。这些规则可能是进一步检查的重点，以了解它们是否可以通过性能增强来受益。

执行次数多且持续时间较长的规则可能是最终突破处理时间限制的候选者，应检查这些规则是否可以进行改进。由于每个 Jira 实例的配置可能有所不同，因此无法明确界定什么算作“慢”。因此，你应该结合其他规则的持续时间并考虑 Jira 实例的具体配置来进行分析。

总结

在本章中，我们学习了如何在自动化规则出现问题或开始表现不佳时进行故障排除。

我们学习了审计日志的工作原理，以及它提供的大量信息，这些信息帮助我们了解规则执行时发生了什么。此外，我们还学会了如何利用审计日志输出消息，这将帮助你调试规则。

我们还了解了各种服务限制以及如何使用自动化规则监控这些限制，这使我们能够在规则超出处理限制之前收到预警。

最后，我们查看了项目和全局管理员可用的性能洞察，并了解了它是如何概述系统中规则的性能，以及我们如何利用这些信息，及时处理可能的性能问题。

通过了解如何使用审计日志进行调试，你将能够编写更健壮的规则，并且能够迅速确定智能值或函数导致规则失败的原因，并识别问题所在。

了解服务限制的工作原理以及如何通过自动化规则和检查性能洞察来监控它们，将使你能够保持 Jira 实例的良好性能。

在下一章，我们将讨论 Atlassian 生态系统中另一个著名的自动化应用，它允许我们使用 Groovy 脚本执行更高级的自动化操作。

第十一章：第十一章：超越自动化；脚本编写简介

本书重点介绍了使用无代码的方法在 Jira 中自动化日常任务。这种自动化功能原生支持 Jira Cloud，并且在 Jira Server 和 Jira Data Center 中可以通过添加 Automation for Jira 应用程序来使用。

这种方法使得 Jira 管理员能够非常轻松地快速启动自动化，因为它不需要任何专业的编程知识。此外，创建自动化的能力可以委派给项目管理员，从而使 Jira 管理员可以专注于其他任务。

然而，任何关于 Jira 自动化的书籍，如果没有提到脚本编写，尤其是 ScriptRunner for Jira，就无法算作完整，因为它无疑是最知名的自动化应用程序。

在这一章中，我们将简要介绍 ScriptRunner for Jira 及其背后使用的 Groovy 脚本语言。此外，我们还将探讨 Jira Cloud 与 Jira Server 在脚本编写上的差异。

本章将涵盖以下主题：

• 使用 ScriptRunner 引入高级自动化

• 探索 Jira Cloud 中的脚本编写

• 探索 Jira Server 中的脚本编写

技术要求

本章的要求如下：

• Jira 云环境：如果你还没有 Jira 访问权限，你可以在www.atlassian.com/software/jira/free创建一个免费的 Jira Cloud 账户，并确保选择了 Jira Software 和 Jira Service Management。你还需要从 Atlassian Marketplace 安装 ScriptRunner for Jira。

• Jira Server 环境：如果你使用的是 Jira Server（可从www.atlassian.com/software/jira/download下载），请确保你拥有 Jira Software 和 Jira Service Desk 的许可证。此外，你还需要确保安装了从 Atlassian Marketplace 获取的 ScriptRunner for Jira 应用程序。

你需要成为全球 Jira 管理员才能跟随本章节中的示例进行操作。此外，我们使用了 IT 服务管理项目模板 来创建本示例中使用的服务台项目。

你可以从本书的官方 GitHub 仓库下载本章的最新代码示例：github.com/PacktPublishing/Automate-Everyday-Tasks-in-Jira。请访问以下链接查看 CiA 视频：bit.ly/39L6BIB

使用 ScriptRunner 引入高级自动化

ScriptRunner for Jira 允许你通过编写 Groovy 脚本来扩展 Jira Cloud、Jira Server 或 Jira Data Center 的功能。

在自动化中使用 Groovy 语言的能力使您可以访问底层 Java 平台和 Jira API，同时还可以发挥脚本语言本身的全部功能。

如我们所见，在 Jira Cloud 中，访问 Jira API 仅限于与 Jira 提供的 REST API 进行交互。而在 Jira Server 中，您的脚本可以访问 Jira 向开发者开放的整个 API。

本节将首先简要介绍支撑 ScriptRunner 的 Groovy 语言，然后概述 ScriptRunner for Jira 应用程序。

介绍 Groovy

Groovy，或者称为 Apache Groovy，是一种建立在 Java 平台上的编程语言。它既是静态语言，因为它可以编译成字节码，又是动态语言，因为它可以在运行时解释执行。

Groovy 语法与 Java 兼容。这意味着它与 Java 和更重要的第三方库能够无缝集成和运行。这也意味着您可以在 Groovy 脚本中编写 Java 代码，并且代码会被正确解释和执行。

此外，Groovy 支持函数式编程和可选类型，这意味着它可以在运行时推断对象类型。它还具有比 Java 更简洁和表达力更强的语法，并且能够高效地处理 XML 和 JSON。

让我们看一个示例，突出显示 Java 和 Groovy 之间的差异和相似性。

在这个示例中，我们将创建一个包含名字的列表，然后遍历该列表，将每个名字打印到控制台，前面加上 "Hello" 这个词，代码如下：

List<String> nameList = new ArrayList<>();
nameList.add("Andrew");
nameList.add("Evelyn");
nameList.add("Tony");
for (String name : nameList) {
    System.out.println("Hello " + name);
}

尽管这段代码是用 Java 编写的，但它可以在 Groovy 中完全不做修改地运行。在编写脚本时，应用程序通常提供一个执行上下文。这个执行上下文本质上是一个类中的空方法，我们的脚本就是方法体，因此不需要声明周围的类或方法。

现在，让我们看一下上面代码的 Groovy 版本：

def nameList = ["Andrew", "Evelyn", "Tony"]
nameList.each { name ->
    println "Hello ${name}"
}

这个 Groovy 脚本与我们之前看到的 Java 代码等效。让我们逐行快速查看这个示例中发生了什么：

• def nameList = ["Andrew", "Evelyn", "Tony"]：我们通过使用 def 关键字声明 nameList 变量来使用可选类型。此外，我们使用方括号初始化该变量，并赋值为一个字符串列表。

• nameList.each { name ->：在这里，我们对列表调用 each 闭包，并将闭包参数命名为 name。

  闭包通过使用大括号标识，而箭头（->）将闭包参数与代码分开。

  当使用仅包含一个参数的闭包，并且您不需要在内部闭包中引用该参数时，可以省略该参数和分隔箭头。

  在这种情况下，参数名默认为 it，如下所示：

  nameList.each { println "Hello ${it}" }

• println "Hello ${name}"：这一行使用字符串插值打印出 "Hello" 字符串，后跟当前正在迭代的名字。

此外，你会注意到，在 Java 中用于终止语句的分号，在 Groovy 中并不需要。

提示

你可以在官方的 Apache Groovy 网站 groovy-lang.org/learn.html 上了解更多关于 Groovy 的信息，那里有许多书籍、演示文稿和课程，帮助你学习并最大限度地利用 Groovy 语言。

正如我们所学到的，Groovy 使你能够编写简洁、易读的代码，并且支持你在 Java 中编写脚本。接下来，让我们看看 ScriptRunner for Jira 如何利用这一点，帮助我们在 Jira 中创建自动化脚本。

了解 ScriptRunner

Adaptavist 的 ScriptRunner 是 Atlassian 生态系统中的一款应用，已有十多年历史。它结合了 Groovy 脚本引擎，并以一种便于通过可用 API 对 Jira 进行脚本访问的方式配置它。

它已经成为许多 Jira 管理员的首选应用，帮助他们自动化并扩展 Jira 的基本功能，实际上，它也适用于其他 Atlassian 工具，包括 Confluence、Bitbucket 和 Bamboo。

简而言之，ScriptRunner 通过提供一个现成的框架，其中所有底层基础设施已经就绪，从而让你能够专注于自动化的业务逻辑，进而让你能够访问 Jira 应用程序。

重要提示

ScriptRunner 提供的功能远不止于创建脚本化自动化。它还提供了使用内置和自定义 Groovy 脚本创建工作流函数的能力。此外，它还提供了一些强大的额外 JQL 功能，便于更轻松地搜索 Jira。它还允许你使用脚本片段对用户界面进行自定义，具体的复杂度会根据你使用的是 Jira Cloud 还是 Jira Server 而有所不同。

Adaptavist 为 ScriptRunner 提供了全面的文档和教程，适用于 Jira Cloud 和 Jira Server。你可以在 scriptrunner-docs.connect.adaptavist.com/jiracloud/quickstart.html 上了解更多关于 ScriptRunner for Jira Cloud 的内容。要了解关于 ScriptRunner for Jira Server 的更多信息，你可以在 scriptrunner.adaptavist.com/latest/jira/quickstart.html 查阅文档。

提示

Adaptavist 提供了一个脚本库，你可以直接使用其中的脚本，或者将它们作为自己脚本的起点。你可以在 library.adaptavist.com 上找到这些脚本。

现在我们已经简要了解了 ScriptRunner 和 Groovy 脚本语言，接下来让我们看看如何在 Jira Cloud 中使用脚本创建自动化。

探索 Jira Cloud 中的脚本

ScriptRunner for Jira Cloud 使你能够根据 Jira 中发生的事件创建自动化任务，例如创建或更新问题等。它还具有升级服务，允许你对由 JQL 查询提供的问题列表执行预定的操作。

ScriptRunner 还提供了在预定时间间隔运行脚本的功能。这与升级服务不同，因为它不需要一个问题列表来执行操作，从而使你能够执行如定期创建问题等任务。

在本节中，我们将简要概述 Jira Cloud API 的工作原理，然后重建来自第二章的 事件优先级矩阵 示例，自动化 Jira 问题，以了解如何使用脚本编写自动化任务。

理解 Jira Cloud API

为了使应用能够与 Jira Cloud 集成，它需要使用 Atlassian Connect 框架 来构建。该框架允许应用扩展 Jira 用户界面，访问 Jira API，并响应来自 Jira Cloud 的事件。

使用 Connect 框架构建的应用程序是一个通过 HTTP 协议远程操作的 web 应用程序。这意味着，当你为 Jira 构建一个 Connect 应用时，它需要托管在一个可以通过 HTTP 从 Jira Cloud 接收请求的公开可访问的 web 服务器上，并且能够向 Jira Cloud 发送 REST API 请求。

使用 Connect 框架构建的应用与 Jira Cloud 之间的基本交互可以从以下图示中看到。这是关于使用 ScriptRunner 进行自动化的简化表示：

图 11.1 – 应用与 Atlassian Connect 框架的交互

当 Jira Cloud 中发生事件时，Webhook 会通过 HTTP 发送，通知 ScriptRunner 应用该事件已发生。这避免了应用程序需要定期轮询 Jira 以确定是否发生了更改。

作为响应，ScriptRunner 会启动执行配置为监听特定事件的任何脚本。反过来，这些脚本利用 Jira REST API 获取附加信息并更新 Jira 中的数据。

使用 ScriptRunner 的预定或升级服务的脚本只需要访问 Jira REST API 来与 Jira 中的数据进行交互。

提示

你可以在 developer.atlassian.com/cloud/jira/platform/webhooks/ 上了解有关 Jira Cloud 中 Webhook 的更多信息，而可以在 developer.atlassian.com/cloud/jira/platform/rest/v3/intro/ 上了解 Jira Cloud REST API 的相关信息。

现在我们已经了解了 Jira Cloud API 的基本工作原理，让我们来看看如何利用它在 Jira Cloud 中创建脚本自动化。

在 Jira Cloud 中创建脚本自动化

在这个示例中，我们将重新创建我们在第二章《自动化 Jira 问题》章节中首次介绍的事件优先级矩阵自动化。如果你已经有类似的 Jira 自动化规则，请在实施此规则前禁用该规则。

这个示例将展示如何利用 Groovy 脚本和 Jira Cloud API 在 Jira Cloud 中实现类似的自动化。

我们将使用的 Groovy 脚本在下面的截图中展示：

![图 11.2 – Jira Cloud 中的事件优先级矩阵脚本]

](https://github.com/OpenDocCN/freelearn-devops-pt7-zh/raw/master/docs/auto-evdy-task-jira/img/Figure_11.2_B16551.jpg)

图 11.2 – Jira Cloud 中的事件优先级矩阵脚本

让我们来看看这个脚本的执行过程：

1. 我们做的第一件事是使用 Jira 的 REST API 将所有自定义字段检索到一个存储在customFields变量中的列表中。

2. 使用自定义字段列表后，我们可以确定Impact和Urgency字段的 ID，并将其保存到相应的变量中。

3. 现在我们已经获得了Impact和Urgency字段的 ID，我们可以利用这些 ID 从问题中提取相应的值，这些值表示为Map对象。

4. 在这个代码块中，我们使用字段的值来根据优先级矩阵确定正确的优先级。

   我们使用 Groovy 的switch语句，使代码比使用 if/else 语句更具可读性。

5. 最后，我们使用 Jira 的 REST API 来更新问题，并使用第 4 步中计算出的新优先级。

现在我们已经创建了 Groovy 中的自动化脚本，我们需要在 ScriptRunner 中创建一个脚本监听器来实际启动自动化：

1. 作为 Jira 管理员，点击顶部菜单栏中的应用程序菜单，然后选择管理你的应用程序。

2. 从左侧菜单中，选择ScriptRunner部分下的脚本监听器标签，然后点击添加监听器按钮。

3. 完成脚本监听器字段如下：

   事件优先级矩阵

   问题已创建和问题已更新

   IT 服务台 (DESK)

   当前用户

4. 我们只希望在问题为事件时才调用该监听器，因此我们需要向监听器添加一个条件，只有在处理事件时它才会评估为true。

   在issue.issueType.name == 'Incident'

   这将确保该监听器仅在问题类型名称为Incident时继续执行。

5. 最后，将脚本输入到本章节 GitHub 仓库中的11.1 事件优先级矩阵 – Cloud.groovy文件中，然后将代码复制并粘贴到字段中。

   你的脚本监听器现在应该类似于以下截图：

![图 11.3 – 在 Jira Cloud 中创建脚本监听器]

](https://github.com/OpenDocCN/freelearn-devops-pt7-zh/raw/master/docs/auto-evdy-task-jira/img/Figure_11.3_B16551.jpg)

图 11.3 – 在 Jira Cloud 中创建脚本监听器

在本节中，我们学习了如何在 Jira Cloud 中使用 Groovy 脚本在脚本监听器中重新创建事例优先级矩阵。现在，您应该了解如何使用脚本编写自动化任务。

在接下来的部分中，我们将查看如何在 Jira Server 中创建脚本自动化，并重新使用事例优先级矩阵示例，以便您可以看到两个平台之间的区别。

探索 Jira Server 中的脚本编写

与 Jira Cloud 的 ScriptRunner 类似，ScriptRunner for Jira Server 允许您根据 Jira 中的事件创建自动化。

然而，与 Jira Cloud 不同的是，由于您可以访问完整的 Jira API，因此您能够在 Jira Server 中对更广泛的事件创建自动化。

在本节中，我们将查看 Jira Server 平台上脚本可用的 API。然后，我们将再次查看事例优先级矩阵示例，以便更容易理解两个平台之间脚本编写的区别。

理解 Jira Server API

与 Jira Cloud API 相反，使用 Jira Server API 编写的应用程序在与核心 Jira 应用程序相同的 Java 进程中运行，因此可以通过公共基于 Java 的 API 充分访问底层应用程序。

ScriptRunner for Jira Server 是使用 Jira Plugins2 (P2) 框架构建的应用程序。该框架允许应用程序注册为 Jira 中事件的监听器，并提供访问应用程序随附的底层 API 和公共第三方库的能力。

Jira API 非常庞大，要全面理解它的每个方面可能需要几本书。然而，出于我们的目的，我们将集中精力讨论 ComponentAccessor 类，其文档位于 docs.atlassian.com/software/jira/docs/api/latest/com/atlassian/jira/component/ComponentAccessor.html。

该类是在 ScriptRunner 中编写脚本时您将需要的大多数组件的入口点。它为您提供了诸如 IssueService 和 IssueManager 类的操作权限，这些类用于创建、更新和修改问题。您还将使用它获取 CustomFieldManager 类的访问权限，该类允许您操作 Jira 中定义的大多数自定义字段。

提示

您可以在官方的 执行问题操作 教程中了解如何使用 IssueService 和 IssueManager 与 Jira 中的问题进行交互，位于 developer.atlassian.com/server/jira/platform/performing-issue-operations/。

要访问 ComponentAccessor，您需要在脚本的开头显式导入该类，如下所示：

import com.atlassian.jira.component.ComponentAccessor

正如你将在下一部分的示例中看到的那样，ComponentAccessor是我们在 Jira Server 中查找和操作数据的核心工具。

现在我们简要介绍了 Jira Server API，接下来让我们看看如何使用 API 创建自动化脚本。

在 Jira Server 中创建脚本自动化

在这个例子中，我们将使用 Groovy 脚本重新创建事件优先级矩阵，这样我们可以了解在 Jira Server 和 Jira Cloud 中编写脚本的区别。

我们将要使用的脚本示例如下所示：

图 11.4 – Jira Server 中的事件优先级矩阵脚本

让我们来看看这个脚本在做什么：

1. 我们需要做的第一件事是导入 Jira API 类，这些类是我们脚本所需的。如果没有这些类，脚本将无法编译并无法访问 Jira API。

2. Jira Server 中的 ScriptRunner 脚本监听器会将事件对象传递给脚本。该事件对象在issue字段中包含底层问题。

   此外，我们还确保将issue变量强制转换为MutableIssue类型，这将允许我们对问题进行更改。

3. ScriptRunner 中的自定义脚本监听器没有条件字段，因此我们需要使用if语句确保只有在处理事故问题类型时才继续执行。

4. 这里我们通过使用ComponentAccessor中的CustomFieldManager组件来获取Impact和Urgency字段的自定义字段对象。在这个例子中，我通过名称而不是 ID 来获取字段，但你也可以使用任一方法。

5. 现在我们已经拥有了Impact和Urgency字段的自定义字段对象，可以使用这些对象从问题中检索它们各自的值。

   此外，我们还提取了这些值的字符串表示形式，以便在接下来的代码块中进行比较。

6. 在此代码块中，我们使用字段的值根据优先级矩阵来确定正确的优先级。

   我们利用 Groovy 的switch语句使代码比使用 if/else 块更加易读。

7. 在 Jira Server 中，优先级字段是优先级类型的对象，因此我们需要找到与我们在步骤 6中计算的字符串值相对应的Priority对象。

   我们通过使用ComponentAccessor提供的ConstantsManager类来检索系统中所有的优先级。

   然后，我们使用find闭包来搜索名称字段匹配我们计算出的优先级的优先级对象。

8. 一旦找到正确的优先级对象，我们就可以相应地更新问题。

9. 最后，我们需要将更改持久化到数据库中，我们通过调用从ComponentAccessor获取的IssueManager对象上的updateIssue方法来实现。

   我们不希望此特定更新导致更多的更新事件被触发，因此我们使用 EventDispatchOption.DO_NOT_DISPATCH 选项来表示这一点。

   我们还不希望在更新问题时发送任何电子邮件通知，因此我们将最后一个参数设置为 false。

正如我们在这个示例中所学到的，针对 Jira Server 编写的脚本可以利用完整的 Jira API，而不是针对 Jira Cloud 编写的脚本所能使用的简化版 REST API。

注意

拥有完整的 Jira API 访问权限既强大又危险。您在 Jira Server 中编写脚本时应谨慎操作，因为编写不当的脚本可能会导致严重的性能下降，甚至更糟的后果。

让我们通过将脚本附加到监听器上来完成此示例，这样它就会在每次创建或更新事件时执行：

1. 作为 Jira 管理员，点击设置菜单（齿轮）图标，然后选择 管理应用。

2. 在左侧菜单中，选择 ScriptRunner 部分下的 监听器 标签，点击 创建监听器 按钮，然后选择 自定义监听器。

3. 按照以下方式填写监听器字段：

   事件优先级矩阵

   IT 服务台

   问题创建 和 问题更新

4. 在本章的 GitHub 仓库中输入 11.2 事件优先级矩阵 - Server.groovy 中的 Groovy 脚本，然后将代码复制粘贴到字段中。

   新的脚本监听器现在应该类似于以下截图：

图 11.5 – 在 Jira Server 中创建脚本监听器

现在我们已经完成了本节内容，您已经学会了如何在 ScriptRunner for Jira Server 中使用 Groovy 脚本创建自动化。您现在应该也能理解 Jira Cloud 和 Jira Server 平台在脚本方面的一些核心差异。

总结

在本章中，我们介绍了 ScriptRunner for Jira，这是一款允许我们在 Jira 中使用脚本创建高级自动化的应用程序。

我们已经学习了 Groovy 语言，ScriptRunner 使用它在 Jira 中启用脚本化，并且我们了解到 Groovy 可以执行 Java 和 Groovy 语句，这使得即使不先学习 Groovy，也能更容易入门。

为了理解脚本如何与 Jira Cloud 进行交互，我们了解了 Atlassian Connect 框架，它用于为 Jira Cloud 构建应用程序，并且我们了解了它如何使 ScriptRunner 提供对 Jira 的脚本化访问。

接着，我们通过重新创建 第二章 中的事件优先级矩阵示例，学习了如何创建一个脚本自动化，并且通过解析脚本，我们了解了与 Jira Cloud 进行交互的方式。

接下来，我们向您介绍了 Jira Server 上的脚本，并通过简要了解 Jira Server API，学习了它与 Jira Cloud 的脚本有什么不同。

为了更容易理解不同平台之间的差异，我们重新使用了事件优先级矩阵示例脚本，并再次分析了该脚本，以了解如何与 Jira Server API 进行交互。

了解如何使用 Groovy 脚本创建高级自动化，将使你能够创建超越无代码方法的自动化，而这正是本书的重点，它将使你能够根据自己的需求定制 Jira 实例。

这也标志着本书的结束，我希望它不仅激励了你，还能给你一些关于如何将自动化提升到新水平的想法。

第十二章：你可能喜欢的其他书籍

如果你喜欢这本书，你可能对 Packt 的其他书籍感兴趣：

通过 Jira Align 扩展敏捷

Dean MacNell 和 Aslam Cader

ISBN: 978-1-80020-321-1

• 理解 Jira Align 成功的关键因素

• 了解如何通过 Jira Align 连接人员、工作、时间和成果

• 在 Jira Align 中导航并协作

• 将团队敏捷性扩展到投资组合和企业层级

• 深入规划和执行，包括路线图和可预测性指标

• 实施精益投资组合管理和 OKR

• 掌握双模和混合交付的处理方式

• 在 Jira Align 中启用高级数据安全和分析功能

Jira 8 Essentials - 第五版

Patrick Li

ISBN: 978-1-78980-281-8

• 理解 Jira 的数据层次结构，以及如何设计和处理 Jira 中的项目

• 使用 Jira 进行敏捷软件项目、业务流程管理、客户服务支持等

• 理解问题并与之合作

• 设计系统字段和自定义字段，在不同的上下文中表现不同

• 创建并设计你自己的屏幕，并将其应用于不同的项目和问题类型

• 了解工作流及其各个组成部分

• 设置进出邮件服务器以便处理电子邮件

留下评论 - 让其他读者了解你的想法

请通过在你购买书籍的网站上留下评论与他人分享你对这本书的看法。如果你是从亚马逊购买的这本书，请在亚马逊页面上留下诚实的评论。这对其他潜在读者非常重要，因为他们可以通过你的无偏见意见做出购买决策，我们可以了解客户对我们产品的反馈，而我们的作者也能看到你对他们与 Packt 合作创作的作品的反馈。只需要几分钟时间，但对其他潜在客户、我们的作者以及 Packt 来说都非常有价值。谢谢！