文章
Qiao Peng · 一月 14, 2021
本文以及后面两篇该系列文章，是为需要在其基于 InterSystems 产品的应用程序中使用 OAuth 2.0 框架（下文简称为 OAUTH）的开发人员或系统管理员提供的指南。
作者：InterSystems 高级销售工程师 Daniel Kutac
# 发布后校正和更改历史记录
* 2016 年 8 月 3 日 - 修正了 Google 客户端配置屏幕截图，更新了 Google API 屏幕截图以反映新版本的页面
* 2016 年 8 月 28 日 - 更改了 JSON 相关代码，反映了对 Cache 2016.2 JSON 支持的更改
* 2017 年 5 月 3 日 - 更新了文本和屏幕，以反映 Cache 2017.1 的新 UI 和功能
* 2018 年 2 月 19 日 - 将 Caché 更改为 InterSystems IRIS 以反映最新的发展。 但是请记住，尽管产品名称发生更改，但**文章涵盖所有的 InterSystems 产品**——InterSystems IRIS 数据平台、Ensemble 和 Caché。
* 2020 年 8 月 17 日 - 大面积更改，软件方面更改更大。 要获取 Google 的更新版 Oauth2 的网址，请咨询 Micholai Mitchko。
_第 1 部分 客户端_
# **简介**
有关开放式授权框架 InterSystems 实现的相关内容，我们分 3 部分讲述，这是第 1 部分。
在第 1 部分中，我们对该主题进行了简短介绍，并提供了一个 InterSystems IRIS 应用程序担当授权服务器客户端并请求一些受保护资源的简单方案。
第 2 部分将讲述一个复杂一些的方案，在该方案中 InterSystems IRIS 本身通过 OpenID Connect 担当授权服务器和身份验证服务器。
本系列的最后一部分将描述 OAUTH 框架类的各个部分，它们由 InterSystems IRIS 实现。
## **什么是开放授权框架 [1] **
许多人已经听说过有关开放授权框架及其用途的信息。 因此这里只做简单介绍，以备未听说过的人参考。
开放授权框架 (OAUTH) 当前为 2.0 版，其是一种协议，允许基于 Web 的主应用程序通过在客户端（应用程序请求数据）和资源所有者（应用程序保存请求的数据）之间建立间接信任来以安全的方式交换信息。 信任本身由客户端和资源服务器都认可并信任的主体提供。 该主体称为授权服务器。
简单举例如下：
假设 Jenny（使用 OAUTH 术语，就是资源所有者）在开展 JennyCorp 公司的一个工作项目。 她为一个潜在的大型业务创建了项目计划，并邀请 JohnInc 公司的业务伙伴 John（客户端用户）审阅此文档。 不过，她并不愿意让 John 访问自己公司的 VPN，因此她将文档放在 Google 云端硬盘（资源服务器）或其他类似的云存储中。 她这样做，已经在她和 Google（授权服务器）之间建立了信任。 她标记了要与 John 共享的文档（John 已经使用 Google 云端硬盘服务，Jenny 知道他的电子邮件）。
当 John 想要阅读该文档时，他进行了 Google 帐户身份验证，然后通过移动设备（平板电脑、笔记本电脑等）启动文档编辑器（客户端服务器）并加载 Jenny 的项目文件。
这听起来很简单，但是两个人与 Google 之间有很多通信。 所有交流均遵循 OAuth 2.0 规范，因此 John 的客户端（阅读器应用程序）必须首先向 Google 进行身份验证（OAUTH 不涵盖此步骤），然后 John 申请获取 Google 对提供表格的同意，经过授权后，Google 就会发出一个访问令牌，授权阅读器应用程序访问文档。 阅读器应用程序使用该访问令牌向 Google 云端硬盘服务发出请求，以检索 Jenny 的文件。
下图说明了各方之间的通信
请注意：虽然所有的 OAUTH 2.0 通信都使用 HTTP 请求，但服务器不必非得是 Web 应用程序。
让我们通过 InterSystems IRIS 来说明这一简单方案。
# **简单 Google 云端硬盘演示**
在本演示中，我们将创建一个基于 CSP 的小型应用程序，该应用程序将使用我们自己的帐户（以及作为奖励的日历列表）来请求存储在 Google 云端硬盘服务中的资源（文件列表）。
## **基本要求**
开始应用程序编码之前，我们需要准备环境。 这包括启用 SSL 的 Web 服务器和 Google 配置文件。
### **Web 服务器配置**
如上所述，我们需要使用 SSL 与授权服务器进行通信，因为默认情况下 OAuth 2.0 要求如此。 我们需要确保数据安全，对吧？
解释如何配置 Web 服务器来支持 SSL 的内容超出了本文讨论的范围，因此，请以您喜欢的方式参阅相应 Web 服务器的用户手册。 为了您的好奇心（我们稍后可能会显示一些屏幕截图），在此特定示例中，我们将使用 Microsoft IIS 服务器。
### **Google 配置**
为了向 Google 注册，我们需要使用 Google API Manager-[ https://console.developers.google.com/apis/library?project=globalsummit2016demo ](https://console.developers.google.com/apis/library?project=globalsummit2016demo)
为了进行演示，我们创建了一个帐户 GlobalSummit2016Demo。 确保我们已启用 Drive API
现在，该定义凭据了
请注意以下事项：
_Authorized JavaScript – _我们仅允许本地生成的脚本（相对于调用页面）
_Authorized redirect URIs – 从理论上讲，我们可以将客户端应用程序重定向到任何站点，但是当使用 InterSystems IRIS OAUTH 实现时，我们必须重定向到** https://localhost/csp/sys/oauth2/OAuth2.Response.cls**。您可以定义多个授权的重定向 URI，如屏幕截图所示，但是对于本演示，我们只需要两者中的第二个条目。
最后，我们需要将 InterSystems IRIS 配置为 Google 授权服务器的客户端
### **Caché /IRIS配置**
InterSystems IRIS OAUTH2 客户端配置需要两步。 首先，我们需要创建服务器配置。
在 SMP 中，导航至**系统管理 > 安全性 > OAuth 2.0 > 客户端配置**。
点击**创建服务器配置**按钮，填写表格并保存。
输入到表格的所有信息可以在 Google 开发者控制台网站上找到。 请注意，InterSystems IRIS 支持自动 Open ID 发现。 但是，由于我们没有使用它，因此我们手动输入所有信息
现在，点击新创建的 Issuer Endpoint
旁边的“客户端配置”链接。并点击**创建客户端配置**按钮。
将“客户端信息”和“JWT 设置”选项卡保留为空（默认值），并填写客户端凭据。
请注意：我们正在创建机密客户端（这比公共客户端更安全，这意味着客户端秘密永远不会离开客户端服务器应用程序（永远不会传输到浏览器）
此外，请确保选中**“使用 SSL/TLS**”，并提供主机名（本地主机，因为我们将本地重定向到客户端应用程序），最后提供端口和前缀（当同一台机器上有多个 InterSystems IRIS 实例时，这非常有用）。 根据输入的信息，会计算客户端重定向 URL 并显示在上一行中。
在上面的屏幕截图中，我们提供了一个名为 GOOGLE 的 SSL 配置。 该名称本身实际上仅用于帮助您确定此特定通信通道使用的可能是众多 SSL 配置中的哪个。 Caché 使用 SSL/TLS 配置存储所有必要的信息，以建立与服务器（在本例中，为 Google OAuth 2.0 URI）的安全流量。
有关详细信息，请参阅[文档](http://docs.intersystems.com/latest/csp/docbook/DocBook.UI.Page.cls?KEY=GCAS_ssltls#GCAS_ssltls_aboutconfigs) 。
Supply Client ID 和 Client Secret 值从 Google 凭据定义表中获得（使用手动配置时）。
现在，我们完成了所有的配置步骤，可以开始编写 CSP 应用程序代码。
## **客户端应用程序**
客户端应用程序是基于 Web 的简单 CSP 应用程序。 因此，它包含由 Web 服务器定义和执行的服务器端源代码，以及由 Web 浏览器向用户公开的用户界面。 下文提供的示例代码期望客户端应用程序在 GOOGLE 名称空间中运行。 请将路径 /csp/google/ 修改为您的命名空间。
## **客户端服务器**
客户端服务器是一个简单的两页应用程序。 在该应用程序内，我们将：
· 将 URL 重定向到 Google 授权服务器
· 执行向 Google Drive API 和 Google Calendar API 的请求并显示结果
### **第 1 页**
这是应用程序的一页，我们决定在此处调用 Google 的资源。
以下是此页面上简单但功能齐全的代码。
Class Web.OAUTH2.Google1N Extends %CSP.Page
{
Parameter OAUTH2CLIENTREDIRECTURI = "https://localhost/csp/google/Web.OAUTH2.Google2N.cls";
Parameter OAUTH2APPNAME = "Google";
ClassMethod OnPage() As %Status
{
&html
// we need to supply openid scope to authenticate to Google
set scope="openid https://www.googleapis.com/auth/userinfo.email "_
"https://www.googleapis.com/auth/userinfo.profile "_
"https://www.googleapis.com/auth/drive.metadata.readonly "_
"https://www.googleapis.com/auth/calendar.readonly"
set properties("approval_prompt")="force"
set properties("include_granted_scopes")="true"
set url=##class(%SYS.OAuth2.Authorization).GetAuthorizationCodeEndpoint(..#OAUTH2APPNAME,scope,
..#OAUTH2CLIENTREDIRECTURI,.properties,.isAuthorized,.sc)
w !,""
&html
Quit $$$OK
}
ClassMethod OnPreHTTP() As %Boolean [ ServerOnly = 1 ]
{
#dim %response as %CSP.Response
set scope="openid https://www.googleapis.com/auth/userinfo.email "_
"https://www.googleapis.com/auth/userinfo.profile "_
"https://www.googleapis.com/auth/drive.metadata.readonly "_
"https://www.googleapis.com/auth/calendar.readonly"
if ##class(%SYS.OAuth2.AccessToken).IsAuthorized(..#OAUTH2APPNAME,,scope,.accessToken,.idtoken,.responseProperties,.error) {
set %response.ServerSideRedirect="Web.OAUTH2.Google2N.cls"
}
quit 1
}
}
代码的简要说明如下：
1. OnPreHTTP 方法 - 首先，我们有机会时检查一下，我们是否由于 Google 授权而获得了有效的访问令牌——这种情况可能会发生，例如当我们只是刷新页面时。 如果没有，我们需要授权。 如果我们有令牌，我们只需将页面重定向到显示结果的页面
2. OnPage 方法 - 只有在我们没有可用的有效访问令牌时，我们才到这里，因此我们需要开始通信——向 Google 进行身份验证和授权，以便它向我们授予访问令牌。
3. 我们定义了作用域字符串和属性数组，用于修改 Google 身份验证对话框的行为（我们需要先向 Google 进行身份验证，然后它才能根据我们的身份对我们进行授权）。
4. 最后，我们收到 Google 登录页面的 URL，然后将其提供给用户，接着提供同意页面。
还有一点注意事项：
我们在 OAUTH2CLIENTREDIRECTURI 参数的 中指定真正的重定向页面。 但是，我们在 Google 凭据定义中使用了 InterSystems IRIS OAUTH 框架的系统页面！ 重定向由我们的 OAUTH 处理程序类在内部处理。
### **第 2 页**
此页面显示 Google 授权的结果，如果成功，我们将调用 Google API 调用以检索数据。 同样，此代码简单，但功能齐全。 相比读者的想象，我们以更结构化的方式来显示输入数据。
Include %occInclude
Class Web.OAUTH2.Google2N Extends %CSP.Page
{
Parameter OAUTH2APPNAME = "Google";
Parameter OAUTH2ROOT = "https://www.googleapis.com";
ClassMethod OnPage() As %Status
{
&html
// Check if we have an access token
set scope="openid https://www.googleapis.com/auth/userinfo.email "_
"https://www.googleapis.com/auth/userinfo.profile "_
"https://www.googleapis.com/auth/drive.metadata.readonly "_
"https://www.googleapis.com/auth/calendar.readonly"
set isAuthorized=##class(%SYS.OAuth2.AccessToken).IsAuthorized(..#OAUTH2APPNAME,,scope,.accessToken,.idtoken,.responseProperties,.error)
if isAuthorized {
// Google has no introspection endpoint - nothing to call - the introspection endpoint and display result -- see RFC 7662.
w "Data from GetUserInfo API"
// userinfo has special API, but could be also retrieved by just calling Get() method with appropriate url
try {
set tHttpRequest=##class(%Net.HttpRequest).%New()
$$$THROWONERROR(sc,##class(%SYS.OAuth2.AccessToken).AddAccessToken(tHttpRequest,"query","GOOGLE",..#OAUTH2APPNAME))
$$$THROWONERROR(sc,##class(%SYS.OAuth2.AccessToken).GetUserinfo(..#OAUTH2APPNAME,accessToken,,.jsonObject))
w jsonObject.%ToJSON()
} catch (e) {
w "ERROR: ",$zcvt(e.DisplayString(),"O","HTML")_""
}
/******************************************
* *
* Retrieve info from other APIs *
* *
******************************************/
w ""
do ..RetrieveAPIInfo("/drive/v3/files")
do ..RetrieveAPIInfo("/calendar/v3/users/me/calendarList")
} else {
w "Not authorized!"
}
&html
Quit $$$OK
}
ClassMethod RetrieveAPIInfo(api As %String)
{
w "Data from "_api_""
try {
set tHttpRequest=##class(%Net.HttpRequest).%New()
$$$THROWONERROR(sc,##class(%SYS.OAuth2.AccessToken).AddAccessToken(tHttpRequest,"query","GOOGLE",..#OAUTH2APPNAME))
$$$THROWONERROR(sc,tHttpRequest.Get(..#OAUTH2ROOT_api))
set tHttpResponse=tHttpRequest.HttpResponse
s tJSONString=tHttpResponse.Data.Read()
if $e(tJSONString)'="{" {
// not a JSON
d tHttpResponse.OutputToDevice()
} else {
w tJSONString
w ""
/*
// new JSON API
&html
s tJSONObject={}.%FromJSON(tJSONString)
set iterator=tJSONObject.%GetIterator()
while iterator.%GetNext(.key,.value) {
if $isobject(value) {
set iterator1=value.%GetIterator()
w "",key,""
while iterator1.%GetNext(.key1,.value1) {
if $isobject(value1) {
set iterator2=value1.%GetIterator()
w "",key1,""
while iterator2.%GetNext(.key2,.value2) {
write !, "",key2, "",value2,""
}
// this way we can go on and on into the embedded objects/arrays
w ""
} else {
write !, "",key1, "",value1,""
}
}
w ""
} else {
write !, "",key, "",value,""
}
}
&html
*/
}
} catch (e) {
w "ERROR: ",$zcvt(e.DisplayString(),"O","HTML")_""
}
}
}
让我们快速看一下代码：
1. 首先，我们需要检查一下我们是否具有有效的访问令牌（即我们是否被授权）
2. 如果是，我们可以向 Google 提供且由已发布访问令牌覆盖的 API 发出请求
3. 为此，我们使用标准的 ％Net.HttpRequest 类，但根据 API 规范，我们将访问令牌添加到 GET 或 POST 方法中
4. 如您所见，为了方便您，OAUTH 框架已实现 GetUserInfo（）方法，但是您可以使用 Google API 规范直接检索用户信息，就像我们在 RetrieveAPIInfo（）助手方法中所做的一样。
5. 由于在 OAUTH 世界中以 JSON 格式交换数据司空见惯，因此我们只读取传入的数据，然后简单地将其转储到浏览器。 应用程序开发人员可以解析和格式化接收到的数据，以便用户可以看明白。 但这超出了本演示的范围。 （尽管一些代码有注释，显示了如何完成解析。）
下图是一个输出屏幕截图，显示了原始 JSON 数据。
继续阅读[第 2 部分](https://community.intersystems.com/post/cach%C3%A9-open-authorization-framework-oauth-20-implementation-part-2)，该部分讲述 InterSystems IRIS 担当授权服务器和 OpenID Connect 提供程序相关的内容。
[1] https://tools.ietf.org/html/rfc6749, https://tools.ietf.org/html/rfc6750
文章
Nicky Zhu · 十一月 2, 2021
目录
技术概要：InterSystems 云管理器（Cloud Manager） 1
ICM 能为您做什么？ 1
ICM 是如何工作的？ 1
试一试！使用 ICM 在云中部署 InterSystems IRIS 2
安装 Docker 3
下载 ICM 映像 3
启动 ICM 3
获取云供应商帐户和证书 3
生成安全密钥 4
自定义示例配置文件 4
配置基础设施 9
部署 InterSystems IRIS 10
尝试 ICM 管理命令 11
取消配置基础设施 12
ICM 能做的远不止这些! 13
了解有关 ICM 的更多信息 13
插图目录
图 1: ICM 让一切变得简单 2
图 2: 云供应商的 ICM 默认文件示例 8
图 3: 交互式 ICM 命令 11
技术概要：InterSystems 云管理器（Cloud Manager）
本文向您介绍了 InterSystems 云管理器（InterSystems Cloud Manager，ICM），这是基于 InterSystems IRIS®数据平台的应用程序的端到端云配置和部署解决方案。
作为本指南的一部分，您将使用 ICM 在公共云中配置基础设施，并在该基础设施上部署 InterSystems IRIS。
要浏览所有的技术概要（First Looks），包括那些可以在免费的云实例或 web 实例上执行的技术概要（First Looks），请参见 InterSystems First Looks（《InterSystems 技术概要》）。
ICM 能为您做什么？
欢迎来到云时代（Cloud Age）! 您是否对它的机会虎视眈眈，但又对它的挑战保持警惕？具体来说，
您是否渴望利用云，但又犹豫是否要投入资源进行复杂的迁移？
您是否已经在云中，但还在努力寻找一种方法，以便在各种软件环境中管理部署和版本化您的应用程序？
您是否希望将持续集成和交付引入您的软件工厂，并将 DevOps 方法引入您的部署过程？也就是说，您想把自己从传统实践、库依赖、系统漂移、手动升级和其他开销的限制和风险中解放出来吗？
ICM 可以提供帮助！ ICM 为您提供了一种简单、直观的方法来配置云基础设施并在其上部署服务，帮助您现在就进入云，而无需进行重大开发或重组。基础设施即代码 (infrastructure as code，IaC) 和容器化部署的优势使得在 Google、Amazon 和 Azure 等公共云平台或私有 VMware vSphere 云上部署基于 InterSystems IRIS 的应用程序变得容易。定义您想要的内容，发布一些命令，剩下的工作由 ICM 来完成。
即使您已经在使用云基础设施、容器，或者同时使用两者，ICM 也可以通过自动化大量手动步骤，极大地减少配置和部署应用程序所需的时间和精力。
ICM 是如何工作的？
在您输入的纯文本配置文件的指导下，ICM 使用 Hashicorp 流行的 Terraform IaC 工具配置您的基础设施，并根据需要配置的主机节点。在下一阶段，ICM 将 InterSystems IRIS 和您的应用程序部署在 Docker 容器中，如果需要，还可以部署其他服务。您想要的部署所需的所有 InterSystems IRIS 配置都是自动执行的。ICM 还可以在现有的虚拟和物理集群上部署容器化服务。
ICM 本身带有一个容器映像，其中包含您所需要的一切。从 InterSystems 的 ICM 映像下载并运行容器，打开命令行，您就可以开始了。ICM 通过组合这些元素，使一切变得简单：
可以用作模板以快速定义所需部署的示例配置文件。
可以向其中添加应用程序的 InterSystems IRIS 映像。
试一试! 使用 ICM 在云中部署 InterSystems IRIS
每个任务的用户友好命令。
管理已配置节点和部署在其上的服务并与之交互的多种方法。
图 1: ICM 让一切变得简单
试一试！使用 ICM 在云中部署 InterSystems IRIS
ICM 为您执行许多任务，并为您提供许多选项，以帮助您准确地部署您所需要的内容，所以在生产中使用它需要一定的计划和准备（尽管比手动方法要少得多！）。但配置和部署过程很简单，ICM 可以为您做出许多决定。这一探索旨在让您亲眼看到 ICM 是如何工作的，以及使用 ICM 在亚马逊网络服务（Amazon Web Services，AWS）上部署 InterSystems IRIS 配置是多么容易。虽然这不是一时的工作，但这种探索不应该占用您太多的时间，您可以在机会出现时分阶段进行。
为了让您体验 ICM 而又不至于在细节上陷入困境，我们保持了简单的探索；例如，我们让您尽可能多地使用默认设置。但是，当您把 ICM 引入您的生产系统时，您需要做很多不同的事情，特别是（但不限于）安全方面。所以请确保不要把这种对 ICM 的探索与真实的情况相混淆! 本文档末尾提供的参考资料将使您对在生产中使用 ICM 的情况有一个很好的了解。ICM Guide（《ICM 指南》）提供了使用 ICM 的完整信息和程序，并在适当的地方提供了链接。
这些说明假定您具备以下条件：
特定于容器的 InterSystems IRIS 分片（sharding）许可证并可以访问 InterSystems 软件下载。
亚马逊网络服务（Amazon Web Services，AWS）、谷歌云平台（Google Cloud Platform，GCP）、微软云（Azure）或腾讯云（Tencent）上的帐户。
在配置文件中指定的许多属性在这些云平台上是通用的，但其他属性是特定于平台的。有关这些差异的详细信息可在 ICM Guide（《ICM 指南》）的"ICM Reference（《ICM 参考资料》）"一章中的"Provider-Specific Parameters（特定于供应商的参数）"部分找到。
试一试! 使用 ICM 在云中部署 InterSystems IRIS
安装 Docker
ICM 是作为容器映像提供的，它包含您需要的所有内容。因此，对启动 ICM 的 Linux、macOS 或 Microsoft Windows 系统的唯一要求是安装 Docker，并运行 Docker 守护进程，以及系统连接到 Internet。有关在您的平台上安装 Docker 的信息，请参见 Docker 文档中的 Install Docker（《安装 Docker》）。
重要提示： Docker 企业版（Enterprise Edition）和社区版（Community Edition）18.09 及更高版本支持 ICM；企业版（Enterprise Edition）仅支持生产环境。
下载 ICM 映像（Image）
要使用 ICM，您需要将 ICM 映像下载到您正在工作的系统中；这要求您识别将从其中下载它的注册表和访问所需的凭证。同样，对于 ICM 部署 InterSystems IRIS 和其他 InterSystems 组件，它需要相关映像的此信息。ICM 下载映像的注册表必须能被您使用的云供应商访问（也就是说，不能在防火墙后面），而且为了安全起见，必须要求 ICM 使用您提供给它的凭证进行身份验证。有关识别所涉及的注册表和下载 ICM 映像的详细信息，请参见 InterSystems Cloud Manager Guide（《InterSystems 云管理器指南》）中的 Downloading the ICM Image（下载 ICM 映像）。
注意： 启动 ICM 的映像的主要版本和部署的 InterSystems 映像必须匹配。例如，您不能使用 2019.3 版本的 ICM 部署 2019.4 版本的 InterSystems IRIS。
有关在容器中使用 InterSystems IRIS 的简要介绍，包括实际操作经验， 请参见 First Look: InterSystems Products in Containers（《技术概要：容器中的 InterSystems 产品》）；有关使用 ICM 以外的方法在容器中部署 InterSystems IRIS 和基于 InterSystems IRIS 的应用程序的详细信息，请参见 Running InterSystems IRIS in Containers（《在容器中运行 InterSystems IRIS》）。
启动 ICM
要在命令行上启动 ICM，使用下面的 docker run 命令，从注册表中拉出（下载）ICM 映像，从中创建一个容器，并启动该容器，例如：
docker run --name icm -it --cap-add SYS_TIME containers.intersystems.com/intersystems/icm:2021.1.0.205.0
ICM 容器中的 /Samples 目录，每个供应商都有一个（/AWS，/GCP，等等），旨在使您能够轻松地使用开箱即用的 ICM 进行配置和部署；您可以使用这些目录之一中的示例配置文件 ，也可以从该目录进行配置和部署。然而，由于这些目录在 ICM 容器内，当容器被删除时，其中的数据就会丢失，包括您的配置文件和 ICM 创建并用于管理配置的基础设施的状态目录。在生产中，最好的做法是在启动 ICM 时通过挂载外部卷使用容器外的位置来存储这些数据（请参见 Docker 文档中的 Manage data in Docker（在 Docker 中管理数据））。
获取云供应商帐户和证书
ICM 可以在四个公共云平台上进行配置和部署：亚马逊网络服务（Amazon Web Services，AWS）、谷歌云平台（Google Cloud Platform，GCP）、微软云（Azure）和腾讯云（Tencent）。
登录您的 AWS、GCP、Azure 或 Tencent 帐户。如果您和您的雇主都还没有帐户，您可以进入AWS、GCP、Azure或Tencent 门户页面，快速创建一个免费帐户。
有关获取 ICM 需要向每个云供应商进行身份验证的帐户凭证的信息，请参见 ICM Guide（《ICM 指南》）的 "ICM Reference（《ICM 参考资料》） "一章中的 Security- Related Parameters（安全相关的参数）。
试一试! 使用 ICM 在云中部署 InterSystems IRIS
生成安全密钥
ICM 与配置基础设施的云供应商、配置的节点上的 Docker 以及容器部署后的若干 InterSystems IRIS 服务进行安全的通信。您已经下载或识别了您的云证书；您还需要其他文件来启用安全的 SSH 和 TLS 通信。
您可以使用 ICM 提供的两个脚本来创建您需要的文件，keygenSSH.sh 脚本创建所需的 SSH 文件并将它们放在 ICM 容器的 /Samples/ssh 目录中。keygenTLS.sh 脚本创建所需的 TLS 文件，并将它们放在 /Samples/tls 中。
要在 ICM 命令行上运行这些脚本，请输入以下内容：
# keygenSSH.sh
Generating keys for SSH authentication.
...
# keygenTLS.sh
Generating keys for TLS authentication.
...
有关这些脚本生成的文件的更多信息，请参见 ICM Guide（《ICM指南》）中的 Obtain Security-Related Files（获取安全相关的文件）、ICM Security（ICM 安全）和 Security-Related Parameters（安全相关的参数）。
重要提示： 这些生成的密钥是为了方便您在本文体验和其他测试中使用；在生产中，您应该根据您公司的安全策略来生成或获取所需的密钥。这些脚本生成的密钥以及您的云供应商凭证必须完全安全，因为它们提供了对使用它们的任何 ICM 部署的完全访问权限。
自定义示例配置文件
要定义您希望 ICM 部署的配置，您在两个 JSON 格式的配置文件中包含所需的设置：默认文件和定义文件。前者（defaults.json）包含应用于整个部署的设置 --- 例如，您对云供应商的选择 ------而后者（definitions.json）定义了您想要的节点类型以及每种节点的数量，从而决定了您是部署一个分片集群、一个独立的 IRIS 实例，还是其他配置。
ICM 容器中的 /Samples 目录为所有四个云供应商提供示例配置文件。例如，AWS 的示例配置文件位于 /Samples/AWS 目录中。要自定义这些文件，请选择您要使用的供应商，然后按照下面的表格描述，为该供应商修改示例默认值和定义文件。要做到这一点，您可以使用 vi 等编辑器直接在容器内编辑它们，或者在本地命令行上使用 docker cp 命令将它们从容器复制到本地文件系统，然后在您编辑它们后再次返回，例如：
docker cp icm:/Samples/AWS/defaults.json . docker cp icm:/Samples/AWS/definitions.json .
...
docker cp defaults.json icm:/Samples/AWS docker cp definitions.json icm:/Samples/AWS
重要提示： 字段名和值都是区分大小写的；例如，要选择 AWS 作为云供应商，您必须在默认文件中包含 "Provider"："AWS" ，而不是 "provider"： "AWS"、"Provider"： "aws"等等。
自定义 defaults.json
下表详细说明了 /Samples 文件中提供的默认文件所需的最小自定义，以及对可选更改的建议。这里没有涉及到的任何设置都可以在示例文件中保持原样。
试一试! 使用 ICM 在云中部署 InterSystems IRIS
每个设置都连接到 ICM Guide（《ICM 指南》）的 "ICM Reference（《ICM 参考资料》）"一章中的 ICM Configuration Parameters（ICM 配置参数）部分中的相关表格，在那里您可以找到更详细的说明；在那里，搜索您想要的参数。最右边的列显示了在示例默认文件中出现的每个参数或参数集。
要查看所有供应商通用的所有设置，请参见该部分的 General Parameters（常规参数） ；要查看特定于特定供应商的所有设置，请参见 Provider-Specific Parameters（特定于供应商的参数）。
下图显示了 AWS、GCP、Azure 和 Tencent 的示例 defaults.json 文件的内容：
设置
说明
示例 defaults.json 文件中的条目
Provider
识别云基础设施供应商；保留示例 defaults.json 中的值。
“Provider”:[”AWS”|"GCP"|"Azure"|"Tencent"],
Label
配置节点的命名方案中的字段， Label-Role-Tag-NNNN (请参见下面的 Role)；更新以识别部署的所有者和目的， 例如，使用您的公司名称和“TEST”来创建节点名称，如 Acme-DATA-TEST-0001。
"Label": "Sample",
Tag
(请参见上面的 Label )
"Tag": "TEST",
DataVolumeSize
为每个节点配置的持久化数据卷的大小，这可以在 definitions.json 文件中的各个节点定义中被覆盖；接受示例 defaults.json 中的值，除非您在 Tencent 上配置，在这种情况下，将其改为 60。
"DataVolumeSize": "10",
SSHUser
在配置节点上具有 sudo 访问权限的非根帐户，用于 ICM 访问； 您可以保留示例 defaults.json 中的默认值， 但如果您在 AWS 或 Tencent 上更改了机器映像(如下)，则可能需要更新此条目。
"SSHUser": "ubuntu",(AWS & Tencent) "SSHUser": "sample",(GCP & Azure)
SSHPublicKey
SSH 公钥的位置。如果您使用了 Generate Security Keys（生成安全密钥）中讨论的密钥生成脚本， 则密钥位于示例文件指定的目录中，因此无需更改；如果您提供了自己的密钥, 请使用 docker cp 将它们从本地文件系统复制到这些位置。
"SSHPublicKey": "/Samples/ssh/insecure-ssh2.pub",
SSHPrivateKey
SSH 私钥的位置；请参见上面的 SSHPublicKey。
"SSHPrivateKey": "/Samples/ssh/insecure",
TLSKeyDir
TILS 文件的位置；请参见上面的 SSHPublicKey 。
"TLSKeyDir": "/Samples/tls/",
设置
说明
示例 defaults.json 文件中的条目
DockerVersion
要安装在已配置节点上的 Docker 版本；保持默认值。
"DockerVersion": "5:19.03.8~3-0~ubuntu-bionic",
DockerImage
要部署在已配置节点上的映像；更新以反映您在 Identify Docker Repository and Credentials（识别 Docker 存储库和凭证）中识别的存储库和映像信息。
"DockerImage": "containers.intersystems.con/intersystems/iris:2021.1.0.205.0",
DockerUser- name Docker- Password
如果在私有存储库中，则下载 DockerImage 指定的映像所需的凭证；请更新以反映您在 Identify Docker Repository and Credentials（识别 Docker 存储库和凭证）中识别的存储库信息和凭证。
"DockerUsername": "xxxxxxxxxxxx", "DockerPassword": "xxxxxxxxxxxx",
LicenseDir
InterSystems IRIS 许可证的暂存目录；将您的特定于容器的 InterSystems IRIS 分片（sharding）许可证放在这个目录中。
“LicenseDir”: “/Samples/Licenses”,
Region, Location (Azure)
供应商用于配置基础设施的计算资源的地理区域；接受示例 defaults.json 中的默认值，或者从供应商那里选择 region 和 zone 的另一个组合（如下）。
"Region": "us-west-1",(AWS) "Region": "us-east1",(GCP) "Location": "Central US",(Azure) "Region": "na-siliconvalley", (Tencent)
Zone
所选区域内的可用区（如上）；接受示例 defaults.json 中的默认值，或者从供应商那里选择 region 和 zone 的另一个组合。
"Zone": "us-west-1c",(AWS) "Zone": "us-east1-b",(GCP) "Zone": "1",(Azure) "Zone": "na-siliconvalley-1", (Tencent)
Machine image (特定于供应商)
配置节点的平台和 OS 模板；接受示例 defaults.json 中的默认值，或者从供应商那里选择 machine image 和 instance type 的不同组合（如下）。
"AMI": "ami-c509eda6",(AWS) "Image": "ubuntu-os-cloud/ubuntu-1804-bionic-v20180617", (GCP) "PublisherName": "Canonical",(Azure) "Offer": "UbuntuServer",(Azure) "Sku": "18.04-LTS",(Azure) "Version": "18.04.201804262",(Azure) "ImageID": "img-pi0ii46r",(Tencent)
设置
说明
示例 defaults.json 文件中的条目
Instance type (特定于供应商)
配置节点的计算资源模板；接受示例 defaults.json 中的值，或者从供应商那里选择 machine image 和 instance type 的不同组合（如上）。
"InstanceType": "m4.large",(AWS) "MachineType": "n1-standard-1",(GCP) "Size": "Standard_DS2_v2",(Azure) "InstanceType": "S2.MEDIUM4",(Tencent)
Credentials and account settings (特定于供应商)
ICM 向供应商进行身份验证所需的文件或 ID，因供应商而异；更新以指定您的帐户所需的文件位置或 ID（有关说明，请点击供应商链接）。
“Credentials”:”/Samples/AWS/credentials”, (AWS) "Credentials": "/Samples/GCP/sample.credentials",(GCP) "Project": "dp-icmdevelopment",(GCP) "SubscriptionId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",(Azure) "ClientId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",(Azure) "ClientSecret": "xxxxxxxxxxxx/xxxxxxxxxxxxxxx/xxxxxxxxxxxxxx=", (Azure) "TenantId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",(Azure) "SecretID": "xxxxxxxxxxxx",(Tencent) "SecretKey": "xxxxxxxxxxxx",(Tencent)
ISCPassword
已部署的 InterSystems IRIS 映像中预定义帐户的密码；要在部署阶段以交互方式提供带有屏蔽输入的密码（为安全起见建议这样做），请删除此字段，否则更改为您的首选密码。
"ISCPassword": "",
Mirror
确定部署在 DATA、DM 和 DS 节点上的 InterSystems IRIS 实例是否被配置为镜像；保留默认值。
“Mirror”: “false”
设置
说明
示例 defaults.json 文件中的条目
UserCPF
指定用于覆盖已部署实例的初始 CPF 设置的配置合并文件。（如果您不熟悉配置合并功能或 CPF，请删除此条目；有关配置合并的信息，请参见 ICM Guide（《ICM**指南》）的 "ICM Reference（《ICM 参考资料》）"一章中的 Deploying with Customized InterSystems IRIS Configurations（使用自定义的 InterSystems IRIS 配置进行部署）。）
"UserCPF": "/Samples/cpf/iris.cpf"
下图显示了 AWS、GCP、Azure 和 Tencent 的示例 defaults.json 文件的内容：
图 2: 云供应商的 ICM 默认文件示例
自定义 definitions.json
在 /Samples 目录中的示例 definitions.json 文件（对所有供应商来说都是一样的），定义了一个有两个数据节点和两个计算节点的分片集群，如下所示：
试一试! 使用 ICM 在云中部署 InterSystems IRIS
[
{
"Role": "DATA",
"Count": "2",
"LicenseKey": "ubuntu-sharding-iris.key"
},
{
"Role": "COMPUTE",
"Count": "2",
"StartCount": "3",
"LicenseKey": "ubuntu-sharding-iris.key"
}
]
Role 字段标识正在配置的节点类型，在这种情况下是 DATA 和 COMPUTE。Count 字段表示要配置多少个该类型的节点；对于 COMPUTE 节点，StartCount 从 0003 开始编号。LicenseKey 字段表示 InterSystems IRIS 许可证文件的名称，该文件位于默认文件中由 LicenseDir 字段指定的目录中。
在这个练习中，删除 COMPUTE 定义，只保留 DATA 定义，如下所示：
[
{
"Role": "DATA",
"Count": "2",
"LicenseKey": "ubuntu-sharding-iris.key"
}
]
部署分片集群时，所有节点必须有分片（sharding）许可证。使用 docker cp 将分片（sharding）许可证复制到 LicenseDir 指定的容器内的位置，如 /Samples/Licenses，并更新 DATA 节点定义中的 LicenseKey 设置，以指定要使用的许可证密钥。
这些是配置基本分片集群所需的唯一 definitions.json 更改。要配置一个独立的 InterSystems IRIS 实例，请使用此定义：
[
{
"Role": "DM",
"Count": "1",
"LicenseKey": "standard-iris.key""
},
]
配置基础设施
默认情况下，ICM 从当前目录中的配置文件中获取输入，因此您需要做的就是将配置基础设施更改为您选择的供应商的 /Samples 目录，例如 /Samples/AWS，并发出这个命令：
icm provision
icm provision 命令在您选择的平台上分配和配置主机节点。在配置操作期间，ICM 在状态子目录中创建或更新状态和日志文件，完成后创建 instances.json 文件，作为后续部署和管理命令的输入。
因为 ICM 同时运行多个任务，所以这些步骤（Terraform 计划和应用、复制文件、挂载卷等等）可能不会以相同的顺序在节点上启动和完成。完成后，ICM 提供了一个已经配置好的主机节点的摘要，并输出一个命令行，可以在以后用来删除基础设施，如下所示：
Machine IP Address DNS Name Region Zone
Acme-DATA-TEST-0001 00.53.183.209 ec2-00-53-183-209.us-west-1.compute.amazonaws.com us-west-1 c Acme-DATA-TEST-0002 00.53.183.185 ec2-00-53-183-185.us-west-1.compute.amazonaws.com us-west-1 c To destroy: icm unprovision [-cleanUp] [-force]
试一试! 使用 ICM 在云中部署 InterSystems IRIS
重要提示： 复制输出中提供的 icm unprovision 命令行，并保存此信息，这样您就可以在取消配置时轻松地复制它。这个输出也出现在 icm.log 文件中。
管理和取消配置您的基础设施所需的文件和目录都在 ICM 容器中，因此当您删除它时就会丢失。因此，在完成基础设施并成功地取消配置之前，您不能删除 ICM 容器。(在生产中，最好的做法是在启动 ICM 时通过挂载外部卷使用容器外的位置来存储这些数据（请参见 Docker 文档中的 Manage data in Docker（在 Docker 中管理数据））。
在配置和部署阶段发生的错误的详细信息写入状态目录子目录中的 terraform.err 文件；当发生错误时，ICM 会将您指向适当的文件，该文件可以帮助您识别问题的原因。
如果 icm provision 由于超时和供应商方面的内部错误，或者配置文件中的错误而没有成功完成，您可以根据需要再次发出该命令，直到 ICM 为所有指定的节点完成所有需要的任务而没有错误。更多信息，请参见 ICM Guide（《ICM 指南》）的 "Using ICM（《使用 ICM》） "一章中的 "Reprovisioning the Infrastructure（重新配置基础设施）"。
有关 icm provision 的更多信息，请参见 ICM Guide（《ICM 指南》）中的 The icm provision Command （icm 配置命令）。
部署 InterSystems IRIS
除了在提供的主机节点上下载映像（Image）并将它们作为容器运行外，ICM 还执行特定于 InterSystems IRIS 的配置和其他任务。要在您已配置的节点上部署 InterSystems IRIS，请留在 /Samples 目录，您在其中自定义了配置文件并配置了基础设施，然后发出以下命令：
icm run
默认情况下，icm run 下载并运行配置文件中 DockerImage 字段指定的映像，在这种情况下，是来自 InterSystems 存储库的 InterSystems IRIS 映像；每个容器都被命名为 iris。在实践中，在定义文件中的节点定义中使用不同的 DockerImage 字段（而不是对默认文件中的所有节点使用一次，如此处），可以让您在不同的节点类型上运行不同的映像，除此之外，您还可以使用某些选项多次执行 icm run 命令，以便在每个配置的节点上或只在指定节点上部署具有唯一名称的多个容器。
InterSystems IRIS 在每个节点上启动后，ICM 会执行实例所需的任何配置 --- 例如，重置密码、配置分片（sharding）等。因为 ICM 同时运行多个任务，因此部署过程中的步骤可能不会以相同的顺序在节点上启动和完成。
完成后，ICM 输出一个链接到相应的 InterSystems IRIS 实例的管理门户（Management Portal）：
$ icm run -definitions definitions_cluster.json
Executing command 'docker login' on ACME-DATA-TEST-0001...
...output in /Samples/AWS/state/ACME-DATA-TEST/ACME-DATA-TEST-0001/docker.out
...
Pulling image intersystems/iris:2021.1.0.205.0 on ACME-DATA-TEST-0001...
...pulled ACME-DATA-TEST-0001 image intersystems/iris:2021.1.0.205.0
...
Creating container iris on ACME-DATA-TEST-0002...
...
Management Portal available at:
http://ec2-00-53-183-209.us-west-1.compute.amazonaws.com:52773/csp/sys/UtilHome.csp
在这种情况下，所提供的链接用于数据节点 1，或者用于独立的实例（如果这是您选择的配置）。在浏览器中打开链接，并使用管理门户（Management Portal）探索 InterSystems IRIS。
与 icm provision 一样，如果 icm run 由于超时和供应商方面的内部错误而没有成功完成，您可以再次发出命令；在大多数情况下，反复尝试，部署就会成功。但是，如果错误仍然存在，并且需要手动干预 --- 例如，如果它是由某个配置文件中的错误引起的 --- 在修复问题后，您可能需要删除受影响的一个或多个节点上的持久化 %SYS 数据，
试一试! 使用 ICM 在云中部署 InterSystems IRIS
在重新发布 icm run 命令之前，如 ICM Guide（《ICM 指南》）的 "Using ICM（《使用 ICM》）"一章中的 Redeploying Services（重新部署服务）所述。在出现错误的情况下，请参见 ICM 指向您访问的日志文件，以获得有助于您确定问题原因的信息。
有关 icm run 命令及其选项的更多信息，请参见 ICM Guide（《ICM 指南》）中的 The icm run Command（icm run 命令）。
尝试 ICM 管理命令
ICM 提供了一系列的命令用于
管理配置的基础设施。
管理部署的容器。
与运行在部署的容器中的服务交互，包括 InterSystems IRIS。
这些命令在 ICM Guide（《ICM 指南》）的 Infrastructure Management Commands（基础设施管理命令）、Container Management Commands（容器管理命令）和 Service Management Commands（服务管理命令）小节中有详细的讨论，并在 ICM Commands and Options（ICM 命令和选项）中全面列出。这里提供了一些示例，供您在部署时试用。特别要注意的是，有三个命令（icm ssh、icm exec 和 icm session）可以让您在多个层次上与您部署的节点交互 --- 与节点本身、与部署在它上面的容器以及与容器内运行的 InterSystems IRIS 实例，如下所示：
图 3: 交互式 ICM 命令
在您新部署的 InterSystems IRIS 配置上试试这些命令吧!
列出配置的主机节点：
试一试! 使用 ICM 在云中部署 InterSystems IRIS
icm inventory
在每个主机节点上运行 shell 命令：
icm ssh -command "df -k"
当一个命令在多个节点上执行时，输出被写入文件，并提供一个输出文件的列表。例如，在这种情况下，如果您部署了分片集群，三个节点各有一个输出文件。
在特定的主机节点上打开交互式 shell：
icm ssh -role DATA -interactive
要做到交互，命令必须使用 -interactive 选项并指定单个节点。例如，虽然 icm ssh 可以在多个节点上执行命令，如前面的示例所示，但它只能使用 -interactive 选项在一个节点上打开交互式 shell，如本例所示。代替 -role DM 选项将命令限制在该类型的节点上（在您的部署中只有一个节点），您也可以使用-machine 选项来指定一个特定节点的名称，例如：
icm ssh -machine Acme-DATA-TEST-0001 -interactive
显示部署的 InterSystems IRIS 容器的状态：
icm ps
当在节点上部署了多个容器时，这个命令会将它们全部列出。
将本地文件复制到 InterSystems IRIS 容器或其中一个容器：
icm cp -localPath /Samples/ssh/ssh_notes -remotePath /home/sshuser
icm cp -localPath /Samples/ssh/ssh_notes -remotePath /home/sshuser -role DM
在每个 InterSystems IRIS 容器中运行 shell 命令：
icm exec -command "ls /irissys/"
在特定的 InterSystems IRIS 容器中打开一个交互式 shell（或运行任何 shell 命令）：
icm exec -command "bash" -role DATA -interactive
为 InterSystems IRIS 实例打开一个终端（Terminal）窗口（对于单个实例，总是交互式的）：
icm session -machine Acme-DATA-TEST-0001
针对 InterSystems IRIS 的每个实例，或针对特定的实例，运行 SQL 命令：
icm sql -command "SELECT Name FROM Security.Users"
icm sql -command "SELECT Name FROM Security.Users" -machine Acme-DATA-TEST-0002
取消配置基础设施
因为 AWS 和其他公共云平台实例会不断产生费用，所以在完成这一体验后，立即取消配置基础设施是很重要的。
要做到这一点，把您从 icm provision 的输出中保存的 icm unprovision 命令复制到 ICM 命令行，例如：
$ icm unprovision -cleanUp
ICM 能做的远不止这些!
如果您没有从配置输出中保存命令，您可以在工作目录的 icm.log 文件中找到它（例如，/Samples/AWS/icm.log）。-cleanUp 选项在取消配置后会删除状态目录；如果没有这个选项，状态目录会被保留下来。
ICM 能做的远不止这些!
尽管您刚刚完成的 ICM 探索是刻意简化的，但它仍包含了现实世界的基础设施配置和服务部署。添加到您刚刚完成的只是在配置文件中扩展您的部署定义并利用大量命令行选项的问题。例如，您可以
通过定义 AM 节点和 DM 节点，部署应用服务器和数据服务器的分布式缓存集群，或通过仅定义 DM 节点部署独立的 InterSystems IRIS 实例。
部署镜像（mirror） DATA 节点或镜像 DM 节点，只需在默认文件中包含"Mirror"："True"，并在定义文件中定义偶数个 DATA 节点或两个 DM 节点和一个 AR（仲裁器）节点。
部署一个包含 COMPUTE 节点的分片集群，以分离查询和数据摄取工作量，同时保持并行处理和分布式缓存的优势，提高两者的性能。
在定义文件中添加 web 服务器（WS）和负载均衡器（LB 或自动）。
通过在定义文件中为不同的节点指定不同的 DockerImage 值，并多次执行 icm run 命令，在不同的节点上部署不同的服务。
通过多次执行 icm run ，同时在命令行中使用 -container 和 -image 选项指定不同的容器名称和映像（包括自定义和第三方映像），在一些或所有节点上部署多个服务。
通过使用第三方工具和内部脚本扩展 ICM 的功能，进一步提高自动化程度，减少工作量。
在已有的虚拟和物理集群上部署服务。
在不部署服务的情况下配置基础设施，只需使用 ICM provision 命令停止。
所有这些可能性以及更多的可能性都在 ICM Guide（《ICM 指南》）中有所涉及。
了解有关 ICM 的更多信息
要了解有关 ICM 和在容器中使用 InterSystems IRIS 的更多信息，请参见
InterSystems Cloud Manager Introduction（《InterSystems 云管理器简介》） (视频)
The Benefits of InterSystems Cloud Manager（《InterSystems 云管理器的优势》） (视频)
Experience InterSystems IRIS in the Cloud（在云中体验 InterSystems IRIS） (在线体验)
InterSystems Cloud Manager Guide（《InterSystems 云管理器指南》）
First Look:InterSystems Products in Containers（《技术概要：容器中的 InterSystems 产品》）
Running InterSystems Products in Containers（《在容器中运行 InterSystems 产品》）
文章
Nicky Zhu · 九月 9, 2021
本文档将您介绍
InterSystems IRIS®数据平台的分片（sharding）功能，以及它在分片集群中的使用，以水平扩展
InterSystems IRIS 的数据量。
作为本指南的一部分，您将使用 ICM 在公共云中提供的分片集群，并了解分片表（sharding a table）如何在集群中的分片之间分布其行。
分片（Sharding）如何帮助您？
您感受到大数据（Big Data）的热度了吗？
无论是否准备好了，我们都在管理比以往任何时候都多的数据，并被要求用这些数据做更多的事情——所需的响应时间也越来越短。无论您是照顾一千万名患者、每天处理数十亿的金融订单，追踪一个星系的恒星，还是监控一千个工厂的引擎，数据平台不仅要支持您目前的数据工作量，而且还必须在保持性能的同时进行扩展（Scale），以满足不断增长的需求，避免业务中断。每个特定业务的工作量对其运行的数据平台提出了不同的挑战 — 而随着工作量的增加，这些挑战将变得更加严峻。
InterSystems IRIS 包含一套全面的功能来扩展（Scale）您的应用程序，这些功能可以单独或组合应用，这取决于您的工作量的性质和它所面临的特定性能挑战。其中之一是分片（sharding），它在多个服务器上对数据及其相关缓存进行分区，为查询和数据摄取提供灵活、价优的性能扩展，同时通过高效的资源利用使基础设施价值最大化。
InterSystems IRIS 分片集群（sharded cluster） 可以为各种应用程序提供显著的性能优势，特别是对于那些工作量包括以下一项或多项的应用程序：
高容量或高速数据摄入，或组合。
相对较大的数据集，返回大量数据的查询，或两者兼有。
执行大量数据处理的复杂查询，例如扫描磁盘上的大量数据或涉及大量计算工作的查询。
这些因素各自都会影响分片（sharding）的潜在收益，但如果将它们结合起来，收益可能会得到增强。例如，所有这三个因素的组合——快速摄入的大量数据、大型数据集以及检索和处理大量数据的复杂查询——使得如今的许多分析工作量非常适合进行分片（sharding）。
请注意，这些特征都与数据有关；
InterSystems IRIS 分片（sharding）的主要功能是扩展数据量（sharded cluster）。但是，当涉及部分或所有这些数据相关因素的工作量也经历了来自大量用户的非常高的查询量时，分片集群也可以包括扩展用户量（scale for user volume）功能。分片（sharding）也可以与垂直扩展相结合。通过
InterSystems IRIS，您可以为工作量的性能挑战创建恰到好处的整体扩展解决方案。
分片（Sharding）是如何工作的？
分片架构的核心是跨多个系统对数据及其相关缓存进行分区。分片集群将大型数据库表水平（即按行）划分为多个
InterSystems IRIS 实例，称为数据节点（data node），同时允许应用程序通过这些实例中的任何一个访问这些表。每个数据节点在集群分片数据中的份额被称为分片（shard）。这种架构有三个优势：
并行处理（Parallel processing）
查询在数据节点上并行运行，合并查询结果，并作为完整的查询结果返回给应用程序，在许多情况下显著提高了执行速度。
分区缓存（Partitioned caching）
每个数据节点都有自己的专用缓存，而不是由单个实例的缓存为整个数据集服务，这大大降低了缓存溢出和强制降低性能的磁盘读取的风险。
并行加载（Parallel loading）
数据可以并行加载到数据节点上，从而减少摄取工作量和查询工作量之间的缓存和磁盘争夺，提高两者的性能。
一个被称为分片管理器（sharding manager）的联合软件组件会跟踪哪些数据位于哪些数据节点上，并相应地指导查询。非分片数据存储在配置的第一个数据节点上，称为数据节点 1 （它也存储代码和元数据）。从应用程序 SQL 的角度来看，分片表（sharded table）和非分片表（nonsharded table）之间的区别是完全透明的。
图 1: 一个基本的分片集群
试一试！部署和演示
InterSystems IRIS 分片集群
在这次探索中，您将
使用
InterSystems 云管理器（
InterSystems Cloud Manager，ICM）在公共云中部署基本的分片集群。
ICM 是一个自动化的命令行工具，可以轻松地在云中配置基础设施，并在提供的节点上部署
InterSystems IRIS 和其他服务。ICM 负责所有需要的
InterSystems IRIS 配置，所以如果您指定了一个分片集群，该集群在部署完成后就可以使用了。
使用不同的分片键（shard key）从相同的数据中创建三个分片表（sharded table），并观察数据节点上跨分片的行的不同分布。
分片键是用来确定分片表的哪些行存储在哪些分片上的一个或多个字段。默认情况下，RowID 被用作分片键，这种分布对于大多数分片表来说是最有效的方法，因为它提供了数据均匀分布的最佳保证，并允许最有效的并行数据加载。然而，在一种情况下，用户定义的键可能是有益的。当您对在字段或用于连接它们的字段上的查询中经常连接的两个大表进行分片时，要连接的行被存储在相同的分片上，并且连接可以在每个分片上本地执行，而不是跨分片执行（across the shard），从而提供显著的性能提升。这被称为 cosharded 连接（cosharded join）。
在所有三个分片表上运行相同的查询，以证明跨分片的行分布对查询是完全透明。
为了向您介绍分片（sharding），而又不至于让您在细节上陷入困境，我们保持了简单的探索。生产中的分片集群需要计划和许多决策，所以确保不要把对分片（sharding）的探索和真实情况相混淆！例如，在设计一个生产集群时，您将检查您的架构和表，以决定哪些表将被分片，然后根据分片数据的预期工作集和服务器上数据库缓存的可用内存量，决定部署多少个数据节点（通常为 4 到 16 个）。然而，在本次探索中，您将部署一个由两个数据节点组成的基本集群。本文档末尾列出的参考资料将使您对生产中使用分片（sharding ）的情况有一个很好的了解。Scalability Guide（《可扩展性指南》）中的 "Horizontally Scaling for Data Volume Sharding（《水平扩展数据卷分片[Sharding]》)"一章提供了有关分片（sharding）和分片集群的详细信息。
这些说明假定您有
InterSystems IRIS 分片（sharding）许可证并可以访问
InterSystems 软件下载。
使用 ICM 部署集群
您可以在 First Look：
InterSystems Cloud Manager（《技术概要：
InterSystems 云管理器》）中找到使用 ICM 在亚马逊网络服务（Amazon Web Services）公共云平台上部署分片集群的程序；特别是在 Try It!Deploy
InterSystems IRIS in the Cloud with ICM（试一试！使用 ICM 在云中部署
InterSystems IRIS）部分。您可以使用此处显示的整个程序。当您进入自定义定义.json（Customize definitions.json）时，验证每个 LicenseKey 字段的值是否是 defaults.json 文件中 LicenseDir 字段指定的暂存位置中的
InterSystems IRIS 分片（sharding）许可证的文件名。当您完成了部署阶段（部署
InterSystems IRIS[Deploy
InterSystems IRIS]）后，留在 ICM 容器中。
注意： 正如 Scalability Guide(《可扩展性指南》)中的 Deploying the Sharded Cluster(部署分片集群) 所描述的那样，您也可以在现有的物理、虚拟或云机器上安装
InterSystems IRIS 实例，并使用分片 API（Sharding API） 或管理门户（Management Portal）部署分片集群，或使用多种方法之一自动化部署分片集群。
使用不同的分片键以不同的方式分布行，然后查询分片表
为了了解分片集群如何根据您使用的分片键（shard key）在数据节点上的分片上对分片表（sharded table）进行分区，您将连接到集群并执行以下步骤：
创建并填充一个小型的非分片表。
使用三个不同的分片键，创建三个与非分片表具有相同字段的分片表 。
从非分片表中填充分片表。
从分片表中选择行，以查看在每种情况下，行在分片（数据节点）上的分布情况。
当一个表被分片时，RowID 值被从每个分片的不同范围分配，从相隔甚远的范围开始；相同范围的行在同一个分片上。当处理一个小表时，就像本例一样，分片的 RowID 很容易区分，清楚地告诉您哪些行在一个分片上，哪些在另一个分片上（尽管您无法分辨哪个分片是哪个）。在 RowID 上分片的表的行的分布方式与行中的数据没有关系，如果您清空并重新加载一个表，可能会有所不同。另一方面，用户定义的分片键，根据键中一个或多个字段的值来分配行，因此当您清空并重新加载表（假设值和分片数没有改变）时将是相同的。
查询所有三个表以获得其中一个字段的最大长度，来显示跨分片（across shards）的行的分布对查询是透明的。
对于这部分探索，请使用以下程序：
为任意一个数据节点实例打开终端（Terminal）窗口。
在 ICM 命令行上， 发出命令 icm session 命令，使用 -machine 选项指定一个数据节点的名称，使用 - namespace 选项指定集群命名空间 IRISCLUSTER (或者使用默认文件中的 Namespace 字段指定的命名空间，如果不同的话)。 如果您不确定节点的名称，可以使用 icm inventory 命令来显示节点名称：
$ icm inventory
Machine IP Address DNS Name Region Zone
Acme-DATA-TEST-0001 00.53.183.209 ec2-00-53-183-209.us-west-1.compute.amazonaws.com us-west-1 c
Acme-DATA-TEST-0002 00.53.183.185 ec2-00-53-183-185.us-west-1.compute.amazonaws.com us-west-1 c
选择一个节点（哪个节点并不重要）并发出命令：
icm session -machine Acme-DATA-TEST-0002 -namespace IRISCLUSTER
icm session 命令为指定节点上的
InterSystems IRIS 实例打开一个终端（Terminal）窗口。
如果您使用 %SYSTEM.Cluster.Sharding API 手动部署您的集群，使用
InterSystems IRIS Basics：Connecting an IDE（《技术概要：连接一个 IDE》）中的procedure described for your instance（为您的实例描述的程序），在任一实例上打开一个终端（Terminal）窗口，然后切换到 IRISCLUSTER 命名空间 (或者初始化集群时指定的命名空间，如果不同的话)。
Node: Acme-DATA-TEST-0002, Instance: IRIS USER>set $namespace="IRISCLUSTER" IRISCLUSTER>
打开终端（Terminal）SQL shell：IRISCLUSTER>do $SYSTEM.SQL.Shell() [SQL]IRISCLUSTER>>
使用以下 SQL 语句，创建并填充非分片表 test.nonsharded。
CREATE TABLE test.nonsharded (field1 CHAR(5), field2 CHAR(5)) INSERT INTO test.nonsharded (field1,field2) VALUES ('one','one') INSERT INTO test.nonsharded (field1,field2) VALUES ('one','two') INSERT INTO test.nonsharded (field1,field2) VALUES ('one','three') INSERT INTO test.nonsharded (field1,field2) VALUES ('two','one') INSERT INTO test.nonsharded (field1,field2) VALUES ('two','two') INSERT INTO test.nonsharded (field1,field2) VALUES ('two','three') INSERT INTO test.nonsharded (field1,field2) VALUES ('three','one') INSERT INTO test.nonsharded (field1,field2) VALUES ('three','two')
INSERT INTO test.nonsharded (field1,field2) VALUES ('three','three')
使用 SELECT 来查看表的内容：
SELECT * FROM test.nonsharded field1 field2
one one
one two
one three
two one
two two
two three
three one
three two
three three
使用 test.nonsharded 中的相同字段创建三个分片表，在第一个表中使用默认的分片键（RowID），在第二个表中使用 field1 字段，在第三个表中使用 field2 字段，并使用从 test.nonsharded 中选择的 INSERT INTO 语句填充每一个：
CREATE TABLE test.rowid (field1 CHAR(5), field2 CHAR(5), SHARD)
INSERT INTO test.rowid (field1,field2) SELECT field1,field2 FROM test.nonsharded
CREATE TABLE test.field1 (field1 CHAR(5), field2 CHAR(5), SHARD KEY (field1)) INSERT INTO test.field1 (field1,field2) SELECT field1,field2 FROM test.nonsharded
CREATE TABLE test.field2 (field1 CHAR(5), field2 CHAR(5), SHARD KEY (field2)) INSERT INTO test.field2 (field1,field2) SELECT field1,field2 FROM test.nonsharded
使用 SELECT *,%ID 来显示每个分片表的内容和它在分片上的 RowID。
SELECT *,%ID FROM test.rowid ORDER BY %ID
field1 field2 ID one one 1
one two 2
two one 3
two two 4
three three 5
one three 256000
two three 256001
three one 256002
three two 256003
这个分布并不反映 field1 或 field2 的值（具有各自全部三个值的行位于两个分片上）。如果您删除、重新创建并重新加载 test.rowid，分布可能会有所不同。
SELECT *,%ID FROM test.field1 ORDER BY %ID
field1 one one one
field2
one 1
two 2
three 3
ID
two
one 256000
two
two 256001
two
three 256002
three
one 256003
three
two 256004
three
three 256005
在 field1 字段上分片（sharding）会分布行，使那些具有相同 field1 值的行被放在同一个分片上。在这种情况下，值为 1 的行在一个分片上，值为 2 和 3 的行在另一个分片上，但是哪个数值最终在哪个分片上取决于有多少个分片和多少个数值。
SELECT *,%ID FROM test.field2 ORDER BY %ID
field1 field2 ID
one one 1
two one 2
three one 3
one two 256000
one three 256001
two two 256002
two three 256003
three two 256004
three three 256005
这里，分布是由 field2 字段的值决定的。
最后，作为分片如何将工作分配到数据节点的示例，对所有三个分片表使用以下 SELECT 语句：
SELECT MAX(LENGTH(field2)) FROM <table>
在每种情况下，结果都是 5，即最长值的长度是 3，因为跨分片的行分布对查询来说是完全透明的。 MAX(LENGTH(field2)) 表达式在每个分片上独立计算，分片管理器选择它们返回结果的 MAX()。例如，当查询在 test.field2 表上运行时，一个分片返回 3，因为它在 field2 字段中只有值 1 ，而另一个分片返回 5；然后分片管理器选择 5 作为两个结果中较大的那个。
如果您愿意，可以使用 EXPLAIN 来显示查询计划，明确指出如何将工作发送到分片上：
EXPLAIN SELECT MAX(LENGTH(field2)) FROM <table>
更多分片集群选项
分片集群的其他选项包括如下内容：
您可以随时添加数据节点，并跨扩展的数据节点集重新平衡现有的分片数据。重新平衡（Rebal ancing）不能与查询和更新同时进行，因此只有在分片集群离线并且没有其他分片操作的情况下才能进行。( Scalability Guide[《可扩展性指南》]中的 Add Nodes and Rebalance Data[添加节点和重新平衡数据] )
要为集群上的数据添加高可用性，您可以将数据节点部署为镜像故障转移对。( Scalability Guide[《可扩展性指南》]中的 Mirror for High Availability[高可用性镜像])。
对于需要极低查询延迟的高级用例（可能与不断涌入的数据相冲突），可以添加计算节点 ，为查询服务提供一个透明的缓存层。当集群包含计算节点时，只读的查询会自动在计算节点上并行执行，而不是在数据节点上执行；所有写入操作（插入、更新、删除和 DDL 操作）继续在数据节点上执行。这种分工将查询和数据摄取工作量分开，同时保持并行处理和分布式缓存的优势，提高两者的性能。(Scalability Guide[《可扩展性指南》]中的 Deploy Compute Nodes[部署计算节点])
了解有关分片（Sharding）的更多信息
要了解有关分片的更多信息，请参见
Data Platform Scalability Technology Overview（《数据平台可扩展性技术概要》） (视频)
Introduction to Sharding（《分片简介》） (在线课程)
Sharding Basics（《分片基础》） (在线课程)
Experience
InterSystems IRIS in the Cloud（在云中体验
InterSystems IRIS） (在线体验)
Scalability Guide（《可扩展性指南》）
First Look:
InterSystems Cloud Manager（《技术概要：
InterSystems 云管理器》）
文章
Jingwei Wang · 十月 28, 2021
html {overflow-x: initial !important;}:root { --bg-color: #ffffff; --text-color: #333333; --select-text-bg-color: #B5D6FC; --select-text-font-color: auto; --monospace: "Lucida Console",Consolas,"Courier",monospace; --title-bar-height: 20px; }
.mac-os-11 { --title-bar-height: 28px; }
html { font-size: 14px; background-color: var(--bg-color); color: var(--text-color); font-family: "Helvetica Neue", Helvetica, Arial, sans-serif; -webkit-font-smoothing: antialiased; }
body { margin: 0px; padding: 0px; height: auto; inset: 0px; font-size: 1rem; line-height: 1.42857143; overflow-x: hidden; background-image: inherit; background-size: inherit; background-attachment: inherit; background-origin: inherit; background-clip: inherit; background-color: inherit; tab-size: 4; background-position: inherit; background-repeat: inherit; }
iframe { margin: auto; }
a.url { word-break: break-all; }
a:active, a:hover { outline: 0px; }
.in-text-selection, ::selection { text-shadow: none; background: var(--select-text-bg-color); color: var(--select-text-font-color); }
#write { margin: 0px auto; height: auto; width: inherit; word-break: normal; word-wrap: break-word; position: relative; white-space: normal; overflow-x: visible; padding-top: 36px; }
#write.first-line-indent p { text-indent: 2em; }
#write.first-line-indent li p, #write.first-line-indent p * { text-indent: 0px; }
#write.first-line-indent li { margin-left: 2em; }
.for-image #write { padding-left: 8px; padding-right: 8px; }
body.typora-export { padding-left: 30px; padding-right: 30px; }
.typora-export .footnote-line, .typora-export li, .typora-export p { white-space: pre-wrap; }
.typora-export .task-list-item input { pointer-events: none; }
@media screen and (max-width: 500px) {
body.typora-export { padding-left: 0px; padding-right: 0px; }
#write { padding-left: 20px; padding-right: 20px; }
.CodeMirror-sizer { margin-left: 0px !important; }
.CodeMirror-gutters { display: none !important; }
}
#write li > figure:last-child { margin-bottom: 0.5rem; }
#write ol, #write ul { position: relative; }
img { max-width: 100%; vertical-align: middle; image-orientation: from-image; }
button, input, select, textarea { color: inherit; font-family: inherit; font-size: inherit; font-style: inherit; font-variant-caps: inherit; font-weight: inherit; font-stretch: inherit; line-height: inherit; }
input[type="checkbox"], input[type="radio"] { line-height: normal; padding: 0px; }
*, ::after, ::before { box-sizing: border-box; }
#write h1, #write h2, #write h3, #write h4, #write h5, #write h6, #write p, #write pre { width: inherit; }
#write h1, #write h2, #write h3, #write h4, #write h5, #write h6, #write p { position: relative; }
p { line-height: inherit; }
h1, h2, h3, h4, h5, h6 { break-after: avoid-page; break-inside: avoid; orphans: 4; }
p { orphans: 4; }
h1 { font-size: 2rem; }
h2 { font-size: 1.8rem; }
h3 { font-size: 1.6rem; }
h4 { font-size: 1.4rem; }
h5 { font-size: 1.2rem; }
h6 { font-size: 1rem; }
.md-math-block, .md-rawblock, h1, h2, h3, h4, h5, h6, p { margin-top: 1rem; margin-bottom: 1rem; }
.hidden { display: none; }
.md-blockmeta { color: rgb(204, 204, 204); font-weight: 700; font-style: italic; }
a { cursor: pointer; }
sup.md-footnote { padding: 2px 4px; background-color: rgba(238, 238, 238, 0.7); color: rgb(85, 85, 85); border-top-left-radius: 4px; border-top-right-radius: 4px; border-bottom-right-radius: 4px; border-bottom-left-radius: 4px; cursor: pointer; }
sup.md-footnote a, sup.md-footnote a:hover { color: inherit; text-transform: inherit; text-decoration: inherit; }
#write input[type="checkbox"] { cursor: pointer; width: inherit; height: inherit; }
figure { overflow-x: auto; margin: 1.2em 0px; max-width: calc(100% + 16px); padding: 0px; }
figure > table { margin: 0px; }
tr { break-inside: avoid; break-after: auto; }
thead { display: table-header-group; }
table { border-collapse: collapse; border-spacing: 0px; width: 100%; overflow: auto; break-inside: auto; text-align: left; }
table.md-table td { min-width: 32px; }
.CodeMirror-gutters { border-right-width: 0px; background-color: inherit; }
.CodeMirror-linenumber { }
.CodeMirror { text-align: left; }
.CodeMirror-placeholder { opacity: 0.3; }
.CodeMirror pre { padding: 0px 4px; }
.CodeMirror-lines { padding: 0px; }
div.hr:focus { cursor: none; }
#write pre { white-space: pre-wrap; }
#write.fences-no-line-wrapping pre { white-space: pre; }
#write pre.ty-contain-cm { white-space: normal; }
.CodeMirror-gutters { margin-right: 4px; }
.md-fences { font-size: 0.9rem; display: block; break-inside: avoid; text-align: left; overflow: visible; white-space: pre; background-image: inherit; background-size: inherit; background-attachment: inherit; background-origin: inherit; background-clip: inherit; background-color: inherit; position: relative !important; background-position: inherit; background-repeat: inherit; }
.md-fences-adv-panel { width: 100%; margin-top: 10px; text-align: center; padding-top: 0px; padding-bottom: 8px; overflow-x: auto; }
#write .md-fences.mock-cm { white-space: pre-wrap; }
.md-fences.md-fences-with-lineno { padding-left: 0px; }
#write.fences-no-line-wrapping .md-fences.mock-cm { white-space: pre; overflow-x: auto; }
.md-fences.mock-cm.md-fences-with-lineno { padding-left: 8px; }
.CodeMirror-line, twitterwidget { break-inside: avoid; }
.footnotes { opacity: 0.8; font-size: 0.9rem; margin-top: 1em; margin-bottom: 1em; }
.footnotes + .footnotes { margin-top: 0px; }
.md-reset { margin: 0px; padding: 0px; border: 0px; outline: 0px; vertical-align: top; text-decoration: none; text-shadow: none; float: none; position: static; width: auto; height: auto; white-space: nowrap; cursor: inherit; line-height: normal; font-weight: 400; text-align: left; box-sizing: content-box; direction: ltr; background-position: 0px 0px; }
li div { padding-top: 0px; }
blockquote { margin: 1rem 0px; }
li .mathjax-block, li p { margin: 0.5rem 0px; }
li blockquote { margin: 1rem 0px; }
li { margin: 0px; position: relative; }
blockquote > :last-child { margin-bottom: 0px; }
blockquote > :first-child, li > :first-child { margin-top: 0px; }
.footnotes-area { color: rgb(136, 136, 136); margin-top: 0.714rem; padding-bottom: 0.143rem; white-space: normal; }
#write .footnote-line { white-space: pre-wrap; }
@media print {
body, html { border: 1px solid transparent; height: 99%; break-after: avoid; break-before: avoid; font-variant-ligatures: no-common-ligatures; }
#write { margin-top: 0px; padding-top: 0px; border-color: transparent !important; }
.typora-export * { -webkit-print-color-adjust: exact; }
.typora-export #write { break-after: avoid; }
.typora-export #write::after { height: 0px; }
.is-mac table { break-inside: avoid; }
.typora-export-show-outline .typora-export-sidebar { display: none; }
}
.footnote-line { margin-top: 0.714em; font-size: 0.7em; }
a img, img a { cursor: pointer; }
pre.md-meta-block { font-size: 0.8rem; min-height: 0.8rem; white-space: pre-wrap; background-color: rgb(204, 204, 204); display: block; overflow-x: hidden; }
p > .md-image:only-child:not(.md-img-error) img, p > img:only-child { display: block; margin: auto; }
#write.first-line-indent p > .md-image:only-child:not(.md-img-error) img { left: -2em; position: relative; }
p > .md-image:only-child { display: inline-block; width: 100%; }
#write .MathJax_Display { margin: 0.8em 0px 0px; }
.md-math-block { width: 100%; }
.md-math-block:not(:empty)::after { display: none; }
.MathJax_ref { fill: currentcolor; }
[contenteditable="true"]:active, [contenteditable="true"]:focus, [contenteditable="false"]:active, [contenteditable="false"]:focus { outline: 0px; box-shadow: none; }
.md-task-list-item { position: relative; list-style-type: none; }
.task-list-item.md-task-list-item { padding-left: 0px; }
.md-task-list-item > input { position: absolute; top: 0px; left: 0px; margin-left: -1.2em; margin-top: calc(1em - 10px); border: none; }
.math { font-size: 1rem; }
.md-toc { min-height: 3.58rem; position: relative; font-size: 0.9rem; border-top-left-radius: 10px; border-top-right-radius: 10px; border-bottom-right-radius: 10px; border-bottom-left-radius: 10px; }
.md-toc-content { position: relative; margin-left: 0px; }
.md-toc-content::after, .md-toc::after { display: none; }
.md-toc-item { display: block; color: rgb(65, 131, 196); }
.md-toc-item a { text-decoration: none; }
.md-toc-inner:hover { text-decoration: underline; }
.md-toc-inner { display: inline-block; cursor: pointer; }
.md-toc-h1 .md-toc-inner { margin-left: 0px; font-weight: 700; }
.md-toc-h2 .md-toc-inner { margin-left: 2em; }
.md-toc-h3 .md-toc-inner { margin-left: 4em; }
.md-toc-h4 .md-toc-inner { margin-left: 6em; }
.md-toc-h5 .md-toc-inner { margin-left: 8em; }
.md-toc-h6 .md-toc-inner { margin-left: 10em; }
@media screen and (max-width: 48em) {
.md-toc-h3 .md-toc-inner { margin-left: 3.5em; }
.md-toc-h4 .md-toc-inner { margin-left: 5em; }
.md-toc-h5 .md-toc-inner { margin-left: 6.5em; }
.md-toc-h6 .md-toc-inner { margin-left: 8em; }
}
a.md-toc-inner { font-size: inherit; font-style: inherit; font-weight: inherit; line-height: inherit; }
.footnote-line a:not(.reversefootnote) { color: inherit; }
.md-attr { display: none; }
.md-fn-count::after { content: "."; }
code, pre, samp, tt { font-family: var(--monospace); }
kbd { margin: 0px 0.1em; padding: 0.1em 0.6em; font-size: 0.8em; color: rgb(36, 39, 41); background-color: rgb(255, 255, 255); border: 1px solid rgb(173, 179, 185); border-top-left-radius: 3px; border-top-right-radius: 3px; border-bottom-right-radius: 3px; border-bottom-left-radius: 3px; box-shadow: rgba(12, 13, 14, 0.2) 0px 1px 0px, rgb(255, 255, 255) 0px 0px 0px 2px inset; white-space: nowrap; vertical-align: middle; }
.md-comment { color: rgb(162, 127, 3); opacity: 0.8; font-family: var(--monospace); }
code { text-align: left; }
a.md-print-anchor { white-space: pre !important; border: none !important; display: inline-block !important; position: absolute !important; width: 1px !important; right: 0px !important; outline: 0px !important; text-shadow: initial !important; background-position: 0px 0px !important; }
.md-inline-math .MathJax_SVG .noError { display: none !important; }
.html-for-mac .inline-math-svg .MathJax_SVG { vertical-align: 0.2px; }
.md-fences-math .MathJax_SVG_Display, .md-math-block .MathJax_SVG_Display { text-align: center; margin: 0px; position: relative; text-indent: 0px; max-width: none; max-height: none; min-height: 0px; min-width: 100%; width: auto; overflow-y: visible; display: block !important; }
.MathJax_SVG_Display, .md-inline-math .MathJax_SVG_Display { width: auto; margin: inherit; display: inline-block !important; }
.MathJax_SVG .MJX-monospace { font-family: var(--monospace); }
.MathJax_SVG .MJX-sans-serif { font-family: sans-serif; }
.MathJax_SVG { display: inline; font-style: normal; font-weight: 400; line-height: normal; text-indent: 0px; text-align: left; text-transform: none; letter-spacing: normal; word-spacing: normal; word-wrap: normal; white-space: nowrap; float: none; direction: ltr; max-width: none; max-height: none; min-width: 0px; min-height: 0px; border: 0px; padding: 0px; margin: 0px; zoom: 90%; }
#math-inline-preview-content { zoom: 1.1; }
.MathJax_SVG * { transition: none; }
.MathJax_SVG_Display svg { vertical-align: middle !important; margin-bottom: 0px !important; margin-top: 0px !important; }
.os-windows.monocolor-emoji .md-emoji { font-family: "Segoe UI Symbol", sans-serif; }
.md-diagram-panel > svg { max-width: 100%; }
[lang="flow"] svg, [lang="mermaid"] svg { max-width: 100%; height: auto; }
[lang="mermaid"] .node text { font-size: 1rem; }
table tr th { border-bottom-width: 0px; }
video { max-width: 100%; display: block; margin: 0px auto; }
iframe { max-width: 100%; width: 100%; border: none; }
.highlight td, .highlight tr { border: 0px; }
mark { background-color: rgb(255, 255, 0); color: rgb(0, 0, 0); }
.md-html-inline .md-plain, .md-html-inline strong, mark .md-inline-math, mark strong { color: inherit; }
.md-expand mark .md-meta { opacity: 0.3 !important; }
mark .md-meta { color: rgb(0, 0, 0); }
@media print {
.typora-export h1, .typora-export h2, .typora-export h3, .typora-export h4, .typora-export h5, .typora-export h6 { break-inside: avoid; }
}
.md-diagram-panel .messageText { stroke: none !important; }
.md-diagram-panel .start-state { fill: var(--node-fill); }
.md-diagram-panel .edgeLabel rect { opacity: 1 !important; }
.md-require-zoom-fix foreignObject { font-size: var(--mermaid-font-zoom); }
.md-fences.md-fences-math { font-size: 1em; }
.md-fences-math .MathJax_SVG_Display { margin-top: 8px; cursor: default; }
.md-fences-advanced:not(.md-focus) { padding: 0px; white-space: nowrap; border: 0px; }
.md-fences-advanced:not(.md-focus) { background-image: inherit; background-size: inherit; background-attachment: inherit; background-origin: inherit; background-clip: inherit; background-color: inherit; background-position: inherit; background-repeat: inherit; }
.typora-export-show-outline .typora-export-content { max-width: 1440px; margin: auto; display: flex; flex-direction: row; }
.typora-export-sidebar { width: 300px; font-size: 0.8rem; margin-top: 80px; margin-right: 18px; }
.typora-export-show-outline #write { --webkit-flex: 2; flex: 2 1 0%; }
.typora-export-sidebar .outline-content { position: fixed; top: 0px; max-height: 100%; overflow: hidden auto; padding-bottom: 30px; padding-top: 60px; width: 300px; }
@media screen and (max-width: 1024px) {
.typora-export-sidebar, .typora-export-sidebar .outline-content { width: 240px; }
}
@media screen and (max-width: 800px) {
.typora-export-sidebar { display: none; }
}
.outline-content li, .outline-content ul { margin-left: 0px; margin-right: 0px; padding-left: 0px; padding-right: 0px; list-style: none; }
.outline-content ul { margin-top: 0px; margin-bottom: 0px; }
.outline-content strong { font-weight: 400; }
.outline-expander { width: 1rem; height: 1.428571429rem; position: relative; display: table-cell; vertical-align: middle; cursor: pointer; padding-left: 4px; }
.outline-expander::before { content: ''; position: relative; font-family: Ionicons; display: inline-block; font-size: 8px; vertical-align: middle; }
.outline-item { padding-top: 3px; padding-bottom: 3px; cursor: pointer; }
.outline-expander:hover::before { content: ''; }
.outline-h1 > .outline-item { padding-left: 0px; }
.outline-h2 > .outline-item { padding-left: 1em; }
.outline-h3 > .outline-item { padding-left: 2em; }
.outline-h4 > .outline-item { padding-left: 3em; }
.outline-h5 > .outline-item { padding-left: 4em; }
.outline-h6 > .outline-item { padding-left: 5em; }
.outline-label { cursor: pointer; display: table-cell; vertical-align: middle; text-decoration: none; color: inherit; }
.outline-label:hover { text-decoration: underline; }
.outline-item:hover { border-color: rgb(245, 245, 245); background-color: var(--item-hover-bg-color); }
.outline-item:hover { margin-left: -28px; margin-right: -28px; border-left-width: 28px; border-left-style: solid; border-left-color: transparent; border-right-width: 28px; border-right-style: solid; border-right-color: transparent; }
.outline-item-single .outline-expander::before, .outline-item-single .outline-expander:hover::before { display: none; }
.outline-item-open > .outline-item > .outline-expander::before { content: ''; }
.outline-children { display: none; }
.info-panel-tab-wrapper { display: none; }
.outline-item-open > .outline-children { display: block; }
.typora-export .outline-item { padding-top: 1px; padding-bottom: 1px; }
.typora-export .outline-item:hover { margin-right: -8px; border-right-width: 8px; border-right-style: solid; border-right-color: transparent; }
.typora-export .outline-expander::before { content: "+"; font-family: inherit; top: -1px; }
.typora-export .outline-expander:hover::before, .typora-export .outline-item-open > .outline-item > .outline-expander::before { content: '−'; }
.typora-export-collapse-outline .outline-children { display: none; }
.typora-export-collapse-outline .outline-item-open > .outline-children, .typora-export-no-collapse-outline .outline-children { display: block; }
.typora-export-no-collapse-outline .outline-expander::before { content: "" !important; }
.typora-export-show-outline .outline-item-active > .outline-item .outline-label { font-weight: 700; }
.CodeMirror { height: auto; }
.CodeMirror.cm-s-inner { background-image: inherit; background-size: inherit; background-attachment: inherit; background-origin: inherit; background-clip: inherit; background-color: inherit; background-position: inherit; background-repeat: inherit; }
.CodeMirror-scroll { overflow: auto hidden; z-index: 3; }
.CodeMirror-gutter-filler, .CodeMirror-scrollbar-filler { background-color: rgb(255, 255, 255); }
.CodeMirror-gutters { border-right-width: 1px; border-right-style: solid; border-right-color: rgb(221, 221, 221); background-image: inherit; background-size: inherit; background-attachment: inherit; background-origin: inherit; background-clip: inherit; background-color: inherit; white-space: nowrap; background-position: inherit; background-repeat: inherit; }
.CodeMirror-linenumber { padding: 0px 3px 0px 5px; text-align: right; color: rgb(153, 153, 153); }
.cm-s-inner .cm-keyword { color: rgb(119, 0, 136); }
.cm-s-inner .cm-atom, .cm-s-inner.cm-atom { color: rgb(34, 17, 153); }
.cm-s-inner .cm-number { color: rgb(17, 102, 68); }
.cm-s-inner .cm-def { color: rgb(0, 0, 255); }
.cm-s-inner .cm-variable { color: rgb(0, 0, 0); }
.cm-s-inner .cm-variable-2 { color: rgb(0, 85, 170); }
.cm-s-inner .cm-variable-3 { color: rgb(0, 136, 85); }
.cm-s-inner .cm-string { color: rgb(170, 17, 17); }
.cm-s-inner .cm-property { color: rgb(0, 0, 0); }
.cm-s-inner .cm-operator { color: rgb(152, 26, 26); }
.cm-s-inner .cm-comment, .cm-s-inner.cm-comment { color: rgb(170, 85, 0); }
.cm-s-inner .cm-string-2 { color: rgb(255, 85, 0); }
.cm-s-inner .cm-meta { color: rgb(85, 85, 85); }
.cm-s-inner .cm-qualifier { color: rgb(85, 85, 85); }
.cm-s-inner .cm-builtin { color: rgb(51, 0, 170); }
.cm-s-inner .cm-bracket { color: rgb(153, 153, 119); }
.cm-s-inner .cm-tag { color: rgb(17, 119, 0); }
.cm-s-inner .cm-attribute { color: rgb(0, 0, 204); }
.cm-s-inner .cm-header, .cm-s-inner.cm-header { color: rgb(0, 0, 255); }
.cm-s-inner .cm-quote, .cm-s-inner.cm-quote { color: rgb(0, 153, 0); }
.cm-s-inner .cm-hr, .cm-s-inner.cm-hr { color: rgb(153, 153, 153); }
.cm-s-inner .cm-link, .cm-s-inner.cm-link { color: rgb(0, 0, 204); }
.cm-negative { color: rgb(221, 68, 68); }
.cm-positive { color: rgb(34, 153, 34); }
.cm-header, .cm-strong { font-weight: 700; }
.cm-del { text-decoration: line-through; }
.cm-em { font-style: italic; }
.cm-link { text-decoration: underline; }
.cm-error { color: red; }
.cm-invalidchar { color: red; }
.cm-constant { color: rgb(38, 139, 210); }
.cm-defined { color: rgb(181, 137, 0); }
div.CodeMirror span.CodeMirror-matchingbracket { color: rgb(0, 255, 0); }
div.CodeMirror span.CodeMirror-nonmatchingbracket { color: rgb(255, 34, 34); }
.cm-s-inner .CodeMirror-activeline-background { background-image: inherit; background-size: inherit; background-attachment: inherit; background-origin: inherit; background-clip: inherit; background-color: inherit; background-position: inherit; background-repeat: inherit; }
.CodeMirror { position: relative; overflow: hidden; }
.CodeMirror-scroll { height: 100%; outline: 0px; position: relative; box-sizing: content-box; background-image: inherit; background-size: inherit; background-attachment: inherit; background-origin: inherit; background-clip: inherit; background-color: inherit; background-position: inherit; background-repeat: inherit; }
.CodeMirror-sizer { position: relative; }
.CodeMirror-gutter-filler, .CodeMirror-hscrollbar, .CodeMirror-scrollbar-filler, .CodeMirror-vscrollbar { position: absolute; z-index: 6; display: none; }
.CodeMirror-vscrollbar { right: 0px; top: 0px; overflow: hidden; }
.CodeMirror-hscrollbar { bottom: 0px; left: 0px; overflow: hidden; }
.CodeMirror-scrollbar-filler { right: 0px; bottom: 0px; }
.CodeMirror-gutter-filler { left: 0px; bottom: 0px; }
.CodeMirror-gutters { position: absolute; left: 0px; top: 0px; padding-bottom: 30px; z-index: 3; }
.CodeMirror-gutter { white-space: normal; height: 100%; box-sizing: content-box; padding-bottom: 30px; margin-bottom: -32px; display: inline-block; }
.CodeMirror-gutter-wrapper { position: absolute; z-index: 4; border: none !important; background-position: 0px 0px !important; }
.CodeMirror-gutter-background { position: absolute; top: 0px; bottom: 0px; z-index: 4; }
.CodeMirror-gutter-elt { position: absolute; cursor: default; z-index: 4; }
.CodeMirror-lines { cursor: text; }
.CodeMirror pre { border-top-left-radius: 0px; border-top-right-radius: 0px; border-bottom-right-radius: 0px; border-bottom-left-radius: 0px; border-width: 0px; font-family: inherit; font-size: inherit; margin: 0px; white-space: pre; word-wrap: normal; color: inherit; z-index: 2; position: relative; overflow: visible; background-position: 0px 0px; }
.CodeMirror-wrap pre { word-wrap: break-word; white-space: pre-wrap; word-break: normal; }
.CodeMirror-code pre { border-right-width: 30px; border-right-style: solid; border-right-color: transparent; width: fit-content; }
.CodeMirror-wrap .CodeMirror-code pre { border-right-style: none; width: auto; }
.CodeMirror-linebackground { position: absolute; inset: 0px; z-index: 0; }
.CodeMirror-linewidget { position: relative; z-index: 2; overflow: auto; }
.CodeMirror-wrap .CodeMirror-scroll { overflow-x: hidden; }
.CodeMirror-measure { position: absolute; width: 100%; height: 0px; overflow: hidden; visibility: hidden; }
.CodeMirror-measure pre { position: static; }
.CodeMirror div.CodeMirror-cursor { position: absolute; visibility: hidden; border-right-style: none; width: 0px; }
.CodeMirror div.CodeMirror-cursor { visibility: hidden; }
.CodeMirror-focused div.CodeMirror-cursor { visibility: inherit; }
.cm-searching { background-color: rgba(255, 255, 0, 0.4); }
span.cm-underlined { text-decoration: underline; }
span.cm-strikethrough { text-decoration: line-through; }
.cm-tw-syntaxerror { color: rgb(255, 255, 255); background-color: rgb(153, 0, 0); }
.cm-tw-deleted { text-decoration: line-through; }
.cm-tw-header5 { font-weight: 700; }
.cm-tw-listitem:first-child { padding-left: 10px; }
.cm-tw-box { border-style: solid; border-right-width: 1px; border-bottom-width: 1px; border-left-width: 1px; border-color: inherit; border-top-width: 0px !important; }
.cm-tw-underline { text-decoration: underline; }
@media print {
.CodeMirror div.CodeMirror-cursor { visibility: hidden; }
}
:root {
--side-bar-bg-color: #fafafa;
--control-text-color: #777;
}
@include-when-export url(https://fonts.loli.net/css?family=Open+Sans:400italic,700italic,700,400&subset=latin,latin-ext);
/* open-sans-regular - latin-ext_latin */
/* open-sans-italic - latin-ext_latin */
/* open-sans-700 - latin-ext_latin */
/* open-sans-700italic - latin-ext_latin */
html {
font-size: 16px;
}
body {
font-family: "Open Sans","Clear Sans", "Helvetica Neue", Helvetica, Arial, sans-serif;
color: rgb(51, 51, 51);
line-height: 1.6;
}
#write {
max-width: 860px;
margin: 0 auto;
padding: 30px;
padding-bottom: 100px;
}
@media only screen and (min-width: 1400px) {
#write {
max-width: 1024px;
}
}
@media only screen and (min-width: 1800px) {
#write {
max-width: 1200px;
}
}
#write > ul:first-child,
#write > ol:first-child{
margin-top: 30px;
}
a {
color: #4183C4;
}
h1,
h2,
h3,
h4,
h5,
h6 {
position: relative;
margin-top: 1rem;
margin-bottom: 1rem;
font-weight: bold;
line-height: 1.4;
cursor: text;
}
h1:hover a.anchor,
h2:hover a.anchor,
h3:hover a.anchor,
h4:hover a.anchor,
h5:hover a.anchor,
h6:hover a.anchor {
text-decoration: none;
}
h1 tt,
h1 code {
font-size: inherit;
}
h2 tt,
h2 code {
font-size: inherit;
}
h3 tt,
h3 code {
font-size: inherit;
}
h4 tt,
h4 code {
font-size: inherit;
}
h5 tt,
h5 code {
font-size: inherit;
}
h6 tt,
h6 code {
font-size: inherit;
}
h1 {
font-size: 2.25em;
line-height: 1.2;
border-bottom: 1px solid #eee;
}
h2 {
font-size: 1.75em;
line-height: 1.225;
border-bottom: 1px solid #eee;
}
/*@media print {
.typora-export h1,
.typora-export h2 {
border-bottom: none;
padding-bottom: initial;
}
.typora-export h1::after,
.typora-export h2::after {
content: "";
display: block;
height: 100px;
margin-top: -96px;
border-top: 1px solid #eee;
}
}*/
h3 {
font-size: 1.5em;
line-height: 1.43;
}
h4 {
font-size: 1.25em;
}
h5 {
font-size: 1em;
}
h6 {
font-size: 1em;
color: #777;
}
p,
blockquote,
ul,
ol,
dl,
table{
margin: 0.8em 0;
}
li>ol,
li>ul {
margin: 0 0;
}
hr {
height: 2px;
padding: 0;
margin: 16px 0;
background-color: #e7e7e7;
border: 0 none;
overflow: hidden;
box-sizing: content-box;
}
li p.first {
display: inline-block;
}
ul,
ol {
padding-left: 30px;
}
ul:first-child,
ol:first-child {
margin-top: 0;
}
ul:last-child,
ol:last-child {
margin-bottom: 0;
}
blockquote {
border-left: 4px solid #dfe2e5;
padding: 0 15px;
color: #777777;
}
blockquote blockquote {
padding-right: 0;
}
table {
padding: 0;
word-break: initial;
}
table tr {
border: 1px solid #dfe2e5;
margin: 0;
padding: 0;
}
table tr:nth-child(2n),
thead {
background-color: #f8f8f8;
}
table th {
font-weight: bold;
border: 1px solid #dfe2e5;
border-bottom: 0;
margin: 0;
padding: 6px 13px;
}
table td {
border: 1px solid #dfe2e5;
margin: 0;
padding: 6px 13px;
}
table th:first-child,
table td:first-child {
margin-top: 0;
}
table th:last-child,
table td:last-child {
margin-bottom: 0;
}
.CodeMirror-lines {
padding-left: 4px;
}
.code-tooltip {
box-shadow: 0 1px 1px 0 rgba(0,28,36,.3);
border-top: 1px solid #eef2f2;
}
.md-fences,
code,
tt {
border: 1px solid #e7eaed;
background-color: #f8f8f8;
border-radius: 3px;
padding: 0;
padding: 2px 4px 0px 4px;
font-size: 0.9em;
}
code {
background-color: #f3f4f4;
padding: 0 2px 0 2px;
}
.md-fences {
margin-bottom: 15px;
margin-top: 15px;
padding-top: 8px;
padding-bottom: 6px;
}
.md-task-list-item > input {
margin-left: -1.3em;
}
@media print {
html {
font-size: 13px;
}
table,
pre {
page-break-inside: avoid;
}
pre {
word-wrap: break-word;
}
}
.md-fences {
background-color: #f8f8f8;
}
#write pre.md-meta-block {
padding: 1rem;
font-size: 85%;
line-height: 1.45;
background-color: #f7f7f7;
border: 0;
border-radius: 3px;
color: #777777;
margin-top: 0 !important;
}
.mathjax-block>.code-tooltip {
bottom: .375rem;
}
.md-mathjax-midline {
background: #fafafa;
}
#write>h3.md-focus:before{
left: -1.5625rem;
top: .375rem;
}
#write>h4.md-focus:before{
left: -1.5625rem;
top: .285714286rem;
}
#write>h5.md-focus:before{
left: -1.5625rem;
top: .285714286rem;
}
#write>h6.md-focus:before{
left: -1.5625rem;
top: .285714286rem;
}
.md-image>.md-meta {
/*border: 1px solid #ddd;*/
border-radius: 3px;
padding: 2px 0px 0px 4px;
font-size: 0.9em;
color: inherit;
}
.md-tag {
color: #a7a7a7;
opacity: 1;
}
.md-toc {
margin-top:20px;
padding-bottom:20px;
}
.sidebar-tabs {
border-bottom: none;
}
#typora-quick-open {
border: 1px solid #ddd;
background-color: #f8f8f8;
}
#typora-quick-open-item {
background-color: #FAFAFA;
border-color: #FEFEFE #e5e5e5 #e5e5e5 #eee;
border-style: solid;
border-width: 1px;
}
/** focus mode */
.on-focus-mode blockquote {
border-left-color: rgba(85, 85, 85, 0.12);
}
header, .context-menu, .megamenu-content, footer{
font-family: "Segoe UI", "Arial", sans-serif;
}
.file-node-content:hover .file-node-icon,
.file-node-content:hover .file-node-open-state{
visibility: visible;
}
.mac-seamless-mode #typora-sidebar {
background-color: #fafafa;
background-color: var(--side-bar-bg-color);
}
.md-lang {
color: #b4654d;
}
/*.html-for-mac {
--item-hover-bg-color: #E6F0FE;
}*/
#md-notification .btn {
border: 0;
}
.dropdown-menu .divider {
border-color: #e5e5e5;
opacity: 0.4;
}
.ty-preferences .window-content {
background-color: #fafafa;
}
.ty-preferences .nav-group-item.active {
color: white;
background: #999;
}
.menu-item-container a.menu-style-btn {
background-color: #f5f8fa;
background-image: linear-gradient( 180deg , hsla(0, 0%, 100%, 0.8), hsla(0, 0%, 100%, 0));
}
:root {--mermaid-font-zoom:1em ;} @media print { @page {margin: 0 0 0 0;} body.typora-export {padding-left: 0; padding-right: 0;} #write {padding:0;}}
目录
技术概要：InterSystems IRIS 和 UIMA关于 UIMAInterSystems IRIS 如何补充 UIMA Annotation Store（注释存储） InterSystems IRIS NLP在 InterSystems IRIS 中体验 UIMA 用前须知 创建新的命名空间 运行Java Gateway（Java 网关） 体验 UIMA 分析管道 浏览 Annotation Store（注释存储） 通过分析管道发送新文本 向 Aviation.Event 表添加记录 查看Annotation Store（注释存储）中的新条目了解更多关于 UIMA的资料
技术概要：InterSystems IRIS 和 UIMA
本技术概要（First Look）快速介绍了 InterSystems IRIS® 数据平台如何实施和补充非结构化信息管理架构 (UIMA)。在简要概述 UIMA 以及 InterSystems IRIS 如何对其进行补充之后，您将有机会通过基本的动手练习来在实际应用中了解 InterSystems IRIS。 要浏览技术概要（First Look）的所有内容，包括可以在InterSystems IRIS的免费评估实例上执行的内容，请参阅InterSystems 技术概要。
关于 UIMA
UIMA 是管理分析非结构化信息（如文本和视频）的标准。对于非结构化信息，计算机通常需要几个步骤才能将信息转化为可操作的结构化数据。例如，扫描的文档将文本转变为机器可读版本之前需要OCR，即使这样，在应用额外的 NLP 策略之前，计算机也不能很好地处理自然语言文本。由于像这样的流程包括本质上非常不同的步骤，因此单个工具不太可能处理所有这些步骤。更可能的情况是，这个流程包括单独模块，这些模块由使用不同技术的不同主体执行，且需要协同工作。在 UIMA 中，这些模块被称为analysis engines（分析引擎）。 因为符合 UIMA 标准的分析引擎都遵循相同的标准，所以它们可以组合成一系列分析器（a UIMA analysis pipeline [UIMA 分析管道])，每个部分做自己最擅长的事情。源非结构化数据在通过此 UIMA 分析管道时不会发生改变，而是沿途生成annotations（注释）。UIMA 标准确保来自一个分析引擎的注释不会干扰来自不同分析引擎的注释。对于文本，这些注释基于文本中的字符位置。UIMA 的互操作性允许您将来自不同供应商和技术的分析引擎组合到一个管道中，而无需编写任何自定义代码，并且由于分析引擎引用原始源数据中的字符位置，因此它们的注释可以组合、比较和推理。UIMA 标准包括运行这些分析引擎中所执行的框架。 除了提供互操作性之外，UIMA 还提供了用于扩展和部署这些分析引擎的框架。这使供应商可以专注于开发分析引擎，而不必担心扩展和部署他们的解决方案。[]{#2_How_InterSystems_IRIS_Complements_UIMA .anchor}UIMA 标准还提供了在分布式架构中调用这些分析引擎的框架。 每个符合 UIMA 的分析引擎都必须附带一个 XML 描述符文件，该文件包含基本识别信息，例如分析引擎的名称和供应商。它还定义了对分析引擎生成的注释进行分类的注释类型。
InterSystems IRIS 如何补充 UIMA
InterSystems IRIS 在三个方面补充了 UIMA：
引入功能索引以创建 UIMA 分析管道（analysis pipeline），并在 InterSystems IRIS 表中插入或更新记录时自动为该分析管道提供新文本。
将 UIMA 分析管道生成的注释存储在 InterSystems IRIS 中清晰、可通过 SQL 访问的Annotation Store（注释存储）中。
在 InterSystems IRIS 中体验 UIMA
确保 InterSystems IRIS Natural Language Processing（InterSystems IRIS 自然语言处理， NLP ）符合 UIMA 标准，并可用作 UIMA 分析管道中的分析引擎。
创建和调用 UIMA 分析管道
InterSystems IRIS 使用functional index（功能索引）以创建 UIMA 分析管道，该管道使用 InterSystems IRIS 概念，而无需担心实现 Java 接口。功能索引是 InterSystems IRIS 数据库的一项功能，它允许在表中插入或更新记录时执行功能。在这种情况下，功能索引是定义在表的列上，该列包含您希望由 UIMA 分析管道分析的非结构化数据。设置该管道就像将分析引擎描述文件的位置添加到功能索引定义一样简单。
一旦定义了功能索引，只要在索引表列中插入或更新最新数据，InterSystems IRIS 就会自动将非结构化数据输入 UIMA 分析管道。例如，如果在包含报表的列上定义了功能索引，那么将新报表添加到表中后立即对其进行分析。没有[]{#2.2_Annotation_Store .anchor} InterSystems IRIS 中的这一特殊功能，每次您想要分析数据时，都需要在 Java 中以编程方式通过管道发送非结构化数据。
Annotation Store（注释存储）
默认情况下，UIMA 分析管道的结果被存储在冗长繁琐的 XML 文件中。由于 UIMA 标准没有提供更复杂的注释存储方法，InterSystems IRIS 通过使用灵活的、基于 SQL 的存储，将注释放在统一、持久的表中以便后续检索，从而扩展了 UIMA 分析管道。这种存储系统称为Annotation Store（注释存储）。
在您第一次编译包含为创建 UIMA 分析管道定义的功能索引的类时，会自动创建此Annotation Store（注释存储）。它直接链接到包含非结构化数据的原始表的列。
在架构上，Annotation Store（注释存储） 是通过添加一个特殊的分析引擎作为 UIMA 分析管道的最后一个组件来生成的。当您将 UIMA 功能索引添加到 InterSystems IRIS 类时，将会自动生成Annotation Store（注释存储）。在 InterSystems IRIS 之外开发的 UIMA 分析管道也可以将此特殊分析引擎添加到管道末端，以创建Annotation Store（注释存储）。这种实现方式超出了本技术概要（First Look）的讨论范围。
[]{#2.3_InterSystems_IRIS_NLP .anchor}您还可以使用XData block在包含功能索引的类中自定义Annotation Store（注释存储）。例如，您可以为每个表定义额外的列和索引。您还可以筛选注释类型，以将它们排除在Annotation Store（注释存储）之外。
InterSystems IRIS NLP
InterSystems IRIS Natural Language Processing（InterSystems IRIS 自然语言处理， NLP ）被内置到 InterSystems IRIS® 数据平台中，可以在预先不了解这些非结构化文本主题的情况下，对这些文本进行文本分析。它通过应用识别语义实体的特定语言规则来实现这项功能。由于这些规则是专门针对语言而非内容，因此 InterSystems IRIS NLP可以在不使用字典或本体的情况下提供对文本内容的深入分析
您可以使用 InterSystems IRIS NLP 作为 UIMA 分析引擎，为 NLP 概念和上下文生成 UIMA 注释。这些注释与其他 UIMA 分析引擎提供的 UIMA 注释完全兼容。
在 InterSystems IRIS 中体验 UIMA
现在您已经了解了有关 UIMA 的一些基本信息，可以动手体验以了解它在 InterSystems IRIS 中的工作原理。在体验之前，您需要设置环境。
在 InterSystems IRIS 中体验 UIMA
用前须知
首先，请执行以下初步设置任务：
安装 Java Runtime Environment（Java 运行时环境）。
安装 InterSystems IRIS。
创建一个新的 InterSystems IRIS 命名空间。
启动 Java Gateway（Java 网关）。
安装 Java Runtime Environment（Java 运行环境）
InterSystems IRIS 进行 UIMA 分析管道分析需要安装Java Runtime Environment（Java 运行时环境，JRE）。还需要一个指向 JRE 安装位置的环境变量。
如果您的机器上尚未安装 JRE，请从 Oracle® 下载并安装最新版本。
创建一个名为JAVA_HOME的环境变量，该变量指向 JRE 安装的位置。例如，在 Windows® 上，使用 Control Panel（控制面板）创建JAVA_HOME环境变量，并定义该变量到 JRE 安装位置的路径。
安装 InterSystems IRIS
要运行 UIMA 分析管道的演示，您需要一个运行中的 InterSystems IRIS 已授权的实例。
有关如何安装和授权 InterSystems IRIS 开发实例的说明，请参阅InterSystems IRIS Basics: Installation （《InterSystems IRIS 基础知识：安装》）。
创建新的命名空间
作为技术概要（First Look）体验的一部分，您将向 InterSystems IRIS 中的命名空间添加一个新类文件。为了使此示例数据与预定义的命名空间分开，请创建一个名为 SAMPLES 的新命名空间来保存与此技术概要（First Look）关联的代码和数据。创建一个新的命名空间：
在浏览器中打开 Management Portal （管理门户），使用 InterSystems IRIS Basics: Connecting an IDE（《INTERSYSTEMS IRIS 基础：连接一个IDE 》）的实例适用的URL。
选择 System Administration（系统管理） > Configuration（配置） > System Configuration（系统配置） > Namespaces（命名空间）。
在 Namespaces（命名空间）页面，选择 Create New Namespace（新建命名空间）。
在 New Namespace（新建命名空间）页面，输入SAMPLES作为新命名空间的名称。
点击 Create New Database（新建数据库），将显示 Database Wizard（数据库向导）。
在 Database Wizard（数据库向导）的第一页，在 Enter the name of your database（输入您的数据库名称）字段，输入您正在创建的数据库的名称，例如 Samplesdb。
输入数据库的目录，例如 C:\InterSystems\IRIS\mgr\Samplesdb 。
点击 Next（下一步）。
点击 Finish（完成）。
回到New Namespace（新命名空间）页面，在Select an existing database for Routines（为 Routine 选择一个现有数据库）下拉菜单，选择您刚刚创建的数据库Samplesdb。
点击靠近页面顶部的 Save（保存），然后在结果日志的末尾单击 Close（关闭）。
UIMA 分析管道
运行Java Gateway（Java 网关）
Java Gateway（Java 网关）可以实例化外部 Java object（Java 对象），就好像它是 InterSystems IRIS 中的本机对象一样，可以对其进行操作。InterSystems IRIS 的 UIMA 策略使用Java Gateway（Java 网关），可以从command line （命令行）启动Java Gateway（Java 网关）。例如，在 Windows 上：
打开 Run（运行）对话框。
输入以下命令：
%JAVA_HOME%\bin\java -classpath "C:\InterSystems\IRIS\dev\java\lib\JDK18\*;C:\InterSystems\IRIS\dev\java\lib\jackson\*;C:\InterSystems\IRIS \dev\java\lib\uima\*" com.intersystems.gateway.JavaGateway 5555
其中：
JAVA_HOME 是指向Java Runtime Environment（Java 运行环境，JRE）安装目录位置的环境变量。
C:\InterSystems\IRIS 是您安装的 InterSystems IRIS 的目录。
JDK18 对应您的 JRE 版本。
如果在UNIX®上运行 ，请记住 -classpath 的句法使用冒号作为分隔符。
体验 UIMA 分析管道
现在您已经完成了准备工作，并已准备好在实际应用中查看 UIMA 分析管道的运行情况。在这次体验中，您将：
添加包含 UIMA 功能索引的类文件
编译包含功能索引的类。
查看 Annotation Store （注释存储）的表。
将非结构化数据添加到示例数据库。
浏览 Annotation Store（注释存储） 以获取分析管道生成的新数据。
添加带有 UIMA 功能索引的类文件
您可以通过为包含非结构化文本的表定义功能索引，向 UIMA 分析管道添加分析引擎。在本次体验中，您将向该分析管道添加 InterSystems IRIS NLP 分析引擎。
在体验的这一部分中，您将创建一个新的类文件。可以在您喜欢的文本编辑器或 IDE（例如 InterSystems Studio 或带有 ObjectScript 扩展名的 Visual Studio Code）中创建类文件。
在 IDE 或文本编辑器中创建一个新文件。
将以下内容复制并粘贴到类文件中：
xxxxxxxxxx
Class Sample.MyData Extends %Persistent
{
Property MyText As %String;
Index MyIndex On (MyText) As %UIMA.Index(AEDESCRIPTOR = \"classpath:/com/intersystems/uima/annotator/iKnowEngine.xml\");
}
体验 UIMA 分析管道
其中：
MyText 是包含非结构化文本的 Sample.MyData 表中的列。
MyIndex 是 UIMA 功能索引。
iKnowEngine.xml是 InterSystems IRIS NLP 分析引擎的描述符文件。
将文件另存为sample.cls。
编译表类
要自动生成 Annotation Store （注释存储），您只需使用InterSystems Terminal（InterSystems 终端）或 IDE 提供的工具编译包含功能索引的类。
建议： 使用 InterSystems Terminal（InterSystems 终端）时，您可以使用 Shift+Insert 命令将剪贴板的内容粘贴到终端命令提示符中。从本指南复制命令并将它们粘贴到终端中以减少错误，这种方式很有用。
加载和编译类：
打开 InterSystems Terminal（InterSystems 终端）。有关为您的实例打开Terminal （终端）的信息，请参阅InterSystems IRIS Basics: Connecting an IDE（《INTERSYSTEMS IRIS 基础：连接一个IDE 》）中的InterSystems IRIS Connection Information （《InterSystems IRIS 连接信息》）。
切换到您为此演示创建的命名空间。例如： set $namespace="samples"
输入以下命令，将类文件加载到命名空间中： do $system.OBJ.Load("<sample-dir>\sample.cls")
其中 <sample-dir> 是您保存 samples.cls 类文件的位置。
输入以下命令，编译您粘贴到sample.cls 的Sample.MyData 类： do $system.OBJ.Compile("Sample.MyData")
浏览 Annotation Store（注释存储）
既然您已经使用 Annotation Store UIMA 功能索引编译了类，可以浏览为保留 InterSystems IRIS NLP 生成的注释而创建的（Annotation Store ）注释存储。
在浏览器中使用 URL 为实例打开 Management Portal （管理门户），如InterSystems IRIS Basics: Connecting an IDE（《INTERSYSTEMS IRIS 基础：连接一个IDE 》）的InterSystems IRIS Connection Information（InterSystems IRIS 连接信息）所述。
使用标题中的链接切换到 Samples 命名空间。
参观 UIMA 分析管道
进入 System Explorer（系统资源管理器）> SQL 。
展开左侧窗格中的 Tables（表） 列表。
可以看到 Annotation Store （注释存储） 的三个表。这些表的命名规则对应包含所分析的非结构化文本的表 (Sample.MyData)。
Sample_MyData.Type------包含此存储中使用的Annotation Types （注释类型）的概述。
Sample_MyData.Sofa------包含 sofas，这是 UIMA 分析引擎分析的文本对象。
Sample_MyData.Annotation------包含该分析引擎生成的注释。
您可以修改功能索引定义以创建多个注释表，然后根据注释类型将结果输出到正确的表中。
通过分析管道发送新文本
InterSystems IRIS 中 UIMA 分析管道的强大之处在于，新的非结构化文本会自动通过管道发送以进行分析，并将结果添加到 Annotation Store （注释存储）中。由于您已经创建了 Annotation Store（注释存储），可以看到新纪录如何被添加到 Sample.MyData 表，并生成添加到 Annotation Store的新条目。
向 Aviation.Event 表添加记录
在本步骤中，您将使用 SQL 向示例数据库中的 Sample.MyData 表添加一些非结构化文本。请记住，该表包含MyText 列，您已在该列上定义功能索引。正如您将看到的，当进行此插入操作时，会自动生成注释。
在System Explorer （系统资源管理器 ）> SQL页，展开左侧窗格中的 Tables（表） 列表。
选择 Sample.MyData，这是包含通过分析管道发送的非结构化文本的表。
在右侧窗格中，单击 Execute Query（执行查询）标签。
要将新条目插入示例数据库，请在文本框中输入以下查询
xxxxxxxxxx
INSERT INTO Sample.MyData (MyText) VALUES (\'First Look unstructured text\')
点击 Execute （执行）。
这会将短语"First Look unstructured text"放入 Sample.MyData 表的 MyText 列中。
了解更多关于 UIMA的资料
查看Annotation Store（注释存储）中的新条目
现在您已将新的非结构化文本添加到示例数据库中，可以查看 Annotation Store 以了解这些文本是如何通过分析管道自动发送的。您可以看到新的非结构化文本和来自 InterSystems IRIS NLP 的注释都添加到了Annotation Store（注释存储）中。
在 System Explorer （系统资源管理器 ）> SQL页，展开左侧窗格中的 Tables（表） 列表。
选择 Sample_MyData.Sofa 表。
在右侧窗格中，单击 Open Table（打开表）。
您可以看到添加到 Annotation Store 的新记录。sofaString是由分析管道处理的一段非结构化文本。
点击 Close Window（关闭窗口）。
在左侧窗格中，选择 Sample_MyData.Annotation 表。
点击 Open Table（打开表）。
在coveredText列，您可以看到由 InterSystems IRIS NLP 分析引擎生成的注释。
了解更多关于 UIMA的资料
要了解有关 InterSystems IRIS 如何实施和补充 UIMA 的更多信息，请参阅 Using InterSystems UIMA（《使用 InterSystems UIMA》）。
有关 UIMA 标准的框架、基础设施和组件的详细概述，请参阅 Apache UIMA home page
