本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。
# 设置 AWS IoT Greengrass 核心设备
完成本节中的任务以安装、配置和运行 AWS IoT Greengrass 核心软件。
**注意**
本节介绍 AWS IoT Greengrass 核心软件的高级安装和配置。这些步骤不适用于 nucleus Lite。如果您是首次使用 nucleus Lite AWS IoT Greengrass V2，我们建议您先完成[入门教程](getting-started.md)，设置核心设备并探索其功能。 AWS IoT Greengrass
**Topics**
+ [支持的平台](#supported-platforms)
+ [设备要求](#device-requirements)
+ [Lambda 函数要求](#greengrass-v2-lambda-requirements)
+ [设置一个 AWS 账户](#set-up-aws-account)
+ [安装 AWS IoT Greengrass Core 软件](install-greengrass-core-v2.md)
+ [运行 AWS IoT Greengrass 核心软件](run-greengrass-core-v2.md)
+ [在 Docker 容器中运行 AWS IoT Greengrass 核心软件](run-greengrass-docker.md)
+ [配置 AWS IoT Greengrass 核心软件](configure-greengrass-core-v2.md)
+ [更新 AWS IoT Greengrass Core 软件（OTA）](update-greengrass-core-v2.md)
+ [卸载 AWS IoT Greengrass Core 软件](uninstall-greengrass-core-v2.md)
## 支持的平台
+ [支持 Greengrass Nucleus 的平台](https://docs.aws.amazon.com/greengrass/v2/developerguide/greengrass-nucleus-component.html)
+ [支持 Greengrass Nucleus Lite 的平台](https://docs.aws.amazon.com/greengrass/v2/developerguide/greengrass-nucleus-lite-component.html)
## 设备要求
+ [Greengrass Nucleus 设备要求](https://docs.aws.amazon.com/greengrass/v2/developerguide/greengrass-nucleus-component.html)
+ [Greengrass Nucleus Lite 设备要求](https://docs.aws.amazon.com/greengrass/v2/developerguide/greengrass-nucleus-lite-component.html)
## Lambda 函数要求
**重要**
Greengrass Nucleus Lite 目前不支持 Greengrass Lambda 函数。
您的设备必须满足以下要求才能运行 Lambda 函数：
+ 基于 Linux 的操作系统。
+ 您的设备必须有 `mkfifo` Shell 命令。
+ 您的设备必须运行 Lambda 函数所需的编程语言库。您必须在设备上安装所需的库并将其添加到 `PATH` 环境变量中。Greengrass 支持所有 Lambda 支持的 Python、Node.js 和 Java 运行时版本。Greengrass 不对已弃用的 Lambda 运行时版本施加任何额外限制。有关 AWS IoT Greengrass 支持 Lambda 运行时的更多信息，请参阅。[运行 AWS Lambda 函数](run-lambda-functions.md)
+ 要运行容器化 Lambda 函数，您的设备必须满足以下要求：
+ Linux 内核 4.4 或更高版本。
+ 内核必须支持 [cgroups](https://en.wikipedia.org/wiki/Cgroups) v1，并且您必须启用并挂载以下 cgroups：
+ 用于为 AWS IoT Greengrass 容*器*化 Lambda 函数设置内存限制的内存 cgroup。
+ 用于容器化 Lambda 函数访问系统设备或卷的 *devices* cgroup。
AWS IoT Greengrass 核心软件不支持 cgroups v2。
要满足此要求，请使用以下 Linux 内核参数启动设备。
```
cgroup_enable=memory cgroup_memory=1 systemd.unified_cgroup_hierarchy=0
```
**提示**
在 Raspberry Pi 上，编辑 `/boot/cmdline.txt` 文件以设置设备的内核参数。
+ 您必须在设备上启用以下 Linux 内核配置：
+ 命名空间：
+ `CONFIG_IPC_NS`
+ `CONFIG_UTS_NS`
+ `CONFIG_USER_NS`
+ `CONFIG_PID_NS`
+ Cgroups：
+ `CONFIG_CGROUP_DEVICE`
+ `CONFIG_CGROUPS`
+ `CONFIG_MEMCG`
+ 其他：
+ `CONFIG_POSIX_MQUEUE`
+ `CONFIG_OVERLAY_FS`
+ `CONFIG_HAVE_ARCH_SECCOMP_FILTER`
+ `CONFIG_SECCOMP_FILTER`
+ `CONFIG_KEYS`
+ `CONFIG_SECCOMP`
+ `CONFIG_SHMEM`
**提示**
查看您的 Linux 发行版文档以了解如何验证并设置 Linux 内核参数。您也可以使用 AWS IoT Device Tester AWS IoT Greengrass 来验证您的设备是否满足这些要求。有关更多信息，请参阅 [使用适用于 AWS IoT Greengrass V2 的 AWS IoT Device Tester](device-tester-for-greengrass-ug.md)。
## 设置一个 AWS 账户
如果您没有 AWS 账户，请完成以下步骤来创建一个。
**要注册 AWS 账户**
1. 打开[https://portal.aws.amazon.com/billing/注册。](https://portal.aws.amazon.com/billing/signup)
1. 按照屏幕上的说明操作。
在注册时，将接到电话或收到短信，要求使用电话键盘输入一个验证码。
当您注册时 AWS 账户，就会创建*AWS 账户根用户*一个。根用户有权访问该账户中的所有 AWS 服务 和资源。作为最佳安全实践，请为用户分配管理访问权限，并且只使用根用户来执行[需要根用户访问权限的任务](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks)。
要创建管理员用户，请选择以下选项之一。
****
| 选择一种方法来管理您的管理员 | 目的 | 方式 | 您也可以 |
| --- | --- | --- | --- |
| 在 IAM Identity Center 中 （建议） | 使用短期凭证访问 AWS。这符合安全最佳实操。有关最佳实践的信息，请参阅《IAM 用户指南》**中的 [IAM 中的安全最佳实践](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#bp-users-federation-idp)。 | 有关说明，请参阅《AWS IAM Identity Center 用户指南》中的[入门](https://docs.aws.amazon.com//singlesignon/latest/userguide/getting-started.html)。 | 通过在《AWS Command Line Interface 用户指南[》 AWS IAM Identity Center中配置 AWS CLI 要使用的来](https://docs.aws.amazon.com//cli/latest/userguide/cli-configure-sso.html)配置编程访问权限。 |
| 在 IAM 中 （不推荐使用） | 使用长期凭证访问 AWS。 | 按照《IAM 用户指南》中的[创建用于紧急访问的 IAM 用户](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started-emergency-iam-user.html)中的说明进行操作。 | 按照《IAM 用户指南》中的[管理 IAM 用户的访问密钥](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_credentials_access-keys.html)，配置编程式访问。 |
# 安装 AWS IoT Greengrass Core 软件
AWS IoT Greengrass 可将 AWS 无缝扩展至边缘设备，以便可以操作其生成的数据，并将 AWS 云 用于管理、分析和持久存储。在边缘设备上安装 AWS IoT Greengrass Core 软件以与 AWS IoT Greengrass 和 AWS 云 集成。
**重要**
下载和安装 AWS IoT Greengrass Core 软件前，请检查您的核心设备是否满足安装和运行 AWS IoT Greengrass Core 软件 v2.0 的[要求](greengrass-nucleus-component.md#greengrass-v2-requirements)。
AWS IoT Greengrass Core 软件包括一个安装程序，可将您的设备设置为 Greengrass 核心设备。运行安装程序时，您可以配置选项，例如根文件夹和要使用的 AWS 区域。您可以选择让安装程序为您创建所需的 AWS IoT 和 IAM 资源。您也可以选择部署本地开发工具以配置用于自定义组件开发的设备。
AWS IoT Greengrass Core 软件需要以下 AWS IoT 和 IAM 资源才能连接到 AWS 云 并运行：
+ AWS IoT 事物。将设备注册为 AWS IoT 事物后，该设备可以使用数字证书来向 AWS 进行身份验证。此证书允许设备与 AWS IoT 和 AWS IoT Greengrass 通信。有关更多信息，请参阅 [设备身份验证和授权 AWS IoT Greengrass](device-auth.md)。
+ （可选）AWS IoT 事物组。您可以使用事物组来管理 Greengrass 核心设备实例集。将软件组件部署到设备时，可以选择部署到单个设备或设备组。您可以将设备添加到一个事物组，以将该事物组的软件组件部署到该设备。有关更多信息，请参阅 [将 AWS IoT Greengrass 组件部署到设备](manage-deployments.md)。
+ IAM 角色。Greengrass 核心设备使用 AWS IoT Core 凭证提供程序授权通过 IAM 角色调用 AWS 服务。此角色允许您的设备与 AWS IoT 交互、将日志发送到 Amazon CloudWatch Logs 以及从 Amazon Simple Storage Service（Amazon S3）下载自定义组件构件。有关更多信息，请参阅 [授权核心设备与 AWS 服务交互](device-service-role.md)。
+ AWS IoT 角色别名。Greengrass 核心设备使用角色别名来标识要使用的 IAM 角色。角色别名允许您更改 IAM 角色，但设备配置保持不变。有关更多信息，请参阅《AWS IoT Core 开发人员指南》**中的[授权直接调用 AWS 服务](https://docs.aws.amazon.com/iot/latest/developerguide/authorizing-direct-aws.html)。
选择以下选项之一，以将 AWS IoT Greengrass Core 软件安装到您的核心设备。
+ **快速安装**
选择此选项可在尽可能少的步骤内设置 Greengrass 核心设备。安装程序为您创建所需的 AWS IoT 和 IAM 资源。此选项要求您向安装程序提供 AWS 凭证才能在 AWS 账户 中创建资源。
不能使用此选项在防火墙或网络代理之后进行安装。如果设备位于防火墙或网络代理之后，请考虑使用[手动安装](manual-installation.md)。
有关更多信息，请参阅 [安装具有自动资源配置功能的 AWS IoT Greengrass Core 软件](quick-installation.md)。
+ **手动安装**
选择此选项可手动创建所需 AWS 资源或在防火墙或网络代理之后进行安装。使用手动安装时，您无需向安装程序授予在 AWS 账户 中创建资源的权限，因为您已创建了所需的 AWS IoT 和 IAM 资源。您也可以将设备配置为通过端口 443 或网络代理进行连接。您还可以将 AWS IoT Greengrass Core 软件配置为使用存储在硬件安全模块（HSM）、可信平台模块（TPM）或其他加密元素中的私钥和证书。
有关更多信息，请参阅 [使用手动资源配置来安装 AWS IoT Greengrass Core 软件](manual-installation.md)。
+ **使用 AWS IoT 实例集预置进行安装**
选择此选项可根据 AWS IoT 实例集预置模板创建所需的 AWS 资源。如果您要创建实例集中的类似设备，或者制造客户稍后激活的设备（例如车辆或智能家居设备），您可以选择此选项。设备使用声明证书来验证和预置 AWS 资源，包括设备用于连接 AWS 云 以实现正常操作的 X.509 客户端证书。在制造过程中，您可以将声明证书嵌入或闪存到设备的硬件中，也可以使用相同的声明证书和密钥来预置多个设备。您也可以将设备配置为通过端口 443 或网络代理进行连接。
有关更多信息，请参阅 [安装具有 AWS IoT 队列配置功能的 C AWS IoT Greengrass ore 软件](fleet-provisioning.md)。
+ **使用自定义预置进行安装**
选择此选项可开发预置所需 AWS 资源的自定义 Java 应用程序。如果您[创建自己的 X.509 客户端证书](https://docs.aws.amazon.com/iot/latest/developerguide/device-certs-your-own.html)，或者想要更好地控制预置过程，则可以选择此选项。AWS IoT Greengrass 提供一个您可以实现的接口，以便在您的自定义预置应用程序和 AWS IoT Greengrass Core 软件安装程序之间交换信息。
有关更多信息，请参阅 [安装具有自定义资源配置功能的 C AWS IoT Greengrass ore 软件](custom-provisioning.md)。
AWS IoT Greengrass 还提供了运行 AWS IoT Greengrass Core 软件的容器化环境。您可以使用 Dockerfile [在 Docker 容器中运行 AWS IoT Greengrass](run-greengrass-docker.md)。
**Topics**
+ [使用自动预置安装](quick-installation.md)
+ [使用手动预置进行安装](manual-installation.md)
+ [通过 实例集预置安装](fleet-provisioning.md)
+ [使用自定义预置安装](custom-provisioning.md)
+ [安装程序参数](configure-installer.md)
# 安装具有自动资源配置功能的 AWS IoT Greengrass Core 软件
AWS IoT Greengrass 核心软件包括一个安装程序，可将您的设备设置为 Greengrass 核心设备。要快速设置设备，安装程序可以预配置核心设备运行所需 AWS IoT 的事物、事物组、IAM AWS IoT 角色和角色别名。 AWS IoT 安装程序还可以将本地开发工具部署到核心设备，因此您可以使用该设备开发和测试自定义软件组件。安装程序需要 AWS 凭据才能配置这些资源和创建部署。
如果您无法向设备提供 AWS 凭据，则可以配置核心设备运行所需的 AWS 资源。您还可以将开发工具部署到核心设备上，用作开发设备。这使您能够在运行安装程序时向设备提供较少的权限。有关更多信息，请参阅 [使用手动资源配置来安装 AWS IoT Greengrass Core 软件](manual-installation.md)。
**重要**
在下载 AWS IoT Greengrass 核心软件之前，请检查您的核心设备是否满足安装和运行 AWS IoT Greengrass 酷睿软件 v2.0 的[要求](greengrass-nucleus-component.md#greengrass-v2-requirements)。
**注意**
要以非 root 用户身份安装和运行 AWS IoT Greengrass Core 软件，请参阅[将 AWS IoT Greengrass V2 核心设备设置为非 root](setup-greengrass-non-root.md)。
**Topics**
+ [设置设备环境](#set-up-device-environment)
+ [为设备提供 AWS 凭证](#provide-installer-aws-credentials)
+ [下载 AWS IoT Greengrass 核心软件](#download-greengrass-core-v2)
+ [安装 AWS IoT Greengrass 核心软件](#run-greengrass-core-v2-installer)
## 设置设备环境
按照本节中的步骤，将 Linux 或 Windows 设备设置为您的 AWS IoT Greengrass 核心设备。
### 设置 Linux 设备
**设置 Linux 设备用于 AWS IoT Greengrass V2**
1. 安装 Java 运行时， AWS IoT Greengrass 核心软件需要运行该运行时。我们建议您使用 [Amazon Corretto](https://aws.amazon.com/corretto/) 或 [OpenJDK](https://openjdk.java.net/) 长期支持版本。需要版本 8 或更高版本。以下命令向您展示如何在您的设备上安装 OpenJDK。
+ 对于基于 Debian 或基于 Ubuntua 的发行版：
```
sudo apt install default-jdk
```
+ 对于基于 Red Hat 的发行版：
```
sudo yum install java-11-openjdk-devel
```
+ 对于 Amazon Linux 2：
```
sudo amazon-linux-extras install java-openjdk11
```
+ 对于 Amazon Linux 2023：
```
sudo dnf install java-11-amazon-corretto -y
```
安装完成后，运行以下命令以验证 Java 是否在您的 Linux 设备上运行。
```
java -version
```
此命令会打印设备上运行的 Java 版本。例如，在基于 Debian 的发行版上，输出可能与以下示例类似。
```
openjdk version "11.0.9.1" 2020-11-04
OpenJDK Runtime Environment (build 11.0.9.1+1-post-Debian-1deb10u2)
OpenJDK 64-Bit Server VM (build 11.0.9.1+1-post-Debian-1deb10u2, mixed mode)
```
1. （可选）创建在设备上运行组件的默认系统用户和组。您也可以选择让 AWS IoT Greengrass 核心软件安装程序在安装过程中使用安装程序参数创建此用户和组。`--component-default-user`有关更多信息，请参阅 [安装程序参数](configure-installer.md)。
```
sudo useradd --system --create-home ggc_user
sudo groupadd --system ggc_group
```
1. 验证运行 AWS IoT Greengrass Core 软件的用户（通常`root`）是否有权`sudo`与任何用户和任何组一起运行。
1. 运行以下命令以打开 `/etc/sudoers` 文件。
```
sudo visudo
```
1. 验证用户的权限是否如以下示例所示。
```
root ALL=(ALL:ALL) ALL
```
1. （可选）要[运行容器化 Lambda 函数](run-lambda-functions.md)，必须启用 [cgroups](https://en.wikipedia.org/wiki/Cgroups) v1，且必须启用并装载*内存*和*设备* cgroups。如果您不打算运行容器化 Lambda 函数，则可跳过此步骤。
要启用这些 cgroups 选项，请使用以下 Linux 内核参数启动设备。
```
cgroup_enable=memory cgroup_memory=1 systemd.unified_cgroup_hierarchy=0
```
有关查看和设置设备内核参数的信息，请参阅适用于您操作系统和启动加载程序的文档。按照说明永久设置内核参数。
1. 按照 [设备要求](greengrass-nucleus-component.md#greengrass-v2-requirements) 中的要求列表所示，在您的设备上安装所有其他必需的依赖关系。
### 设置 Windows 设备
**注意**
此功能适用于 [Greengrass Nucleus 组件](greengrass-nucleus-component.md) v2.5.0 及更高版本。
**要将 Windows 设备设置为 AWS IoT Greengrass V2**
1. 安装 Java 运行时， AWS IoT Greengrass 核心软件需要运行该运行时。我们建议您使用 [Amazon Corretto](https://aws.amazon.com/corretto/) 或 [OpenJDK](https://openjdk.java.net/) 长期支持版本。需要版本 8 或更高版本。
1. 检查在 [PATH](https://en.wikipedia.org/wiki/PATH_(variable)) 系统变量上是否有 Java 可用，如果没有，请进行添加。该 LocalSystem 帐户运行 AWS IoT Greengrass Core 软件，因此您必须将 Java 添加到 PATH 系统变量中，而不是用户的 PATH 用户变量。执行以下操作：
1. 按下 Windows 键打开开始菜单。
1. 键入 **environment variables** 以从开始菜单中搜索系统选项。
1. 在开始菜单搜索结果中，选择**编辑系统环境变量**，以打开**系统属性**窗口。
1. 选择**环境变量...**，打开**环境变量**窗口。
1. 在**系统变量**下，选择**路径**，然后选择**编辑**。在**编辑环境变量**窗口中，您可以分行查看每个路径。
1. 检查 Java 安装的 `bin` 文件夹的路径是否存在。路径可能与以下示例类似。
```
C:\\Program Files\\Amazon Corretto\\jdk11.0.13_8\\bin
```
1. 如果**路径**中缺少 Java 安装的 `bin` 文件夹，请选择**新建**，添加该文件夹，然后选择**确定**。
1. 以管理员身份打开 Windows 命令提示符 (`cmd.exe`)。
1. 在 Windows 设备上的 LocalSystem 帐户中创建默认用户。*password*替换为安全密码。
```
net user /add ggc_user password
```
**提示**
根据您的 Windows 配置，用户密码可能会设置为在将来某个日期过期。为确保您的 Greengrass 应用程序继续运行，请跟踪密码过期时间，并在密码过期之前对其进行更新。您还可以将用户的密码设置为永不过期。
要检查用户及其密码的过期时间，请运行以下命令。
```
net user ggc_user | findstr /C:expires
```
要将用户密码设置为永不过期，请运行以下命令。
```
wmic UserAccount where "Name='ggc_user'" set PasswordExpires=False
```
如果你使用的是[已弃用该`wmic`命令的](https://learn.microsoft.com/en-us/windows/win32/wmisdk/wmic) Windows 10 或更高版本，请运行以下 PowerShell 命令。
```
Get-CimInstance -Query "SELECT * from Win32_UserAccount WHERE name = 'ggc_user'" | Set-CimInstance -Property @{PasswordExpires="False"}
```
1. 从微软下载该[PsExec实用程序](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec)并将其安装到设备上。
1. 使用该 PsExec 实用程序将默认用户的用户名和密码存储在 LocalSystem 账户的凭据管理器实例中。*password*替换为您之前设置的用户密码。
```
psexec -s cmd /c cmdkey /generic:ggc_user /user:ggc_user /pass:password
```
如果系统打开 **PsExec License Agreement**，请选择 **Accept** 以同意许可并运行命令。
**注意**
在 Windows 设备上，该 LocalSystem 帐户运行 Greengrass 核心，您必须使用 PsExec 该实用程序在帐户中存储默认用户信息。 LocalSystem 使用凭据管理器应用程序将此信息存储在当前登录用户的 Windows 帐户中，而不是 LocalSystem 帐户中。
## 为设备提供 AWS 凭证
向您的设备提供您的 AWS 凭据，以便安装程序可以配置所需的 AWS 资源。有关所需权限的更多信息，请参阅 [安装程序配置资源的最低 IAM 策略](provision-minimal-iam-policy.md)。
**为设备提供 AWS 凭证**
+ 向设备提供您的 AWS 证书，以便安装程序可以为您的核心设备配置 AWS IoT 和 IAM 资源。为了提高安全性，我们建议您为 IAM 角色获取临时凭证，该凭证仅允许预置所需的最低权限。有关更多信息，请参阅 [安装程序配置资源的最低 IAM 策略](provision-minimal-iam-policy.md)。
**注意**
安装程序不会保存或存储您的凭证。
在您的设备上，执行以下任一操作以检索凭证并将其提供给 AWS IoT Greengrass Core 软件安装程序：
+ （推荐）使用来自的临时证书 AWS IAM Identity Center
1. 提供来自 IAM Identity Center 的访问密钥 ID、秘密访问密钥和会话令牌。有关更多信息，请参阅《IAM Identity Center 用户指南》**的[获取和刷新临时凭证](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtogetcredentials.html#how-to-get-temp-credentials)中的**手动凭证刷新**。
1. 运行以下命令为 AWS IoT Greengrass 核心软件提供凭据。
------
#### [ Linux or Unix ]
```
export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
export AWS_SESSION_TOKEN=AQoDYXdzEJr1K...o5OytwEXAMPLE=
```
------
#### [ Windows Command Prompt (CMD) ]
```
set AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
set AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
set AWS_SESSION_TOKEN=AQoDYXdzEJr1K...o5OytwEXAMPLE=
```
------
#### [ PowerShell ]
```
$env:AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
$env:AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
$env:AWS_SESSION_TOKEN="AQoDYXdzEJr1K...o5OytwEXAMPLE="
```
------
+ 使用来自 IAM 角色的临时安全凭证：
1. 提供来自您担任的 IAM 角色的访问密钥 ID、秘密访问密钥和会话令牌。有关如何检索这些凭证的更多信息，请参阅《IAM 用户指南》**中的[请求临时安全凭证](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html)。
1. 运行以下命令为 AWS IoT Greengrass 核心软件提供凭据。
------
#### [ Linux or Unix ]
```
export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
export AWS_SESSION_TOKEN=AQoDYXdzEJr1K...o5OytwEXAMPLE=
```
------
#### [ Windows Command Prompt (CMD) ]
```
set AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
set AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
set AWS_SESSION_TOKEN=AQoDYXdzEJr1K...o5OytwEXAMPLE=
```
------
#### [ PowerShell ]
```
$env:AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
$env:AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
$env:AWS_SESSION_TOKEN="AQoDYXdzEJr1K...o5OytwEXAMPLE="
```
------
+ 使用 IAM 用户的长期凭证：
1. 为 IAM 用户提供访问密钥 ID 和秘密访问密钥。您可以创建 IAM 用户用于预置，稍后再将其删除。有关向用户提供的 IAM 策略，请参阅 [安装程序配置资源的最低 IAM 策略](provision-minimal-iam-policy.md)。有关如何检索长期凭证的更多信息，请参阅《IAM 用户指南》**中的[管理 IAM 用户的访问密钥](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html)。
1. 运行以下命令为 AWS IoT Greengrass 核心软件提供凭据。
------
#### [ Linux or Unix ]
```
export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
```
------
#### [ Windows Command Prompt (CMD) ]
```
set AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
set AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
```
------
#### [ PowerShell ]
```
$env:AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
$env:AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
```
------
1. （可选）如果您创建了 IAM 用户来预置 Greengrass 设备，请删除该用户。
1. （可选）如果您使用了现有 IAM 用户的访问密钥 ID 和秘密访问密钥，请更新该用户的密钥，使其失效。有关更多信息，请参阅《AWS Identity and Access Management 用户指南》中的[更新访问密钥](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html#Using_RotateAccessKey)**。
## 下载 AWS IoT Greengrass 核心软件
您可以从以下位置下载最新版本的 AWS IoT Greengrass Core 软件：
+ [https://d2s8p88vqu9w66.cloudfront。 net/releases/greengrass](https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip)-nucleus-latest.zip
**注意**
您可以从以下位置下载特定版本的 AWS IoT Greengrass Core 软件。*version*替换为要下载的版本。
```
https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-version.zip
```
**下载 AWS IoT Greengrass 核心软件**
1. 在您的核心设备上，将 AWS IoT Greengrass Core 软件下载到名为的文件中`greengrass-nucleus-latest.zip`。
------
#### [ Linux or Unix ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
iwr -Uri https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip -OutFile greengrass-nucleus-latest.zip
```
------
下载此软件即表示您同意[Greengrass Core 软件许可协议](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf)。
1. （可选）验证 Greengrass Nucleus 软件签名
**注意**
此功能适用于 Greengrass Nucleus 版本 2.9.5 及更高版本。
1. 使用以下命令验证您 Greengrass Nucleus 构件的签名：
------
#### [ Linux or Unix ]
```
jarsigner -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
根据您安装的 JDK 版本，文件名可能有所不同。将 *`jdk17.0.6_10`* 替换为您安装的 JDK 版本。
```
"C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe" -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
根据您安装的 JDK 版本，文件名可能有所不同。将 *`jdk17.0.6_10`* 替换为您安装的 JDK 版本。
```
'C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe' -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
1. `jarsigner` 调用会生成输出，指示验证结果。
1. 如果 Greengrass Nucleus ZIP 文件已签署，则输出将包含以下语句：
```
jar verified.
```
1. 如果 Greengrass Nucleus ZIP 文件未签署，则输出将包含以下语句：
```
jar is unsigned.
```
1. 如果您提供了 Jarsigner `-certs` 选项以及 `-verify` 和 `-verbose` 选项，则输出还将包含详细的签名者证书信息。
1. 将 AWS IoT Greengrass Core 软件解压缩到设备上的某个文件夹。*GreengrassInstaller*替换为要使用的文件夹。
------
#### [ Linux or Unix ]
```
unzip greengrass-nucleus-latest.zip -d GreengrassInstaller && rm greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
mkdir GreengrassInstaller && tar -xf greengrass-nucleus-latest.zip -C GreengrassInstaller && del greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
Expand-Archive -Path greengrass-nucleus-latest.zip -DestinationPath .\\GreengrassInstaller
rm greengrass-nucleus-latest.zip
```
------
1. （可选）运行以下命令以查看 AWS IoT Greengrass Core 软件的版本。
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
**重要**
如果您安装了 v2.4.0 之前的 Greengrass nucleus 版本，则在安装 Core 软件后请勿删除此文件夹。 AWS IoT Greengrass C AWS IoT Greengrass ore 软件使用此文件夹中的文件来运行。
如果您下载的是最新版本的软件，则需要安装 v2.4.0 或更高版本，并且可以在安装 C AWS IoT Greengrass ore 软件后删除此文件夹。
## 安装 AWS IoT Greengrass 核心软件
使用可指定以下操作的参数运行安装程序：
+ 创建核心设备运行所需的 AWS 资源。
+ 指定使用 `ggc_user` 系统用户在核心设备上运行软件组件。在 Linux 设备上，此命令还指定使用 `ggc_group` 系统组，安装程序会为您创建系统用户和组。
+ 将 AWS IoT Greengrass Core 软件设置为启动时运行的系统服务。在 Linux 设备上，这需要 [Systemd](https://en.wikipedia.org/wiki/Systemd) 初始化系统。
**重要**
在 Windows 核心设备上，必须将 AWS IoT Greengrass 核心软件设置为系统服务。
要使用本地开发工具设置开发设备，请指定 `--deploy-dev-tools true` 参数。安装完成后，部署本地开发工具可能需要一分钟时间。
有关您可以指定的参数的更多信息，请参阅[安装程序参数](configure-installer.md)。
**注意**
如果您在内存有限的设备 AWS IoT Greengrass 上运行，则可以控制 AWS IoT Greengrass 酷睿软件使用的内存量。要控制内存分配，您可以在 Nucleus 组件的 `jvmOptions` 配置参数中设置 JVM 堆大小选项。有关更多信息，请参阅 [使用 JVM 选项控制内存分配](configure-greengrass-core-v2.md#jvm-tuning)。
**安装 AWS IoT Greengrass 核心软件**
1. 运行 AWS IoT Greengrass 核心安装程序。如下所示替换命令中的参数值。
**注意**
Windows 的路径长度限制为 260 个字符。如果您使用的是 Windows，请使用 `C:\greengrass\v2` 或 `D:\greengrass\v2` 等根文件夹，将 Greengrass 组件的路径保持在 260 个字符的限制以下。
1. `/greengrass/v2`或*C:\$1greengrass\$1v2*：用于安装 C AWS IoT Greengrass ore 软件的根文件夹的路径。
1. *GreengrassInstaller*。 您解压缩 AWS IoT Greengrass 核心软件安装程序的文件夹的路径。
1. *region*。 AWS 区域 在其中查找或创建资源。
1. *MyGreengrassCore*。 你的 Green AWS IoT grass 核心设备的名称。如果该事物不存在，安装程序会进行创建。安装程序下载证书以进行身份 AWS IoT 验证。有关更多信息，请参阅 [设备身份验证和授权 AWS IoT Greengrass](device-auth.md)。
**注意**
事物名称不得包含英文冒号 (`:`) 字符。
1. *MyGreengrassCoreGroup*。 你的 Greengrass 核心设备 AWS IoT 的事物组名称。如果该事物组不存在，安装程序会进行创建并向其中添加事物。如果事物组存在且有活动的部署，则核心设备将下载并运行部署指定的软件。
**注意**
事物组名称不得包含英文冒号 (`:`) 字符。
1. *GreengrassV2IoTThingPolicy*。 允许 Greengrass 核心设备与和通信的 AWS IoT 策略名称。 AWS IoT AWS IoT Greengrass如果该 AWS IoT 策略不存在，则安装程序会使用此名称创建允许 AWS IoT 策略。您可以根据自己的使用案例限制此策略的权限。有关更多信息，请参阅 [AWS IoT Greengrass V2 核心设备的最低 AWS IoT 政策](device-auth.md#greengrass-core-minimal-iot-policy)。
1. *GreengrassV2TokenExchangeRole*。 允许 Greengrass 核心设备获得临时证书的 IAM 角色的名称。 AWS 如果该角色不存在，则安装程序会创建该角色并附加名为 `GreengrassV2TokenExchangeRoleAccess` 的策略。有关更多信息，请参阅 [授权核心设备与 AWS 服务交互](device-service-role.md)。
1. *GreengrassCoreTokenExchangeRoleAlias*。 IAM 角色的别名，允许 Greengrass 核心设备稍后获得临时证书。如果该角色别名不存在，则安装程序会自行创建，并将其指向您指定的 IAM 角色。有关更多信息，请参阅 [授权核心设备与 AWS 服务交互](device-service-role.md)。
------
#### [ Linux or Unix ]
```
sudo -E java -Droot="/greengrass/v2" -Dlog.store=FILE \
-jar ./GreengrassInstaller/lib/Greengrass.jar \
--aws-region region \
--thing-name MyGreengrassCore \
--thing-group-name MyGreengrassCoreGroup \
--thing-policy-name GreengrassV2IoTThingPolicy \
--tes-role-name GreengrassV2TokenExchangeRole \
--tes-role-alias-name GreengrassCoreTokenExchangeRoleAlias \
--component-default-user ggc_user:ggc_group \
--provision true \
--setup-system-service true
```
------
#### [ Windows Command Prompt (CMD) ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" ^
-jar ./GreengrassInstaller/lib/Greengrass.jar ^
--aws-region region ^
--thing-name MyGreengrassCore ^
--thing-group-name MyGreengrassCoreGroup ^
--thing-policy-name GreengrassV2IoTThingPolicy ^
--tes-role-name GreengrassV2TokenExchangeRole ^
--tes-role-alias-name GreengrassCoreTokenExchangeRoleAlias ^
--component-default-user ggc_user ^
--provision true ^
--setup-system-service true
```
------
#### [ PowerShell ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" `
-jar ./GreengrassInstaller/lib/Greengrass.jar `
--aws-region region `
--thing-name MyGreengrassCore `
--thing-group-name MyGreengrassCoreGroup `
--thing-policy-name GreengrassV2IoTThingPolicy `
--tes-role-name GreengrassV2TokenExchangeRole `
--tes-role-alias-name GreengrassCoreTokenExchangeRoleAlias `
--component-default-user ggc_user `
--provision true `
--setup-system-service true
```
------
**重要**
在 Windows 核心设备上，`--setup-system-service true`必须指定将 AWS IoT Greengrass 核心软件设置为系统服务。
如果成功，安装程序会打印以下消息：
+ 如果您指定 `--provision`，则安装程序将在成功配置资源后打印 `Successfully configured Nucleus with provisioned resource details`。
+ 如果您指定 `--deploy-dev-tools`，则安装程序将在成功创建部署后打印 `Configured Nucleus to deploy aws.greengrass.Cli component`。
+ 如果您指定 `--setup-system-service true`，则安装程序会在将软件设置为服务并运行后打印 `Successfully set up Nucleus as a system service`。
+ 如果您未指定 `--setup-system-service true`，则安装程序会在成功安装并运行软件后打印 `Launched Nucleus successfully`。
1. 如果您安装了 [Greengrass Nucleus](greengrass-nucleus-component.md) v2.0.4 或更高版本，请跳过此步骤。如果您下载的是最新版本的软件，则说明您安装了 v2.0.4 或更高版本。
运行以下命令为 AWS IoT Greengrass 核心软件根文件夹设置所需的文件权限。`/greengrass/v2`替换为您在安装命令中指定的根文件夹，并*/greengrass*替换为根文件夹的父文件夹。
```
sudo chmod 755 /greengrass/v2 && sudo chmod 755 /greengrass
```
如果您将 AWS IoT Greengrass Core 软件作为系统服务安装，则安装程序会为您运行该软件。否则，您必须手动运行该软件。有关更多信息，请参阅 [运行 AWS IoT Greengrass 核心软件](run-greengrass-core-v2.md)。
**注意**
默认情况下，安装程序创建的 IAM 角色不允许访问 S3 存储桶中的组件构件。要在 Amazon S3 中部署可定义构件的自定义组件，您必须为该角色添加权限以允许核心设备检索组件构件。有关更多信息，请参阅 [允许访问 S3 存储桶中的组件构件](device-service-role.md#device-service-role-access-s3-bucket)。
如果您还没有适用于组件构件的 S3 存储桶，则可以在创建存储桶后添加这些权限。
**注意**
当 C AWS IoT Greengrass ore 软件连接到云端时，您的设备将被识别为 Core 设备。
有关如何配置和使用软件的更多信息 AWS IoT Greengrass，请参阅以下内容：
+ [配置 AWS IoT Greengrass 核心软件](configure-greengrass-core-v2.md)
+ [开发 AWS IoT Greengrass 组件](develop-greengrass-components.md)
+ [将 AWS IoT Greengrass 组件部署到设备](manage-deployments.md)
+ [Greengrass 命令行界面](gg-cli.md)
# 使用手动资源配置来安装 AWS IoT Greengrass Core 软件
AWS IoT Greengrass 核心软件包括一个安装程序，可将您的设备设置为 Greengrass 核心设备。要手动设置设备，您可以创建设备要使用的必需资源 AWS IoT 和 IAM 资源。如果您手动创建这些资源，则无需向安装程序提供 AWS 凭据。
手动安装 AWS IoT Greengrass Core 软件时，也可以将设备配置为使用网络代理或通过端口 443 AWS 进行连接。例如，如果您的设备在防火墙或网络代理后方运行，则可能需要指定这些配置选项。有关更多信息，请参阅 [通过端口 443 或网络代理进行连接](configure-greengrass-core-v2.md#configure-alpn-network-proxy)。
您也可以通过 [PKCS \$111](https://en.wikipedia.org/wiki/PKCS_11) 接口将 AWS IoT Greengrass 核心软件配置为使用硬件安全模块 (HSM)。此功能使您能够安全地存储私有密钥和证书文件，避免其在软件中暴露或重复。您可以将私有密钥和证书存储在 HSM 或可信平台模块（TPM）等硬件模块上或其他加密元素中。此功能仅在 Linux 设备上可用。有关硬件安全性及其使用要求的更多信息，请参阅 [硬件安全性集成](hardware-security.md)。
**重要**
在下载 AWS IoT Greengrass 酷睿软件之前，请检查您的核心设备是否满足安装和运行 AWS IoT Greengrass 酷睿软件 v2.0 的[要求](greengrass-nucleus-component.md#greengrass-v2-requirements)。
**Topics**
+ [检索 AWS IoT 端点](#retrieve-iot-endpoints)
+ [创建 AWS IoT 事物](#create-iot-thing)
+ [创建事物证书](#create-thing-certificate)
+ [配置事物证书](#configure-thing-certificate)
+ [创建令牌交换角色](#create-token-exchange-role)
+ [将证书下载到设备](#download-thing-certificates)
+ [设置设备环境](#set-up-device-environment)
+ [下载 AWS IoT Greengrass 核心软件](#download-greengrass-core-v2)
+ [安装 AWS IoT Greengrass 核心软件](#run-greengrass-core-v2-installer-manual)
## 检索 AWS IoT 端点
获取您的终 AWS IoT 端节点 AWS 账户，然后将其保存以备后用。您的设备使用这些端点来连接 AWS IoT。执行以下操作：
1. 获取您的 AWS IoT 数据端点 AWS 账户。
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS
```
如果请求成功，响应类似如下示例。
```
{
"endpointAddress": "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
}
```
1. 获取您的 AWS IoT 凭证端点 AWS 账户。
```
aws iot describe-endpoint --endpoint-type iot:CredentialProvider
```
如果请求成功，响应类似如下示例。
```
{
"endpointAddress": "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
}
```
## 创建 AWS IoT 事物
AWS IoT *事物*代表连接到的设备和逻辑实体 AWS IoT。Greengrass 的核心设备就是东西。 AWS IoT 当您将设备注册为 AWS IoT 事物时，该设备可以使用数字证书进行身份验证 AWS。
在本节中，您将创建一个代表您的设备的 AWS IoT 东西。
**创建 AWS IoT 事物**
1. 为你的设备创建 AWS IoT 一件东西。在开发计算机上运行以下命令。
+ *MyGreengrassCore*替换为要使用的事物名称。此名称也是您 Greengrass 核心设备的名称。
**注意**
事物名称不得包含英文冒号 (`:`) 字符。
```
aws iot create-thing --thing-name MyGreengrassCore
```
如果请求成功，响应类似如下示例。
```
{
"thingName": "MyGreengrassCore",
"thingArn": "arn:aws:iot:us-west-2:123456789012:thing/MyGreengrassCore",
"thingId": "8cb4b6cd-268e-495d-b5b9-1713d71dbf42"
}
```
1. （可选）将 AWS IoT 事物添加到新的或现有的事物组。您可以使用事物组来管理 Greengrass 核心设备实例集。将软件组件部署到设备时，可以以单个设备或设备组为目标。您可以将设备添加到有活动 Greengrass 部署的事物组，以将该事物组的软件组件部署到该设备。执行以下操作：
1. （可选）创建 AWS IoT 事物组。
+ *MyGreengrassCoreGroup*替换为要创建的事物组的名称。
**注意**
事物组名称不得包含英文冒号 (`:`) 字符。
```
aws iot create-thing-group --thing-group-name MyGreengrassCoreGroup
```
如果请求成功，响应类似如下示例。
```
{
"thingGroupName": "MyGreengrassCoreGroup",
"thingGroupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/MyGreengrassCoreGroup",
"thingGroupId": "4df721e1-ff9f-4f97-92dd-02db4e3f03aa"
}
```
1. 将 AWS IoT 事物添加到事物组。
+ *MyGreengrassCore*用你的 AWS IoT 东西的名字替换。
+ *MyGreengrassCoreGroup*替换为事物组的名称。
```
aws iot add-thing-to-thing-group --thing-name MyGreengrassCore --thing-group-name MyGreengrassCoreGroup
```
如果请求成功，则该命令没有任何输出。
## 创建事物证书
当您将设备注册为 AWS IoT 事物时，该设备可以使用数字证书进行身份验证 AWS。此证书允许设备与 AWS IoT 和通信 AWS IoT Greengrass。
在本节中，您将创建和下载可供您的设备连接 AWS的证书。
如果要将 AWS IoT Greengrass Core 软件配置为使用硬件安全模块 (HSM) 来安全存储私钥和证书，请按照步骤在 HSM 中使用私钥创建证书。否则，请按照步骤在 AWS IoT 服务中创建证书和私钥。硬件安全功能仅在 Linux 设备上可用。有关硬件安全性及其使用要求的更多信息，请参阅 [硬件安全性集成](hardware-security.md)。
### 在 AWS IoT 服务中创建证书和私钥
**创建事物证书**
1. 创建一个文件夹，用于下载 AWS IoT 事物的证书。
```
mkdir greengrass-v2-certs
```
1. 为该 AWS IoT 事物创建并下载证书。
```
aws iot create-keys-and-certificate --set-as-active --certificate-pem-outfile greengrass-v2-certs/device.pem.crt --public-key-outfile greengrass-v2-certs/public.pem.key --private-key-outfile greengrass-v2-certs/private.pem.key
```
如果请求成功，响应类似如下示例。
```
{
"certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
"certificateId": "aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
"certificatePem": "-----BEGIN CERTIFICATE-----
MIICiTCCAfICCQD6m7oRw0uXOjANBgkqhkiG9w
0BAQUFADCBiDELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZ
WF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIw
EAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5
jb20wHhcNMTEwNDI1MjA0NTIxWhcNMTIwNDI0MjA0NTIxWjCBiDELMAkGA1UEBh
MCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBb
WF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMx
HzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5jb20wgZ8wDQYJKoZIhvcNAQE
BBQADgY0AMIGJAoGBAMaK0dn+a4GmWIWJ21uUSfwfEvySWtC2XADZ4nB+BLYgVI
k60CpiwsZ3G93vUEIO3IyNoH/f0wYK8m9TrDHudUZg3qX4waLG5M43q7Wgc/MbQ
ITxOUSQv7c7ugFFDzQGBzZswY6786m86gpEIbb3OhjZnzcvQAaRHhdlQWIMm2nr
AgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAtCu4nUhVVxYUntneD9+h8Mg9q6q+auN
KyExzyLwaxlAoo7TJHidbtS4J5iNmZgXL0FkbFFBjvSfpJIlJ00zbhNYS5f6Guo
EDmFJl0ZxBHjJnyp378OD8uTs7fLvjx79LjSTbNYiytVbZPQUQ5Yaxu2jXnimvw
3rrszlaEXAMPLE=
-----END CERTIFICATE-----",
"keyPair": {
"PublicKey": "-----BEGIN PUBLIC KEY-----\
MIIBIjANBgkqhkEXAMPLEQEFAAOCAQ8AMIIBCgKCAQEAEXAMPLE1nnyJwKSMHw4h\
MMEXAMPLEuuN/dMAS3fyce8DW/4+EXAMPLEyjmoF/YVF/gHr99VEEXAMPLE5VF13\
59VK7cEXAMPLE67GK+y+jikqXOgHh/xJTwo+sGpWEXAMPLEDz18xOd2ka4tCzuWEXAMPLEahJbYkCPUBSU8opVkR7qkEXAMPLE1DR6sx2HocliOOLtu6Fkw91swQWEXAMPLE\\GB3ZPrNh0PzQYvjUStZeccyNCx2EXAMPLEvp9mQOUXP6plfgxwKRX2fEXAMPLEDa\
hJLXkX3rHU2xbxJSq7D+XEXAMPLEcw+LyFhI5mgFRl88eGdsAEXAMPLElnI9EesG\
FQIDAQAB\
-----END PUBLIC KEY-----\
",
"PrivateKey": "-----BEGIN RSA PRIVATE KEY-----\
key omitted for security reasons\
-----END RSA PRIVATE KEY-----\
"
}
}
```
保存证书的 Amazon 资源名称（ARN），以便稍后用于配置证书。
### 使用 HSM 中的私有密钥创建证书
**注意**
[此功能适用于 Greengrass nucleus 组件的 2.5.3 及更高版本。](greengrass-nucleus-component.md) AWS IoT Greengrass 目前不支持在 Windows 核心设备上使用此功能。
**创建事物证书**
1. 在核心设备上，在 HSM 中初始化 PKCS\$111 令牌，然后生成私有密钥。私有密钥必须是密钥大小为 RSA-2048（或更大）的 RSA 密钥，或 ECC 密钥。
**注意**
要使用带 ECC 密钥的硬件安全模块，必须使用 [Greengrass Nucleus](greengrass-nucleus-component.md) v2.5.6 或更高版本。
要使用硬件安全模块和[密钥管理器](secret-manager-component.md)，必须使用带 RSA 密钥的硬件安全模块。
查看 HSM 的文档，了解如何初始化令牌并生成私有密钥。如果您的 HSM 支持对象 IDs，请在生成私钥时指定对象 ID。保存您在初始化令牌并生成私有密钥时指定的槽位 ID、用户 PIN、对象标签、对象 ID（如果您的 HSM 使用对象）。稍后将事物证书导入 HSM 并配置 C AWS IoT Greengrass ore 软件时，您将使用这些值。
1. 使用私钥创建证书签名请求 (CSR)。 AWS IoT 使用此 CSR 为您在 HSM 中生成的私钥创建事物证书。有关如何通过私有密钥创建 CSR 的信息，请参阅适用于您 HSM 的文档。CSR 是一个文件，例如 `iotdevicekey.csr`。
1. 将 CSR 从设备复制到您的开发计算机。如果在开发计算机和设备上启用了 SSH 和 SCP，则可以在开发计算机上使用 `scp` 命令传输 CSR。*device-ip-address*替换为设备的 IP 地址，然后*\$1/iotdevicekey.csr*替换为设备上 CSR 文件的路径。
```
scp device-ip-address:~/iotdevicekey.csr iotdevicekey.csr
```
1. 在开发计算机上，创建一个文件夹，用于下载该 AWS IoT 事物的证书。
```
mkdir greengrass-v2-certs
```
1. 使用 CSR 文件创建 AWS IoT 事物的证书并将其下载到您的开发计算机。
```
aws iot create-certificate-from-csr --set-as-active --certificate-signing-request=file://iotdevicekey.csr --certificate-pem-outfile greengrass-v2-certs/device.pem.crt
```
如果请求成功，响应类似如下示例。
```
{
"certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
"certificateId": "aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
"certificatePem": "-----BEGIN CERTIFICATE-----
MIICiTCCAfICCQD6m7oRw0uXOjANBgkqhkiG9w
0BAQUFADCBiDELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZ
WF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIw
EAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5
jb20wHhcNMTEwNDI1MjA0NTIxWhcNMTIwNDI0MjA0NTIxWjCBiDELMAkGA1UEBh
MCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBb
WF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMx
HzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5jb20wgZ8wDQYJKoZIhvcNAQE
BBQADgY0AMIGJAoGBAMaK0dn+a4GmWIWJ21uUSfwfEvySWtC2XADZ4nB+BLYgVI
k60CpiwsZ3G93vUEIO3IyNoH/f0wYK8m9TrDHudUZg3qX4waLG5M43q7Wgc/MbQ
ITxOUSQv7c7ugFFDzQGBzZswY6786m86gpEIbb3OhjZnzcvQAaRHhdlQWIMm2nr
AgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAtCu4nUhVVxYUntneD9+h8Mg9q6q+auN
KyExzyLwaxlAoo7TJHidbtS4J5iNmZgXL0FkbFFBjvSfpJIlJ00zbhNYS5f6Guo
EDmFJl0ZxBHjJnyp378OD8uTs7fLvjx79LjSTbNYiytVbZPQUQ5Yaxu2jXnimvw
3rrszlaEXAMPLE=
-----END CERTIFICATE-----"
}
```
保存证书的 ARN，以便稍后用于配置证书。
## 配置事物证书
将事物证书附加到您之前创建 AWS IoT 的事物，然后向证书添加 AWS IoT 策略以定义核心设备的 AWS IoT 权限。
**配置事物证书**
1. 将证书附加到 AWS IoT 事物上。
+ *MyGreengrassCore*用你的 AWS IoT 东西的名字替换。
+ 将证书 Amazon 资源名称（ARN）替换为您在上一步中创建的证书的 ARN。
```
aws iot attach-thing-principal --thing-name MyGreengrassCore --principal arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4
```
如果请求成功，则该命令没有任何输出。
1. 创建并附加用于定义 Greengrass 核心设备 AWS IoT 权限的 AWS IoT 策略。以下策略允许访问所有 MQTT 主题和 Greengrass 操作，因此您的设备可以处理需要新 Greengrass 操作的自定义应用程序和未来更改。您可以根据自己的使用案例来限制此策略。有关更多信息，请参阅 [AWS IoT Greengrass V2 核心设备的最低 AWS IoT 政策](device-auth.md#greengrass-core-minimal-iot-policy)。
如果您之前设置过 Greengrass 核心设备，则可以附加 AWS IoT 其策略，而不必创建新的策略。
执行以下操作：
1. 创建一个包含 Greengrass 核心设备所需的 AWS IoT 策略文档的文件。
例如，在基于 Linux 的系统上，您可以运行以下命令来使用 GNU nano 创建该文件。
```
nano greengrass-v2-iot-policy.json
```
将以下 JSON 复制到该文件中。
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Publish",
"iot:Subscribe",
"iot:Receive",
"iot:Connect",
"greengrass:*"
],
"Resource": [
"*"
]
}
]
}
```
1. 根据 AWS IoT 策略文档创建策略。
+ *GreengrassV2IoTThingPolicy*替换为要创建的策略的名称。
```
aws iot create-policy --policy-name GreengrassV2IoTThingPolicy --policy-document file://greengrass-v2-iot-policy.json
```
如果请求成功，响应类似如下示例。
```
{
"policyName": "GreengrassV2IoTThingPolicy",
"policyArn": "arn:aws:iot:us-west-2:123456789012:policy/GreengrassV2IoTThingPolicy",
"policyDocument": "{
\\"Version\\": \\"2012-10-17 \\",
\\"Statement\\": [
{
\\"Effect\\": \\"Allow\\",
\\"Action\\": [
\\"iot:Publish\\",
\\"iot:Subscribe\\",
\\"iot:Receive\\",
\\"iot:Connect\\",
\\"greengrass:*\\"
],
\\"Resource\\": [
\\"*\\"
]
}
]
}",
"policyVersionId": "1"
}
```
1. 将 AWS IoT 策略附加到 AWS IoT 事物的证书上。
+ *GreengrassV2IoTThingPolicy*替换为要附加的策略的名称。
+ 将目标 ARN 替换为您的 AWS IoT 事物证书的 ARN。
```
aws iot attach-policy --policy-name GreengrassV2IoTThingPolicy --target arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4
```
如果请求成功，则该命令没有任何输出。
## 创建令牌交换角色
Greengrass 核心设备使用 IAM 服务角色（称为*令牌交换角色）来授权对*服务的调用。 AWS 设备使用 AWS IoT 证书提供程序来获取此角色的临时 AWS 证书，从而允许设备与 Amazon Logs 进行交互 AWS IoT、向 Amazon Logs 发送 CloudWatch 日志以及从 Amazon S3 下载自定义组件项目。有关更多信息，请参阅 [授权核心设备与 AWS 服务交互](device-service-role.md)。
您可以使用 AWS IoT *角色别名*为 Greengrass 核心设备配置令牌交换角色。角色别名允许您更改设备的令牌交换角色，但设备配置保持不变。有关更多信息，请参阅《AWS IoT Core 开发人员指南》**中的[授权直接调用 AWS 服务](https://docs.aws.amazon.com/iot/latest/developerguide/authorizing-direct-aws.html)。
在本节中，您将创建一个令牌交换 IAM 角色和一个指向该 AWS IoT 角色的角色别名。如果您已经设置了 Greengrass 核心设备，则可以使用其令牌交换角色和角色别名，而不必新建。然后，您将设备的 AWS IoT 事物配置为使用该角色和别名。
**创建令牌交换 IAM 角色**
1. 创建设备可将其用作令牌交换角色的 IAM 角色。执行以下操作：
1. 创建包含令牌交换角色所需的信任策略文档的文件。
例如，在基于 Linux 的系统上，您可以运行以下命令来使用 GNU nano 创建该文件。
```
nano device-role-trust-policy.json
```
将以下 JSON 复制到该文件中。
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
1. 通过信任策略文档创建令牌交换角色。
+ *GreengrassV2TokenExchangeRole*替换为要创建的 IAM 角色的名称。
```
aws iam create-role --role-name GreengrassV2TokenExchangeRole --assume-role-policy-document file://device-role-trust-policy.json
```
如果请求成功，响应类似如下示例。
```
{
"Role": {
"Path": "/",
"RoleName": "GreengrassV2TokenExchangeRole",
"RoleId": "AROAZ2YMUHYHK5OKM77FB",
"Arn": "arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole",
"CreateDate": "2021-02-06T00:13:29+00:00",
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
}
```
1. 创建一个包含令牌交换角色所需的访问策略文档的文件。
例如，在基于 Linux 的系统上，您可以运行以下命令来使用 GNU nano 创建该文件。
```
nano device-role-access-policy.json
```
将以下 JSON 复制到该文件中。
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents",
"logs:DescribeLogStreams",
"s3:GetBucketLocation"
],
"Resource": "*"
}
]
}
```
**注意**
此访问策略不允许访问 S3 存储桶中的组件构件。要在 Amazon S3 中部署可定义构件的自定义组件，您必须为该角色添加权限以允许核心设备检索组件构件。有关更多信息，请参阅 [允许访问 S3 存储桶中的组件构件](device-service-role.md#device-service-role-access-s3-bucket)。
如果您还没有适用于组件构件的 S3 存储桶，则可以在创建存储桶后添加这些权限。
1. 通过策略文档创建 IAM 策略
+ *GreengrassV2TokenExchangeRoleAccess*替换为要创建的 IAM 策略的名称。
```
aws iam create-policy --policy-name GreengrassV2TokenExchangeRoleAccess --policy-document file://device-role-access-policy.json
```
如果请求成功，响应类似如下示例。
```
{
"Policy": {
"PolicyName": "GreengrassV2TokenExchangeRoleAccess",
"PolicyId": "ANPAZ2YMUHYHACI7C5Z66",
"Arn": "arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess",
"Path": "/",
"DefaultVersionId": "v1",
"AttachmentCount": 0,
"PermissionsBoundaryUsageCount": 0,
"IsAttachable": true,
"CreateDate": "2021-02-06T00:37:17+00:00",
"UpdateDate": "2021-02-06T00:37:17+00:00"
}
}
```
1. 将 IAM 策略附加到令牌交换角色。
+ 将 *GreengrassV2TokenExchangeRole* 替换为 IAM 角色的名称。
+ 将策略 ARN 替换为您在上一步中创建的 IAM 策略的 ARN。
```
aws iam attach-role-policy --role-name GreengrassV2TokenExchangeRole --policy-arn arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess
```
如果请求成功，则该命令没有任何输出。
1. 创建 AWS IoT 指向代币交换角色的角色别名。
+ *GreengrassCoreTokenExchangeRoleAlias*替换为要创建的角色别名的名称。
+ 将角色 ARN 替换为您在上一步中创建的 IAM 角色的 ARN。
```
aws iot create-role-alias --role-alias GreengrassCoreTokenExchangeRoleAlias --role-arn arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole
```
如果请求成功，响应类似如下示例。
```
{
"roleAlias": "GreengrassCoreTokenExchangeRoleAlias",
"roleAliasArn": "arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
```
**注意**
要创建角色别名，您必须有权将令牌交换 IAM 角色传递到 AWS IoT。如果您在尝试创建角色别名时收到错误消息，请检查您的 AWS 用户是否具有此权限。有关更多信息，请参阅[《用户*指南》中的授予AWS Identity and Access Management 用户*向 AWS 服务传递角色的权限](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_passrole.html)。
1. 创建并附加 AWS IoT 允许您的 Greengrass 核心设备使用角色别名担任令牌交换角色的策略。如果您之前设置过 Greengrass 核心设备，则可以附加其角色 AWS IoT 别名策略，而不必创建新的角色别名策略。执行以下操作：
1. （可选）创建一个包含角色别名所需的 AWS IoT 策略文档的文件。
例如，在基于 Linux 的系统上，您可以运行以下命令来使用 GNU nano 创建该文件。
```
nano greengrass-v2-iot-role-alias-policy.json
```
将以下 JSON 复制到该文件中。
+ 将资源 ARN 替换为您角色别名的 ARN。
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iot:AssumeRoleWithCertificate",
"Resource": "arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
]
}
```
1. 根据 AWS IoT 策略文档创建策略。
+ *GreengrassCoreTokenExchangeRoleAliasPolicy*替换为要创建的 AWS IoT 策略的名称。
```
aws iot create-policy --policy-name GreengrassCoreTokenExchangeRoleAliasPolicy --policy-document file://greengrass-v2-iot-role-alias-policy.json
```
如果请求成功，响应类似如下示例。
```
{
"policyName": "GreengrassCoreTokenExchangeRoleAliasPolicy",
"policyArn": "arn:aws:iot:us-west-2:123456789012:policy/GreengrassCoreTokenExchangeRoleAliasPolicy",
"policyDocument": "{
\\"Version\\":\\"2012-10-17 \\",
\\"Statement\\": [
{
\\"Effect\\": \\"Allow\\",
\\"Action\\": \\"iot:AssumeRoleWithCertificate\\",
\\"Resource\\": \\"arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias\\"
}
]
}",
"policyVersionId": "1"
}
```
1. 将 AWS IoT 策略附加到 AWS IoT 事物的证书上。
+ *GreengrassCoreTokenExchangeRoleAliasPolicy*替换为角色别名 AWS IoT 策略的名称。
+ 将目标 ARN 替换为您的 AWS IoT 事物证书的 ARN。
```
aws iot attach-policy --policy-name GreengrassCoreTokenExchangeRoleAliasPolicy --target arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4
```
如果请求成功，则该命令没有任何输出。
## 将证书下载到设备
之前，您已将设备的证书下载到开发计算机上。在本节中，您需将证书复制到核心设备，以便为设备设置用于连接 AWS IoT的证书。您还需下载 Amazon 根证书颁发机构（CA）证书。如果您使用 HSM，在本节中，您还需将证书文件导入 HSM。
+ 如果您之前在 AWS IoT 服务中创建了事物证书和私钥，请按照步骤下载带有私钥和证书文件的证书。
+ 如果您之前在硬件安全模块（HSM）中通过私有密钥创建了事物证书，请按照步骤下载带私有密钥的证书和 HSM 中的证书。
### 下载带私有密钥的证书和证书文件
**将证书下载到设备**
1. 将 AWS IoT 事物证书从开发计算机复制到设备。如果在开发计算机和设备上启用了 SSH 和 SCP，则可以在开发计算机上使用 `scp` 命令传输证书。*device-ip-address*替换为设备的 IP 地址。
```
scp -r greengrass-v2-certs/ device-ip-address:~
```
1. 在设备上创建 Greengrass 根文件夹。稍后，您将将 AWS IoT Greengrass Core 软件安装到此文件夹。
**注意**
Windows 的路径长度限制为 260 个字符。如果您使用的是 Windows，请使用 `C:\greengrass\v2` 或 `D:\greengrass\v2` 等根文件夹，将 Greengrass 组件的路径保持在 260 个字符的限制以下。
------
#### [ Linux or Unix ]
+ 将 `/greengrass/v2` 替换为要使用的文件夹。
```
sudo mkdir -p /greengrass/v2
```
------
#### [ Windows Command Prompt ]
+ 将 *C:\$1greengrass\$1v2* 替换为要使用的文件夹。
```
mkdir C:\greengrass\v2
```
------
#### [ PowerShell ]
+ 将 *C:\$1greengrass\$1v2* 替换为要使用的文件夹。
```
mkdir C:\greengrass\v2
```
------
1. （仅限 Linux）设置 Greengrass 根文件夹的父文件夹的权限。
+ */greengrass*替换为根文件夹的父文件夹。
```
sudo chmod 755 /greengrass
```
1. 将 AWS IoT 事物证书复制到 Greengrass 根文件夹。
------
#### [ Linux or Unix ]
+ 将 `/greengrass/v2` 替换为 Greengrass 根文件夹。
```
sudo cp -R ~/greengrass-v2-certs/* /greengrass/v2
```
------
#### [ Windows Command Prompt ]
+ 将 *C:\$1greengrass\$1v2* 替换为要使用的文件夹。
```
robocopy %USERPROFILE%\greengrass-v2-certs C:\greengrass\v2 /E
```
------
#### [ PowerShell ]
+ 将 *C:\$1greengrass\$1v2* 替换为要使用的文件夹。
```
cp -Path ~\greengrass-v2-certs\* -Destination C:\greengrass\v2
```
------
1. 下载 Amazon 根证书颁发机构 (CA) 证书。 AWS IoT 默认情况下，证书与亚马逊的根 CA 证书相关联。
------
#### [ Linux or Unix ]
```
sudo curl -o /greengrass/v2/AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -o C:\greengrass\v2\\AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ PowerShell ]
```
iwr -Uri https://www.amazontrust.com/repository/AmazonRootCA1.pem -OutFile C:\greengrass\v2\\AmazonRootCA1.pem
```
------
### 下载带私有密钥的证书和 HSM 中的证书
**注意**
[此功能适用于 Greengrass nucleus 组件的 2.5.3 及更高版本。](greengrass-nucleus-component.md) AWS IoT Greengrass 目前不支持在 Windows 核心设备上使用此功能。
**将证书下载到设备**
1. 将 AWS IoT 事物证书从开发计算机复制到设备。如果在开发计算机和设备上启用了 SSH 和 SCP，则可以在开发计算机上使用 `scp` 命令传输证书。*device-ip-address*替换为设备的 IP 地址。
```
scp -r greengrass-v2-certs/ device-ip-address:~
```
1. 在设备上创建 Greengrass 根文件夹。稍后，您将将 AWS IoT Greengrass Core 软件安装到此文件夹。
**注意**
Windows 的路径长度限制为 260 个字符。如果您使用的是 Windows，请使用 `C:\greengrass\v2` 或 `D:\greengrass\v2` 等根文件夹，将 Greengrass 组件的路径保持在 260 个字符的限制以下。
------
#### [ Linux or Unix ]
+ 将 `/greengrass/v2` 替换为要使用的文件夹。
```
sudo mkdir -p /greengrass/v2
```
------
#### [ Windows Command Prompt ]
+ 将 *C:\$1greengrass\$1v2* 替换为要使用的文件夹。
```
mkdir C:\greengrass\v2
```
------
#### [ PowerShell ]
+ 将 *C:\$1greengrass\$1v2* 替换为要使用的文件夹。
```
mkdir C:\greengrass\v2
```
------
1. （仅限 Linux）设置 Greengrass 根文件夹的父文件夹的权限。
+ */greengrass*替换为根文件夹的父文件夹。
```
sudo chmod 755 /greengrass
```
1. 将事物证书文件 `~/greengrass-v2-certs/device.pem.crt` 导入 HSM。查看 HSM 文档，了解如何将证书导入其中。使用之前在 HSM 中生成私有密钥时使用的令牌、槽位 ID、用户 PIN、对象标签和对象 ID（如果您的 HSM 使用）导入证书。
**注意**
如果您之前未使用对象 ID 生成私有密钥，并且证书具有对象 ID，请将私有密钥的对象 ID 设置为与证书相同的值。查看 HSM 文档，了解如何为私有密钥对象设置对象 ID。
1. （可选）删除事物证书文件，使其仅在 HSM 中存在。
```
rm ~/greengrass-v2-certs/device.pem.crt
```
1. 下载 Amazon 根证书颁发机构 (CA) 证书。 AWS IoT 默认情况下，证书与亚马逊的根 CA 证书相关联。
------
#### [ Linux or Unix ]
```
sudo curl -o /greengrass/v2/AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -o C:\greengrass\v2\\AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ PowerShell ]
```
iwr -Uri https://www.amazontrust.com/repository/AmazonRootCA1.pem -OutFile C:\greengrass\v2\\AmazonRootCA1.pem
```
------
## 设置设备环境
按照本节中的步骤，将 Linux 或 Windows 设备设置为您的 AWS IoT Greengrass 核心设备。
### 设置 Linux 设备
**设置 Linux 设备用于 AWS IoT Greengrass V2**
1. 安装 Java 运行时， AWS IoT Greengrass 核心软件需要运行该运行时。我们建议您使用 [Amazon Corretto](https://aws.amazon.com/corretto/) 或 [OpenJDK](https://openjdk.java.net/) 长期支持版本。需要版本 8 或更高版本。以下命令向您展示如何在您的设备上安装 OpenJDK。
+ 对于基于 Debian 或基于 Ubuntua 的发行版：
```
sudo apt install default-jdk
```
+ 对于基于 Red Hat 的发行版：
```
sudo yum install java-11-openjdk-devel
```
+ 对于 Amazon Linux 2：
```
sudo amazon-linux-extras install java-openjdk11
```
+ 对于 Amazon Linux 2023：
```
sudo dnf install java-11-amazon-corretto -y
```
安装完成后，运行以下命令以验证 Java 是否在您的 Linux 设备上运行。
```
java -version
```
此命令会打印设备上运行的 Java 版本。例如，在基于 Debian 的发行版上，输出可能与以下示例类似。
```
openjdk version "11.0.9.1" 2020-11-04
OpenJDK Runtime Environment (build 11.0.9.1+1-post-Debian-1deb10u2)
OpenJDK 64-Bit Server VM (build 11.0.9.1+1-post-Debian-1deb10u2, mixed mode)
```
1. （可选）创建在设备上运行组件的默认系统用户和组。您也可以选择让 AWS IoT Greengrass 核心软件安装程序在安装过程中使用安装程序参数创建此用户和组。`--component-default-user`有关更多信息，请参阅 [安装程序参数](configure-installer.md)。
```
sudo useradd --system --create-home ggc_user
sudo groupadd --system ggc_group
```
1. 验证运行 AWS IoT Greengrass Core 软件的用户（通常`root`）是否有权`sudo`与任何用户和任何组一起运行。
1. 运行以下命令以打开 `/etc/sudoers` 文件。
```
sudo visudo
```
1. 验证用户的权限是否如以下示例所示。
```
root ALL=(ALL:ALL) ALL
```
1. （可选）要[运行容器化 Lambda 函数](run-lambda-functions.md)，必须启用 [cgroups](https://en.wikipedia.org/wiki/Cgroups) v1，且必须启用并装载*内存*和*设备* cgroups。如果您不打算运行容器化 Lambda 函数，则可跳过此步骤。
要启用这些 cgroups 选项，请使用以下 Linux 内核参数启动设备。
```
cgroup_enable=memory cgroup_memory=1 systemd.unified_cgroup_hierarchy=0
```
有关查看和设置设备内核参数的信息，请参阅适用于您操作系统和启动加载程序的文档。按照说明永久设置内核参数。
1. 按照 [设备要求](greengrass-nucleus-component.md#greengrass-v2-requirements) 中的要求列表所示，在您的设备上安装所有其他必需的依赖关系。
### 设置 Windows 设备
**注意**
此功能适用于 [Greengrass Nucleus 组件](greengrass-nucleus-component.md) v2.5.0 及更高版本。
**要将 Windows 设备设置为 AWS IoT Greengrass V2**
1. 安装 Java 运行时， AWS IoT Greengrass 核心软件需要运行该运行时。我们建议您使用 [Amazon Corretto](https://aws.amazon.com/corretto/) 或 [OpenJDK](https://openjdk.java.net/) 长期支持版本。需要版本 8 或更高版本。
1. 检查在 [PATH](https://en.wikipedia.org/wiki/PATH_(variable)) 系统变量上是否有 Java 可用，如果没有，请进行添加。该 LocalSystem 帐户运行 AWS IoT Greengrass Core 软件，因此您必须将 Java 添加到 PATH 系统变量中，而不是用户的 PATH 用户变量。执行以下操作：
1. 按下 Windows 键打开开始菜单。
1. 键入 **environment variables** 以从开始菜单中搜索系统选项。
1. 在开始菜单搜索结果中，选择**编辑系统环境变量**，以打开**系统属性**窗口。
1. 选择**环境变量...**，打开**环境变量**窗口。
1. 在**系统变量**下，选择**路径**，然后选择**编辑**。在**编辑环境变量**窗口中，您可以分行查看每个路径。
1. 检查 Java 安装的 `bin` 文件夹的路径是否存在。路径可能与以下示例类似。
```
C:\\Program Files\\Amazon Corretto\\jdk11.0.13_8\\bin
```
1. 如果**路径**中缺少 Java 安装的 `bin` 文件夹，请选择**新建**，添加该文件夹，然后选择**确定**。
1. 以管理员身份打开 Windows 命令提示符 (`cmd.exe`)。
1. 在 Windows 设备上的 LocalSystem 帐户中创建默认用户。*password*替换为安全密码。
```
net user /add ggc_user password
```
**提示**
根据您的 Windows 配置，用户密码可能会设置为在将来某个日期过期。为确保您的 Greengrass 应用程序继续运行，请跟踪密码过期时间，并在密码过期之前对其进行更新。您还可以将用户的密码设置为永不过期。
要检查用户及其密码的过期时间，请运行以下命令。
```
net user ggc_user | findstr /C:expires
```
要将用户密码设置为永不过期，请运行以下命令。
```
wmic UserAccount where "Name='ggc_user'" set PasswordExpires=False
```
如果你使用的是[已弃用该`wmic`命令的](https://learn.microsoft.com/en-us/windows/win32/wmisdk/wmic) Windows 10 或更高版本，请运行以下 PowerShell 命令。
```
Get-CimInstance -Query "SELECT * from Win32_UserAccount WHERE name = 'ggc_user'" | Set-CimInstance -Property @{PasswordExpires="False"}
```
1. 从微软下载该[PsExec实用程序](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec)并将其安装到设备上。
1. 使用该 PsExec 实用程序将默认用户的用户名和密码存储在 LocalSystem 账户的凭据管理器实例中。*password*替换为您之前设置的用户密码。
```
psexec -s cmd /c cmdkey /generic:ggc_user /user:ggc_user /pass:password
```
如果系统打开 **PsExec License Agreement**，请选择 **Accept** 以同意许可并运行命令。
**注意**
在 Windows 设备上，该 LocalSystem 帐户运行 Greengrass 核心，您必须使用 PsExec 该实用程序在帐户中存储默认用户信息。 LocalSystem 使用凭据管理器应用程序将此信息存储在当前登录用户的 Windows 帐户中，而不是 LocalSystem 帐户中。
## 下载 AWS IoT Greengrass 核心软件
您可以从以下位置下载最新版本的 AWS IoT Greengrass Core 软件：
+ [https://d2s8p88vqu9w66.cloudfront。 net/releases/greengrass](https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip)-nucleus-latest.zip
**注意**
您可以从以下位置下载特定版本的 AWS IoT Greengrass Core 软件。*version*替换为要下载的版本。
```
https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-version.zip
```
**下载 AWS IoT Greengrass 核心软件**
1. 在您的核心设备上，将 AWS IoT Greengrass Core 软件下载到名为的文件中`greengrass-nucleus-latest.zip`。
------
#### [ Linux or Unix ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
iwr -Uri https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip -OutFile greengrass-nucleus-latest.zip
```
------
下载此软件即表示您同意[Greengrass Core 软件许可协议](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf)。
1. （可选）验证 Greengrass Nucleus 软件签名
**注意**
此功能适用于 Greengrass Nucleus 版本 2.9.5 及更高版本。
1. 使用以下命令验证您 Greengrass Nucleus 构件的签名：
------
#### [ Linux or Unix ]
```
jarsigner -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
根据您安装的 JDK 版本，文件名可能有所不同。将 *`jdk17.0.6_10`* 替换为您安装的 JDK 版本。
```
"C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe" -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
根据您安装的 JDK 版本，文件名可能有所不同。将 *`jdk17.0.6_10`* 替换为您安装的 JDK 版本。
```
'C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe' -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
1. `jarsigner` 调用会生成输出，指示验证结果。
1. 如果 Greengrass Nucleus ZIP 文件已签署，则输出将包含以下语句：
```
jar verified.
```
1. 如果 Greengrass Nucleus ZIP 文件未签署，则输出将包含以下语句：
```
jar is unsigned.
```
1. 如果您提供了 Jarsigner `-certs` 选项以及 `-verify` 和 `-verbose` 选项，则输出还将包含详细的签名者证书信息。
1. 将 AWS IoT Greengrass Core 软件解压缩到设备上的某个文件夹。*GreengrassInstaller*替换为要使用的文件夹。
------
#### [ Linux or Unix ]
```
unzip greengrass-nucleus-latest.zip -d GreengrassInstaller && rm greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
mkdir GreengrassInstaller && tar -xf greengrass-nucleus-latest.zip -C GreengrassInstaller && del greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
Expand-Archive -Path greengrass-nucleus-latest.zip -DestinationPath .\\GreengrassInstaller
rm greengrass-nucleus-latest.zip
```
------
1. （可选）运行以下命令以查看 AWS IoT Greengrass Core 软件的版本。
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
**重要**
如果您安装的版本早于 v2.4.0 的 Greengrass nucleus，则在安装 Core 软件后请勿删除此文件夹。 AWS IoT Greengrass C AWS IoT Greengrass ore 软件使用此文件夹中的文件运行。
如果您下载的是最新版本的软件，则需要安装 v2.4.0 或更高版本，并且可以在安装 C AWS IoT Greengrass ore 软件后删除此文件夹。
## 安装 AWS IoT Greengrass 核心软件
使用可指定以下操作的参数运行安装程序：
+ 从指定使用您之前创建的 AWS 资源和证书的部分配置文件进行安装。 AWS IoT Greengrass Core 软件使用配置文件来指定设备上每个 Greengrass 组件的配置。安装程序会根据您提供的部分配置文件创建完整的配置文件。
+ 指定使用 `ggc_user` 系统用户在核心设备上运行软件组件。在 Linux 设备上，此命令还指定使用 `ggc_group` 系统组，安装程序会为您创建系统用户和组。
+ 将 AWS IoT Greengrass Core 软件设置为启动时运行的系统服务。在 Linux 设备上，这需要 [Systemd](https://en.wikipedia.org/wiki/Systemd) 初始化系统。
**重要**
在 Windows 核心设备上，必须将 AWS IoT Greengrass 核心软件设置为系统服务。
有关您可以指定的参数的更多信息，请参阅[安装程序参数](configure-installer.md)。
**注意**
如果您在内存有限的设备 AWS IoT Greengrass 上运行，则可以控制 AWS IoT Greengrass 酷睿软件使用的内存量。要控制内存分配，您可以在 Nucleus 组件的 `jvmOptions` 配置参数中设置 JVM 堆大小选项。有关更多信息，请参阅 [使用 JVM 选项控制内存分配](configure-greengrass-core-v2.md#jvm-tuning)。
+ 如果您之前在 AWS IoT 服务中创建了事物证书和私钥，请按照步骤安装带有私钥和证书文件的 AWS IoT Greengrass 核心软件。
+ 如果您之前使用硬件安全模块 (HSM) 中的私钥创建了事物证书，请按照步骤在 HSM 中安装带有私钥和证书的 AWS IoT Greengrass Core 软件。
### 使用私钥和证书文件安装 C AWS IoT Greengrass ore 软件
**安装 AWS IoT Greengrass 核心软件**
1. 检查 AWS IoT Greengrass 核心软件的版本。
+ *GreengrassInstaller*替换为包含该软件的文件夹的路径。
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
1. 使用文本编辑器创建名为 `config.yaml` 的配置文件，以提供给安装程序。
例如，在基于 Linux 的系统上，您可以运行以下命令来使用 GNU nano 创建该文件。
```
nano GreengrassInstaller/config.yaml
```
将以下 YAML 内容复制到该文件中。此部分配置文件会指定系统参数和 Greengrass Nucleus 参数。
```
---
system:
certificateFilePath: "/greengrass/v2/device.pem.crt"
privateKeyPath: "/greengrass/v2/private.pem.key"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
rootpath: "/greengrass/v2"
thingName: "MyGreengrassCore"
services:
aws.greengrass.Nucleus:
componentType: "NUCLEUS"
version: "2.17.0"
configuration:
awsRegion: "us-west-2"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
```
然后执行以下操作：
+ 将每个 `/greengrass/v2` 实例替换为 Greengrass 根文件夹。
+ *MyGreengrassCore*替换为 AWS IoT 事物的名称。
+ *2.17.0*替换为 AWS IoT Greengrass 核心软件的版本。
+ *us-west-2*替换为您创建资源 AWS 区域 的位置。
+ *GreengrassCoreTokenExchangeRoleAlias*替换为令牌交换角色别名的名称。
+ `iotDataEndpoint`用您的 AWS IoT 数据端点替换。
+ 用您的`iotCredEndpoint` AWS IoT 凭证终端节点替换。
**注意**
在此配置文件中，您可以自定义其他 Nucleus 配置选项，例如要使用的端口和网络代理，如以下示例所示。有关更多信息，请参阅 [Greengrass Nucleus 配置](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration)。
```
---
system:
certificateFilePath: "/greengrass/v2/device.pem.crt"
privateKeyPath: "/greengrass/v2/private.pem.key"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
rootpath: "/greengrass/v2"
thingName: "MyGreengrassCore"
services:
aws.greengrass.Nucleus:
componentType: "NUCLEUS"
version: "2.17.0"
configuration:
awsRegion: "us-west-2"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
iotCredEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
mqtt:
port: 443
greengrassDataPlanePort: 443
networkProxy:
noProxyAddresses: "http://192.168.0.1,www.example.com"
proxy:
url: "https://my-proxy-server:1100"
username: "Mary_Major"
password: "pass@word1357"
```
1. 运行安装程序，并指定 `--init-config` 来提供配置文件。
+ 用 Greengrass 根文件夹替换`/greengrass/v2`或*C:\$1greengrass\$1v2*。
+ 将的*GreengrassInstaller*每个实例替换为解压安装程序所在的文件夹。
------
#### [ Linux or Unix ]
```
sudo -E java -Droot="/greengrass/v2" -Dlog.store=FILE \
-jar ./GreengrassInstaller/lib/Greengrass.jar \
--init-config ./GreengrassInstaller/config.yaml \
--component-default-user ggc_user:ggc_group \
--setup-system-service true
```
------
#### [ Windows Command Prompt (CMD) ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" ^
-jar ./GreengrassInstaller/lib/Greengrass.jar ^
--init-config ./GreengrassInstaller/config.yaml ^
--component-default-user ggc_user ^
--setup-system-service true
```
------
#### [ PowerShell ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" `
-jar ./GreengrassInstaller/lib/Greengrass.jar `
--init-config ./GreengrassInstaller/config.yaml `
--component-default-user ggc_user `
--setup-system-service true
```
------
**重要**
在 Windows 核心设备上，`--setup-system-service true`必须指定将 AWS IoT Greengrass 核心软件设置为系统服务。
如果指定 `--setup-system-service true`，则安装程序会在将软件设置为系统服务并运行后打印 `Successfully set up Nucleus as a system service`。否则，如果安装程序成功安装软件，则不会输出任何消息。
**注意**
在没有 `deploy-dev-tools` 参数的情况下运行安装程序时，您不能使用 `--provision true` 参数来部署本地开发工具。有关直接在您的设备上部署 Greengrass CLI 的信息，请参阅 [Greengrass 命令行界面](gg-cli.md)。
1. 通过查看根文件夹中的文件来验证安装情况。
------
#### [ Linux or Unix ]
```
ls /greengrass/v2
```
------
#### [ Windows Command Prompt (CMD) ]
```
dir C:\greengrass\v2
```
------
#### [ PowerShell ]
```
ls C:\greengrass\v2
```
------
如果安装成功，则根文件夹中包含多个文件夹，例如 `config`、`packages` 和 `logs`。
### 在 HSM 中安装带有私钥和证书的 C AWS IoT Greengrass ore 软件
**注意**
[此功能适用于 Greengrass nucleus 组件的 2.5.3 及更高版本。](greengrass-nucleus-component.md) AWS IoT Greengrass 目前不支持在 Windows 核心设备上使用此功能。
**安装 AWS IoT Greengrass 核心软件**
1. 检查 AWS IoT Greengrass 核心软件的版本。
+ *GreengrassInstaller*替换为包含该软件的文件夹的路径。
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
1. 要使 AWS IoT Greengrass 核心软件能够在 HSM 中使用私钥和证书，请在安装 C AWS IoT Greengrass ore 软件时安装 [PKCS \$111 提供程序组件](pkcs11-provider-component.md)。PKCS\$111 提供程序组件是一个可以在安装过程中配置的插件。您可以从以下位置下载最新版本的 PKCS\$111 提供程序组件：
+ [https://d2s8p88vqu9w66.cloudfront。 net/releases/Pkcs11Provider/aws.greengrass.crypto.pkcs11Provider-latest.jar](https://d2s8p88vqu9w66.cloudfront.net/releases/Pkcs11Provider/aws.greengrass.crypto.Pkcs11Provider-latest.jar)
将 PKCS\$111 提供程序插件下载到名为 `aws.greengrass.crypto.Pkcs11Provider.jar` 的文件中。*GreengrassInstaller*替换为要使用的文件夹。
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/Pkcs11Provider/aws.greengrass.crypto.Pkcs11Provider-latest.jar > GreengrassInstaller/aws.greengrass.crypto.Pkcs11Provider.jar
```
下载此软件即表示您同意[Greengrass Core 软件许可协议](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf)。
1. 使用文本编辑器创建名为 `config.yaml` 的配置文件，以提供给安装程序。
例如，在基于 Linux 的系统上，您可以运行以下命令来使用 GNU nano 创建该文件。
```
nano GreengrassInstaller/config.yaml
```
将以下 YAML 内容复制到该文件中。此部分配置文件会指定系统参数、Greengrass Nucleus 参数和 PKCS\$111 提供程序参数。
```
---
system:
certificateFilePath: "pkcs11:object=iotdevicekey;type=cert"
privateKeyPath: "pkcs11:object=iotdevicekey;type=private"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
rootpath: "/greengrass/v2"
thingName: "MyGreengrassCore"
services:
aws.greengrass.Nucleus:
componentType: "NUCLEUS"
version: "2.17.0"
configuration:
awsRegion: "us-west-2"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
aws.greengrass.crypto.Pkcs11Provider:
configuration:
name: "softhsm_pkcs11"
library: "/usr/local/Cellar/softhsm/2.6.1/lib/softhsm/libsofthsm2.so"
slot: 1
userPin: "1234"
```
然后执行以下操作：
+ 将 PKCS \$111 *iotdevicekey* URIs 中的每个实例替换为创建私钥并导入证书的对象标签。
+ 将每个 `/greengrass/v2` 实例替换为 Greengrass 根文件夹。
+ *MyGreengrassCore*替换为 AWS IoT 事物的名称。
+ *2.17.0*替换为 AWS IoT Greengrass 核心软件的版本。
+ *us-west-2*替换为您创建资源 AWS 区域 的位置。
+ *GreengrassCoreTokenExchangeRoleAlias*替换为令牌交换角色别名的名称。
+ `iotDataEndpoint`用您的 AWS IoT 数据端点替换。
+ 用您的`iotCredEndpoint` AWS IoT 凭证终端节点替换。
+ 将 `aws.greengrass.crypto.Pkcs11Provider` 组件的配置参数替换为核心设备上 HSM 配置的值。
**注意**
在此配置文件中，您可以自定义其他 Nucleus 配置选项，例如要使用的端口和网络代理，如以下示例所示。有关更多信息，请参阅 [Greengrass Nucleus 配置](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration)。
```
---
system:
certificateFilePath: "pkcs11:object=iotdevicekey;type=cert"
privateKeyPath: "pkcs11:object=iotdevicekey;type=private"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
rootpath: "/greengrass/v2"
thingName: "MyGreengrassCore"
services:
aws.greengrass.Nucleus:
componentType: "NUCLEUS"
version: "2.17.0"
configuration:
awsRegion: "us-west-2"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
mqtt:
port: 443
greengrassDataPlanePort: 443
networkProxy:
noProxyAddresses: "http://192.168.0.1,www.example.com"
proxy:
url: "https://my-proxy-server:1100"
username: "Mary_Major"
password: "pass@word1357"
aws.greengrass.crypto.Pkcs11Provider:
configuration:
name: "softhsm_pkcs11"
library: "/usr/local/Cellar/softhsm/2.6.1/lib/softhsm/libsofthsm2.so"
slot: 1
userPin: "1234"
```
1. 运行安装程序，并指定 `--init-config` 来提供配置文件。
+ 将 `/greengrass/v2` 替换为 Greengrass 根文件夹。
+ 将的*GreengrassInstaller*每个实例替换为解压安装程序所在的文件夹。
```
sudo -E java -Droot="/greengrass/v2" -Dlog.store=FILE \
-jar ./GreengrassInstaller/lib/Greengrass.jar \
--trusted-plugin ./GreengrassInstaller/aws.greengrass.crypto.Pkcs11Provider.jar \
--init-config ./GreengrassInstaller/config.yaml \
--component-default-user ggc_user:ggc_group \
--setup-system-service true
```
**重要**
在 Windows 核心设备上，`--setup-system-service true`必须指定将 AWS IoT Greengrass 核心软件设置为系统服务。
如果指定 `--setup-system-service true`，则安装程序会在将软件设置为系统服务并运行后打印 `Successfully set up Nucleus as a system service`。否则，如果安装程序成功安装软件，则不会输出任何消息。
**注意**
在没有 `deploy-dev-tools` 参数的情况下运行安装程序时，您不能使用 `--provision true` 参数来部署本地开发工具。有关直接在您的设备上部署 Greengrass CLI 的信息，请参阅 [Greengrass 命令行界面](gg-cli.md)。
1. 通过查看根文件夹中的文件来验证安装情况。
------
#### [ Linux or Unix ]
```
ls /greengrass/v2
```
------
#### [ Windows Command Prompt (CMD) ]
```
dir C:\greengrass\v2
```
------
#### [ PowerShell ]
```
ls C:\greengrass\v2
```
------
如果安装成功，则根文件夹中包含多个文件夹，例如 `config`、`packages` 和 `logs`。
如果您将 AWS IoT Greengrass Core 软件作为系统服务安装，则安装程序会为您运行该软件。否则，您必须手动运行该软件。有关更多信息，请参阅 [运行 AWS IoT Greengrass 核心软件](run-greengrass-core-v2.md)。
**注意**
当 C AWS IoT Greengrass ore 软件连接到云端时，您的设备将被识别为 Core 设备。
有关如何配置和使用软件的更多信息 AWS IoT Greengrass，请参阅以下内容：
+ [配置 AWS IoT Greengrass 核心软件](configure-greengrass-core-v2.md)
+ [开发 AWS IoT Greengrass 组件](develop-greengrass-components.md)
+ [将 AWS IoT Greengrass 组件部署到设备](manage-deployments.md)
+ [Greengrass 命令行界面](gg-cli.md)
# 安装具有 AWS IoT 队列配置功能的 C AWS IoT Greengrass ore 软件
此功能适用于 [Greengrass Nucleus 组件](greengrass-nucleus-component.md)的 v2.4.0 及更高版本。
借助 AWS IoT 队列配置，您可以配置 AWS IoT 为在设备首次连接时生成 X.509 设备证书和私钥并将其安全地交付 AWS IoT 给设备。 AWS IoT 提供由 Amazon 根证书颁发机构 (CA) 签署的客户证书。您还可以进行配置， AWS IoT 为使用队列配置配置的 Greengrass 核心设备指定事物组、事物类型和权限。您可以定义*配置模板*来定义如何配置 AWS IoT 每台设备。预置模板指定在预置时要为设备创建的事物、策略和证书资源。有关更多信息，请参阅《AWS IoT Core 开发人员指南》中的[预置模板](https://docs.aws.amazon.com/iot/latest/developerguide/provision-template.html)。**
AWS IoT Greengrass 提供了一个 AWS IoT 队列配置插件，您可以使用该插件使用 AWS IoT 队列配置创建的 AWS 资源来安装 AWS IoT Greengrass 核心软件。实例集预置插件使用*通过声明进行预置*。设备使用预置声明证书和私钥来获取可用于常规操作的唯一 X.509 设备证书和私钥。在制造过程中，您可以将声明证书和私钥嵌入每台设备，这样您的客户便可以在每台设备联机后激活设备。您可以为多台设备使用相同的声明证书和私钥。有关更多信息，请参阅《AWS IoT Core 开发人员指南》中的[通过声明进行预置](https://docs.aws.amazon.com/iot/latest/developerguide/provision-wo-cert.html#claim-based)。**
**注意**
[Greengrass](greengrass-nucleus-component.md) nucleus 的舰队配置插件目前不支持在硬件安全模块 (HSM) 中存储私钥和证书文件。要使用带有 [Greengrass nucleus 的 HSM，请使用手动配置](greengrass-nucleus-component.md)来安装 Core [软件](manual-installation.md)。 AWS IoT Greengrass [Greengrass nucleus](greengrass-nucleus-lite-component.md) lite v2.5.0 及更高版本支持 TPM，原生提供舰队配置。
要安装具有 AWS IoT 队列配置功能的 AWS IoT Greengrass Core 软件，您必须在中设置用于配置 Gre AWS IoT engrass 核心设备的资源。 AWS 账户 这些资源包括预置模板、声明证书和[令牌交换 IAM 角色](device-service-role.md)。创建这些资源后，您可以重复使用资源来预置实例集中的多个核心设备。有关更多信息，请参阅 [为 Greengrass 核心 AWS IoT 设备设置队列配置](fleet-provisioning-setup.md)。
**重要**
在下载 AWS IoT Greengrass 酷睿软件之前，请检查您的核心设备是否满足安装和运行 AWS IoT Greengrass 酷睿软件 v2.0 的[要求](greengrass-nucleus-component.md#greengrass-v2-requirements)。
**Topics**
+ [先决条件](#fleet-provisioning-prerequisites)
+ [检索 AWS IoT 端点](#retrieve-iot-endpoints)
+ [将证书下载到设备](#download-claim-certificates)
+ [设置设备环境](#set-up-device-environment)
+ [下载 AWS IoT Greengrass 核心软件](#download-greengrass-core-v2)
+ [下载 AWS IoT 舰队配置插件](#download-fleet-provisioning-plugin)
+ [安装 AWS IoT Greengrass 核心软件](#run-greengrass-core-v2-installer-fleet)
+ [为 Greengrass 核心 AWS IoT 设备设置队列配置](fleet-provisioning-setup.md)
+ [配置 AWS IoT 舰队配置插件](fleet-provisioning-configuration.md)
+ [AWS IoT 实例集预置插件更改日志](fleet-provisioning-changelog.md)
## 先决条件
要安装具有 AWS IoT 队列配置功能的 AWS IoT Greengrass Core 软件，必须先[为 Greengrass 核心 AWS IoT 设备设置队列配置](fleet-provisioning-setup.md)。完成这些步骤后，您可以使用队列配置在任意数量的设备上安装 AWS IoT Greengrass 核心软件。
## 检索 AWS IoT 端点
获取您的终 AWS IoT 端节点 AWS 账户，然后将其保存以备后用。您的设备使用这些端点来连接 AWS IoT。执行以下操作：
1. 获取您的 AWS IoT 数据端点 AWS 账户。
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS
```
如果请求成功，响应类似如下示例。
```
{
"endpointAddress": "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
}
```
1. 获取您的 AWS IoT 凭证终端节点 AWS 账户。
```
aws iot describe-endpoint --endpoint-type iot:CredentialProvider
```
如果请求成功，响应类似如下示例。
```
{
"endpointAddress": "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
}
```
## 将证书下载到设备
设备使用索赔证书和私钥来验证其 AWS 调配资源和获取 X.509 设备证书的请求。您可以在制造过程中将声明证书和私钥嵌入设备中，也可以在安装过程中将证书和密钥复制到设备。在本节中，您需将声明证书和私有密钥复制到设备。您还需将 Amazon 根证书颁发机构（CA）证书下载到设备。
**重要**
预置声明私钥应始终得到保护，包括在 Greengrass 核心设备上时。我们建议您使用 Amazon CloudWatch 指标和日志来监控是否存在滥用迹象，例如未经授权使用索赔证书来配置设备。如果您检测到滥用，请禁用预置声明证书，以使其不能用于设备预置。有关更多信息，请参阅 *AWS IoT Core 开发人员指南* 中的 [监控 AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/monitoring_overview.html)。
为了帮助您更好地管理自己在您的设备中注册的设备数量和设备 AWS 账户，您可以在创建队列配置模板时指定预配置挂钩。预配置挂钩是一种验证设备在注册期间提供的模板参数的 AWS Lambda 功能。例如，您可以创建一个预置前钩子，根据数据库检查设备 ID，以验证设备是否有权进行预置。有关更多信息，请参阅《AWS IoT Core 开发人员指南》中的[预置前钩子](https://docs.aws.amazon.com/iot/latest/developerguide/pre-provisioning-hook.html)。**
**将声明证书下载到设备**
1. 将声明证书和私钥复制到设备。如果在开发计算机和设备上启用了 SSH 和 SCP，则可以在开发计算机上使用 `scp` 命令传输声明证书和私钥。以下示例命令会将开发计算机上名为 `claim-certs` 的文件夹中的这些文件传输到设备。*device-ip-address*替换为设备的 IP 地址。
```
scp -r claim-certs/ device-ip-address:~
```
1. 在设备上创建 Greengrass 根文件夹。稍后，您将将 AWS IoT Greengrass Core 软件安装到此文件夹。
**注意**
Windows 的路径长度限制为 260 个字符。如果您使用的是 Windows，请使用 `C:\greengrass\v2` 或 `D:\greengrass\v2` 等根文件夹，将 Greengrass 组件的路径保持在 260 个字符的限制以下。
------
#### [ Linux or Unix ]
+ 将 `/greengrass/v2` 替换为要使用的文件夹。
```
sudo mkdir -p /greengrass/v2
```
------
#### [ Windows Command Prompt ]
+ 将 *C:\$1greengrass\$1v2* 替换为要使用的文件夹。
```
mkdir C:\greengrass\v2
```
------
#### [ PowerShell ]
+ 将 *C:\$1greengrass\$1v2* 替换为要使用的文件夹。
```
mkdir C:\greengrass\v2
```
------
1. （仅限 Linux）设置 Greengrass 根文件夹的父文件夹的权限。
+ */greengrass*替换为根文件夹的父文件夹。
```
sudo chmod 755 /greengrass
```
1. 将声明证书移动到 Greengrass 根文件夹。
+ 用 Greengrass 根文件夹替换`/greengrass/v2`或*C:\$1greengrass\$1v2*。
------
#### [ Linux or Unix ]
```
sudo mv ~/claim-certs /greengrass/v2
```
------
#### [ Windows Command Prompt (CMD) ]
```
move %USERPROFILE%\claim-certs C:\greengrass\v2
```
------
#### [ PowerShell ]
```
mv -Path ~\claim-certs -Destination C:\greengrass\v2
```
------
1. 下载 Amazon 根证书颁发机构 (CA) 证书。 AWS IoT 默认情况下，证书与亚马逊的根 CA 证书相关联。
------
#### [ Linux or Unix ]
```
sudo curl -o /greengrass/v2/AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -o C:\greengrass\v2\\AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ PowerShell ]
```
iwr -Uri https://www.amazontrust.com/repository/AmazonRootCA1.pem -OutFile C:\greengrass\v2\\AmazonRootCA1.pem
```
------
## 设置设备环境
按照本节中的步骤，将 Linux 或 Windows 设备设置为您的 AWS IoT Greengrass 核心设备。
### 设置 Linux 设备
**设置 Linux 设备用于 AWS IoT Greengrass V2**
1. 安装 Java 运行时， AWS IoT Greengrass 核心软件需要运行该运行时。我们建议您使用 [Amazon Corretto](https://aws.amazon.com/corretto/) 或 [OpenJDK](https://openjdk.java.net/) 长期支持版本。需要版本 8 或更高版本。以下命令向您展示如何在您的设备上安装 OpenJDK。
+ 对于基于 Debian 或基于 Ubuntua 的发行版：
```
sudo apt install default-jdk
```
+ 对于基于 Red Hat 的发行版：
```
sudo yum install java-11-openjdk-devel
```
+ 对于 Amazon Linux 2：
```
sudo amazon-linux-extras install java-openjdk11
```
+ 对于 Amazon Linux 2023：
```
sudo dnf install java-11-amazon-corretto -y
```
安装完成后，运行以下命令以验证 Java 是否在您的 Linux 设备上运行。
```
java -version
```
此命令会打印设备上运行的 Java 版本。例如，在基于 Debian 的发行版上，输出可能与以下示例类似。
```
openjdk version "11.0.9.1" 2020-11-04
OpenJDK Runtime Environment (build 11.0.9.1+1-post-Debian-1deb10u2)
OpenJDK 64-Bit Server VM (build 11.0.9.1+1-post-Debian-1deb10u2, mixed mode)
```
1. （可选）创建在设备上运行组件的默认系统用户和组。您也可以选择让 AWS IoT Greengrass 核心软件安装程序在安装过程中使用安装程序参数创建此用户和组。`--component-default-user`有关更多信息，请参阅 [安装程序参数](configure-installer.md)。
```
sudo useradd --system --create-home ggc_user
sudo groupadd --system ggc_group
```
1. 验证运行 AWS IoT Greengrass Core 软件的用户（通常`root`）是否有权`sudo`与任何用户和任何组一起运行。
1. 运行以下命令以打开 `/etc/sudoers` 文件。
```
sudo visudo
```
1. 验证用户的权限是否如以下示例所示。
```
root ALL=(ALL:ALL) ALL
```
1. （可选）要[运行容器化 Lambda 函数](run-lambda-functions.md)，必须启用 [cgroups](https://en.wikipedia.org/wiki/Cgroups) v1，且必须启用并装载*内存*和*设备* cgroups。如果您不打算运行容器化 Lambda 函数，则可跳过此步骤。
要启用这些 cgroups 选项，请使用以下 Linux 内核参数启动设备。
```
cgroup_enable=memory cgroup_memory=1 systemd.unified_cgroup_hierarchy=0
```
有关查看和设置设备内核参数的信息，请参阅适用于您操作系统和启动加载程序的文档。按照说明永久设置内核参数。
1. 按照 [设备要求](greengrass-nucleus-component.md#greengrass-v2-requirements) 中的要求列表所示，在您的设备上安装所有其他必需的依赖关系。
### 设置 Windows 设备
**注意**
此功能适用于 [Greengrass Nucleus 组件](greengrass-nucleus-component.md) v2.5.0 及更高版本。
**要将 Windows 设备设置为 AWS IoT Greengrass V2**
1. 安装 Java 运行时， AWS IoT Greengrass 核心软件需要运行该运行时。我们建议您使用 [Amazon Corretto](https://aws.amazon.com/corretto/) 或 [OpenJDK](https://openjdk.java.net/) 长期支持版本。需要版本 8 或更高版本。
1. 检查在 [PATH](https://en.wikipedia.org/wiki/PATH_(variable)) 系统变量上是否有 Java 可用，如果没有，请进行添加。该 LocalSystem 帐户运行 AWS IoT Greengrass Core 软件，因此您必须将 Java 添加到 PATH 系统变量中，而不是用户的 PATH 用户变量。执行以下操作：
1. 按下 Windows 键打开开始菜单。
1. 键入 **environment variables** 以从开始菜单中搜索系统选项。
1. 在开始菜单搜索结果中，选择**编辑系统环境变量**，以打开**系统属性**窗口。
1. 选择**环境变量...**，打开**环境变量**窗口。
1. 在**系统变量**下，选择**路径**，然后选择**编辑**。在**编辑环境变量**窗口中，您可以分行查看每个路径。
1. 检查 Java 安装的 `bin` 文件夹的路径是否存在。路径可能与以下示例类似。
```
C:\\Program Files\\Amazon Corretto\\jdk11.0.13_8\\bin
```
1. 如果**路径**中缺少 Java 安装的 `bin` 文件夹，请选择**新建**，添加该文件夹，然后选择**确定**。
1. 以管理员身份打开 Windows 命令提示符 (`cmd.exe`)。
1. 在 Windows 设备上的 LocalSystem 帐户中创建默认用户。*password*替换为安全密码。
```
net user /add ggc_user password
```
**提示**
根据您的 Windows 配置，用户密码可能会设置为在将来某个日期过期。为确保您的 Greengrass 应用程序继续运行，请跟踪密码过期时间，并在密码过期之前对其进行更新。您还可以将用户的密码设置为永不过期。
要检查用户及其密码的过期时间，请运行以下命令。
```
net user ggc_user | findstr /C:expires
```
要将用户密码设置为永不过期，请运行以下命令。
```
wmic UserAccount where "Name='ggc_user'" set PasswordExpires=False
```
如果你使用的是[已弃用该`wmic`命令的](https://learn.microsoft.com/en-us/windows/win32/wmisdk/wmic) Windows 10 或更高版本，请运行以下 PowerShell 命令。
```
Get-CimInstance -Query "SELECT * from Win32_UserAccount WHERE name = 'ggc_user'" | Set-CimInstance -Property @{PasswordExpires="False"}
```
1. 从微软下载该[PsExec实用程序](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec)并将其安装到设备上。
1. 使用该 PsExec 实用程序将默认用户的用户名和密码存储在 LocalSystem 账户的凭据管理器实例中。*password*替换为您之前设置的用户密码。
```
psexec -s cmd /c cmdkey /generic:ggc_user /user:ggc_user /pass:password
```
如果系统打开 **PsExec License Agreement**，请选择 **Accept** 以同意许可并运行命令。
**注意**
在 Windows 设备上，该 LocalSystem 帐户运行 Greengrass 核心，您必须使用 PsExec 该实用程序在帐户中存储默认用户信息。 LocalSystem 使用凭据管理器应用程序将此信息存储在当前登录用户的 Windows 帐户中，而不是 LocalSystem 帐户中。
## 下载 AWS IoT Greengrass 核心软件
您可以从以下位置下载最新版本的 AWS IoT Greengrass Core 软件：
+ [https://d2s8p88vqu9w66.cloudfront。 net/releases/greengrass](https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip)-nucleus-latest.zip
**注意**
您可以从以下位置下载特定版本的 AWS IoT Greengrass Core 软件。*version*替换为要下载的版本。
```
https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-version.zip
```
**下载 AWS IoT Greengrass 核心软件**
1. 在您的核心设备上，将 AWS IoT Greengrass Core 软件下载到名为的文件中`greengrass-nucleus-latest.zip`。
------
#### [ Linux or Unix ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
iwr -Uri https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip -OutFile greengrass-nucleus-latest.zip
```
------
下载此软件即表示您同意[Greengrass Core 软件许可协议](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf)。
1. （可选）验证 Greengrass Nucleus 软件签名
**注意**
此功能适用于 Greengrass Nucleus 版本 2.9.5 及更高版本。
1. 使用以下命令验证您 Greengrass Nucleus 构件的签名：
------
#### [ Linux or Unix ]
```
jarsigner -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
根据您安装的 JDK 版本，文件名可能有所不同。将 *`jdk17.0.6_10`* 替换为您安装的 JDK 版本。
```
"C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe" -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
根据您安装的 JDK 版本，文件名可能有所不同。将 *`jdk17.0.6_10`* 替换为您安装的 JDK 版本。
```
'C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe' -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
1. `jarsigner` 调用会生成输出，指示验证结果。
1. 如果 Greengrass Nucleus ZIP 文件已签署，则输出将包含以下语句：
```
jar verified.
```
1. 如果 Greengrass Nucleus ZIP 文件未签署，则输出将包含以下语句：
```
jar is unsigned.
```
1. 如果您提供了 Jarsigner `-certs` 选项以及 `-verify` 和 `-verbose` 选项，则输出还将包含详细的签名者证书信息。
1. 将 AWS IoT Greengrass Core 软件解压缩到设备上的某个文件夹。*GreengrassInstaller*替换为要使用的文件夹。
------
#### [ Linux or Unix ]
```
unzip greengrass-nucleus-latest.zip -d GreengrassInstaller && rm greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
mkdir GreengrassInstaller && tar -xf greengrass-nucleus-latest.zip -C GreengrassInstaller && del greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
Expand-Archive -Path greengrass-nucleus-latest.zip -DestinationPath .\\GreengrassInstaller
rm greengrass-nucleus-latest.zip
```
------
1. （可选）运行以下命令以查看 AWS IoT Greengrass Core 软件的版本。
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
**重要**
如果您安装了 v2.4.0 之前的 Greengrass nucleus 版本，则在安装 Core 软件后请勿删除此文件夹。 AWS IoT Greengrass C AWS IoT Greengrass ore 软件使用此文件夹中的文件来运行。
如果您下载的是最新版本的软件，则需要安装 v2.4.0 或更高版本，并且可以在安装 C AWS IoT Greengrass ore 软件后删除此文件夹。
## 下载 AWS IoT 舰队配置插件
您可以从以下位置下载最新版本的 AWS IoT 舰队配置插件：
+ [https://d2s8p88vqu9w66.cloudfront。 net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim](https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-latest.jar)-latest.jar
**注意**
您可以从以下位置下载特定版本的 AWS IoT 舰队配置插件。*version*替换为要下载的版本。有关各版本实例集预置插件的更多信息，请参阅 [AWS IoT 实例集预置插件更改日志](fleet-provisioning-changelog.md)。
```
https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-version.jar
```
实例集预置插件是开源插件。要查看其源代码，请参阅上的[AWS IoT 舰队配置插件](https://github.com/aws-greengrass/aws-greengrass-fleet-provisioning-by-claim) GitHub。
**下载 AWS IoT 舰队配置插件**
+ 在您的设备上，将 AWS IoT 队列配置插件下载到名为的文件中`aws.greengrass.FleetProvisioningByClaim.jar`。*GreengrassInstaller*替换为要使用的文件夹。
------
#### [ Linux or Unix ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-latest.jar > GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-latest.jar > GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar
```
------
#### [ PowerShell ]
```
iwr -Uri https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-latest.jar -OutFile GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar
```
------
下载此软件即表示您同意[Greengrass Core 软件许可协议](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf)。
## 安装 AWS IoT Greengrass 核心软件
使用可指定以下操作的参数运行安装程序：
+ 从部分配置文件进行安装，该文件指定使用队列配置插件来配置 AWS 资源。 AWS IoT Greengrass Core 软件使用配置文件来指定设备上每个 Greengrass 组件的配置。安装程序会根据您提供的部分配置文件，以及实例集预置插件创建的 AWS 资源来创建完整的配置文件。
+ 指定使用 `ggc_user` 系统用户在核心设备上运行软件组件。在 Linux 设备上，此命令还指定使用 `ggc_group` 系统组，安装程序会为您创建系统用户和组。
+ 将 AWS IoT Greengrass Core 软件设置为启动时运行的系统服务。在 Linux 设备上，这需要 [Systemd](https://en.wikipedia.org/wiki/Systemd) 初始化系统。
**重要**
在 Windows 核心设备上，必须将 AWS IoT Greengrass 核心软件设置为系统服务。
有关您可以指定的参数的更多信息，请参阅[安装程序参数](configure-installer.md)。
**注意**
如果您在内存有限的设备 AWS IoT Greengrass 上运行，则可以控制 AWS IoT Greengrass 酷睿软件使用的内存量。要控制内存分配，您可以在 Nucleus 组件的 `jvmOptions` 配置参数中设置 JVM 堆大小选项。有关更多信息，请参阅 [使用 JVM 选项控制内存分配](configure-greengrass-core-v2.md#jvm-tuning)。
**安装 AWS IoT Greengrass 核心软件**
1. 检查 AWS IoT Greengrass 核心软件的版本。
+ *GreengrassInstaller*替换为包含该软件的文件夹的路径。
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
1. 使用文本编辑器创建名为 `config.yaml` 的配置文件，以提供给安装程序。
例如，在基于 Linux 的系统上，您可以运行以下命令来使用 GNU nano 创建该文件。
```
nano GreengrassInstaller/config.yaml
```
将以下 YAML 内容复制到该文件中。此部分配置文件会指定实例集预置插件的参数。有关可以指定的选项的更多信息，请参阅[配置 AWS IoT 舰队配置插件](fleet-provisioning-configuration.md)。
------
#### [ Linux or Unix ]
```
---
services:
aws.greengrass.Nucleus:
version: "2.17.0"
aws.greengrass.FleetProvisioningByClaim:
configuration:
rootPath: "/greengrass/v2"
awsRegion: "us-west-2"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredentialEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
provisioningTemplate: "GreengrassFleetProvisioningTemplate"
claimCertificatePath: "/greengrass/v2/claim-certs/claim.pem.crt"
claimCertificatePrivateKeyPath: "/greengrass/v2/claim-certs/claim.private.pem.key"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
templateParameters:
ThingName: "MyGreengrassCore"
ThingGroupName: "MyGreengrassCoreGroup"
```
------
#### [ Windows ]
```
---
services:
aws.greengrass.Nucleus:
version: "2.17.0"
aws.greengrass.FleetProvisioningByClaim:
configuration:
rootPath: "C:\\greengrass\\v2"
awsRegion: "us-west-2"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredentialEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
provisioningTemplate: "GreengrassFleetProvisioningTemplate"
claimCertificatePath: "C:\\greengrass\\v2\\claim-certs\\claim.pem.crt"
claimCertificatePrivateKeyPath: "C:\\greengrass\\v2\\claim-certs\\claim.private.pem.key"
rootCaPath: "C:\\greengrass\\v2\\AmazonRootCA1.pem"
templateParameters:
ThingName: "MyGreengrassCore"
ThingGroupName: "MyGreengrassCoreGroup"
```
------
然后执行以下操作：
+ *2.17.0*替换为 AWS IoT Greengrass Core 软件的版本。
+ 用 Greengrass 根*C:\$1greengrass\$1v2*文件夹替换`/greengrass/v2`或的每个实例。
**注意**
在 Windows 设备上，您必须将路径分隔符指定为双反斜杠 (`\\`)，例如 `C:\\greengrass\\v2`。
+ *us-west-2*替换为您创建置备模板和其他资源的 AWS 区域。
+ `iotDataEndpoint`用您的 AWS IoT 数据端点替换。
+ 用您的`iotCredentialEndpoint` AWS IoT 凭证终端节点替换。
+ *GreengrassCoreTokenExchangeRoleAlias*替换为令牌交换角色别名的名称。
+ *GreengrassFleetProvisioningTemplate*替换为队列配置模板的名称。
+ 将 `claimCertificatePath` 替换为设备上声明证书的路径。
+ 将 `claimCertificatePrivateKeyPath` 替换为设备上声明证书私钥的路径。
+ 将模板参数（`templateParameters`）替换为用于预置设备的值。此示例参考用于定义 `ThingName` 和 `ThingGroupName` 参数的[示例模板](fleet-provisioning-setup.md#example-fleet-provisioning-template)。
**注意**
在此配置文件中，您可以自定义其他配置选项（例如要使用的端口和网络代理），如以下示例所示。有关更多信息，请参阅 [Greengrass Nucleus 配置](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration)。
```
---
services:
aws.greengrass.Nucleus:
version: "2.17.0"
configuration:
mqtt:
port: 443
greengrassDataPlanePort: 443
networkProxy:
noProxyAddresses: "http://192.168.0.1,www.example.com"
proxy:
url: "http://my-proxy-server:1100"
username: "Mary_Major"
password: "pass@word1357"
aws.greengrass.FleetProvisioningByClaim:
configuration:
rootPath: "/greengrass/v2"
awsRegion: "us-west-2"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredentialEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
provisioningTemplate: "GreengrassFleetProvisioningTemplate"
claimCertificatePath: "/greengrass/v2/claim-certs/claim.pem.crt"
claimCertificatePrivateKeyPath: "/greengrass/v2/claim-certs/claim.private.pem.key"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
templateParameters:
ThingName: "MyGreengrassCore"
ThingGroupName: "MyGreengrassCoreGroup"
mqttPort: 443
proxyUrl: "http://my-proxy-server:1100"
proxyUserName: "Mary_Major"
proxyPassword: "pass@word1357"
```
```
---
services:
aws.greengrass.Nucleus:
version: "2.17.0"
configuration:
mqtt:
port: 443
greengrassDataPlanePort: 443
networkProxy:
noProxyAddresses: "http://192.168.0.1,www.example.com"
proxy:
url: "http://my-proxy-server:1100"
username: "Mary_Major"
password: "pass@word1357"
aws.greengrass.FleetProvisioningByClaim:
configuration:
rootPath: "C:\\greengrass\\v2"
awsRegion: "us-west-2"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredentialEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
provisioningTemplate: "GreengrassFleetProvisioningTemplate"
claimCertificatePath: "C:\\greengrass\\v2\\claim-certs\\claim.pem.crt"
claimCertificatePrivateKeyPath: "C:\\greengrass\\v2\\claim-certs\\claim.private.pem.key"
rootCaPath: "C:\\greengrass\\v2\\AmazonRootCA1.pem"
templateParameters:
ThingName: "MyGreengrassCore"
ThingGroupName: "MyGreengrassCoreGroup"
mqttPort: 443
proxyUrl: "http://my-proxy-server:1100"
proxyUserName: "Mary_Major"
proxyPassword: "pass@word1357"
```
要使用 HTTPS 代理，您必须使用 1.1.0 版本或更高版本的实例集预置插件。您还必须在 `system` 下指定 `rootCaPath`，如以下示例所示。
```
---
system:
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
services:
...
```
```
---
system:
rootCaPath: "C:\\greengrass\\v2\\AmazonRootCA1.pem"
services:
...
```
1. 运行安装程序。指定 `--trusted-plugin` 来提供实例集预置插件，并指定 `--init-config` 来提供配置文件。
+ 将 `/greengrass/v2` 替换为 Greengrass 根文件夹。
+ 将的*GreengrassInstaller*每个实例替换为解压安装程序所在的文件夹。
------
#### [ Linux or Unix ]
```
sudo -E java -Droot="/greengrass/v2" -Dlog.store=FILE \
-jar ./GreengrassInstaller/lib/Greengrass.jar \
--trusted-plugin ./GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar \
--init-config ./GreengrassInstaller/config.yaml \
--component-default-user ggc_user:ggc_group \
--setup-system-service true
```
------
#### [ Windows Command Prompt (CMD) ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" ^
-jar ./GreengrassInstaller/lib/Greengrass.jar ^
--trusted-plugin ./GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar ^
--init-config ./GreengrassInstaller/config.yaml ^
--component-default-user ggc_user ^
--setup-system-service true
```
------
#### [ PowerShell ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" `
-jar ./GreengrassInstaller/lib/Greengrass.jar `
--trusted-plugin ./GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar `
--init-config ./GreengrassInstaller/config.yaml `
--component-default-user ggc_user `
--setup-system-service true
```
------
**重要**
在 Windows 核心设备上，`--setup-system-service true`必须指定将 AWS IoT Greengrass 核心软件设置为系统服务。
如果指定 `--setup-system-service true`，则安装程序会在将软件设置为系统服务并运行后打印 `Successfully set up Nucleus as a system service`。否则，如果安装程序成功安装软件，则不会输出任何消息。
**注意**
在没有 `deploy-dev-tools` 参数的情况下运行安装程序时，您不能使用 `--provision true` 参数来部署本地开发工具。有关直接在您的设备上部署 Greengrass CLI 的信息，请参阅 [Greengrass 命令行界面](gg-cli.md)。
1. 通过查看根文件夹中的文件来验证安装情况。
------
#### [ Linux or Unix ]
```
ls /greengrass/v2
```
------
#### [ Windows Command Prompt (CMD) ]
```
dir C:\greengrass\v2
```
------
#### [ PowerShell ]
```
ls C:\greengrass\v2
```
------
如果安装成功，则根文件夹中包含多个文件夹，例如 `config`、`packages` 和 `logs`。
如果您将 AWS IoT Greengrass Core 软件作为系统服务安装，则安装程序会为您运行该软件。否则，您必须手动运行该软件。有关更多信息，请参阅 [运行 AWS IoT Greengrass 核心软件](run-greengrass-core-v2.md)。
有关如何配置和使用软件的更多信息 AWS IoT Greengrass，请参阅以下内容：
+ [配置 AWS IoT Greengrass 核心软件](configure-greengrass-core-v2.md)
+ [开发 AWS IoT Greengrass 组件](develop-greengrass-components.md)
+ [将 AWS IoT Greengrass 组件部署到设备](manage-deployments.md)
+ [Greengrass 命令行界面](gg-cli.md)
# 为 Greengrass 核心 AWS IoT 设备设置队列配置
要[安装具有队列配置功能的 AWS IoT Greengrass Core 软件](fleet-provisioning.md)，必须先在中设置以下资源 AWS 账户。这些资源使设备能够在 Greengrass 核心设备上注册 AWS IoT 并作为 Greengrass 核心设备运行。只需按照本节中的步骤操作一次，即可在 AWS 账户中创建和配置这些资源。
+ 令牌交换 IAM 角色，即核心设备授权调用 AWS 服务时使用的角色。
+ 指向代币交换 AWS IoT 角色的角色别名。
+ （可选）一项 AWS IoT 策略，核心设备使用该策略来授权对 AWS IoT 和 AWS IoT Greengrass 服务的调用。此 AWS IoT 策略必须`iot:AssumeRoleWithCertificate`允许指向令牌交换 AWS IoT 角色的角色别名的权限。
您可以对队列中的所有核心设备使用单一 AWS IoT 策略，也可以配置队列配置模板为每台核心设备创建 AWS IoT 策略。
+ AWS IoT 舰队配置模板。此模板必须指定以下各项：
+ AWS IoT 事物资源。您可以指定一系列现有事物组，在每台设备联机时为设备部署组件。
+ 一种 AWS IoT 策略资源。此资源可以定义下列属性之一：
+ 现有 AWS IoT 策略的名称。如果选择此选项，则根据此模板创建的核心设备将使用相同的 AWS IoT 策略，并且您可以像队列一样管理它们的权限。
+ 一份 AWS IoT 政策文件。如果选择此选项，则根据此模板创建的每台核心设备都使用唯一的 AWS IoT 策略，并且您可以管理每台核心设备的权限。
+ AWS IoT 证书资源。此证书资源必须使用 `AWS::IoT::Certificate::Id` 参数将证书附加到核心设备。有关更多信息，请参阅《*AWS IoT 开发人员指南*》中的[Just-in-time 配置](https://docs.aws.amazon.com/iot/latest/developerguide/jit-provisioning.html)。
+ 队列 AWS IoT 配置模板的配置声明证书和私钥。您可以在制造过程中将此证书和私钥嵌入设备中，这样设备就可以在联机时自行注册和预置。
**重要**
预置声明私钥应始终得到保护，包括在 Greengrass 核心设备上时。我们建议您使用 Amazon CloudWatch 指标和日志来监控是否存在滥用迹象，例如未经授权使用索赔证书来配置设备。如果您检测到滥用，请禁用预置声明证书，以使其不能用于设备预置。有关更多信息，请参阅 *AWS IoT Core 开发人员指南* 中的 [监控 AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/monitoring_overview.html)。
为了帮助您更好地管理自己在您的设备中注册的设备数量和设备 AWS 账户，您可以在创建队列配置模板时指定预配置挂钩。预配置挂钩是一种验证设备在注册期间提供的模板参数的 AWS Lambda 功能。例如，您可以创建一个预置前钩子，根据数据库检查设备 ID，以验证设备是否有权进行预置。有关更多信息，请参阅《AWS IoT Core 开发人员指南》中的[预置前钩子](https://docs.aws.amazon.com/iot/latest/developerguide/pre-provisioning-hook.html)。**
+ 您附加到配置声明证书的 AWS IoT 策略，允许设备注册和使用队列配置模板。
**Topics**
+ [创建令牌交换角色](#create-token-exchange-role)
+ [创建 AWS IoT 策略](#create-iot-policy)
+ [创建实例集预置模板](#create-provisioning-template)
+ [创建预置声明证书和私钥](#create-claim-certificates)
## 创建令牌交换角色
Greengrass 核心设备使用 IAM 服务角色（称为*令牌交换角色）来授权对*服务的调用。 AWS 设备使用 AWS IoT 证书提供程序来获取此角色的临时 AWS 证书，从而允许设备与 Amazon Logs 进行交互 AWS IoT、向 Amazon Logs 发送 CloudWatch 日志以及从 Amazon S3 下载自定义组件项目。有关更多信息，请参阅 [授权核心设备与 AWS 服务交互](device-service-role.md)。
您可以使用 AWS IoT *角色别名*为 Greengrass 核心设备配置令牌交换角色。角色别名允许您更改设备的令牌交换角色，但设备配置保持不变。有关更多信息，请参阅《AWS IoT Core 开发人员指南》**中的[授权直接调用 AWS 服务](https://docs.aws.amazon.com/iot/latest/developerguide/authorizing-direct-aws.html)。
在本节中，您将创建一个令牌交换 IAM 角色和一个指向该 AWS IoT 角色的角色别名。如果您已经设置了 Greengrass 核心设备，则可以使用其令牌交换角色和角色别名，而不必新建。
**创建令牌交换 IAM 角色**
1. 创建设备可将其用作令牌交换角色的 IAM 角色。执行以下操作：
1. 创建包含令牌交换角色所需的信任策略文档的文件。
例如，在基于 Linux 的系统上，您可以运行以下命令来使用 GNU nano 创建该文件。
```
nano device-role-trust-policy.json
```
将以下 JSON 复制到该文件中。
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
1. 通过信任策略文档创建令牌交换角色。
+ *GreengrassV2TokenExchangeRole*替换为要创建的 IAM 角色的名称。
```
aws iam create-role --role-name GreengrassV2TokenExchangeRole --assume-role-policy-document file://device-role-trust-policy.json
```
如果请求成功，响应类似如下示例。
```
{
"Role": {
"Path": "/",
"RoleName": "GreengrassV2TokenExchangeRole",
"RoleId": "AROAZ2YMUHYHK5OKM77FB",
"Arn": "arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole",
"CreateDate": "2021-02-06T00:13:29+00:00",
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
}
```
1. 创建一个包含令牌交换角色所需的访问策略文档的文件。
例如，在基于 Linux 的系统上，您可以运行以下命令来使用 GNU nano 创建该文件。
```
nano device-role-access-policy.json
```
将以下 JSON 复制到该文件中。
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents",
"logs:DescribeLogStreams",
"s3:GetBucketLocation"
],
"Resource": "*"
}
]
}
```
**注意**
此访问策略不允许访问 S3 存储桶中的组件构件。要在 Amazon S3 中部署可定义构件的自定义组件，您必须为该角色添加权限以允许核心设备检索组件构件。有关更多信息，请参阅 [允许访问 S3 存储桶中的组件构件](device-service-role.md#device-service-role-access-s3-bucket)。
如果您还没有适用于组件构件的 S3 存储桶，则可以在创建存储桶后添加这些权限。
1. 通过策略文档创建 IAM 策略
+ *GreengrassV2TokenExchangeRoleAccess*替换为要创建的 IAM 策略的名称。
```
aws iam create-policy --policy-name GreengrassV2TokenExchangeRoleAccess --policy-document file://device-role-access-policy.json
```
如果请求成功，响应类似如下示例。
```
{
"Policy": {
"PolicyName": "GreengrassV2TokenExchangeRoleAccess",
"PolicyId": "ANPAZ2YMUHYHACI7C5Z66",
"Arn": "arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess",
"Path": "/",
"DefaultVersionId": "v1",
"AttachmentCount": 0,
"PermissionsBoundaryUsageCount": 0,
"IsAttachable": true,
"CreateDate": "2021-02-06T00:37:17+00:00",
"UpdateDate": "2021-02-06T00:37:17+00:00"
}
}
```
1. 将 IAM 策略附加到令牌交换角色。
+ 将 *GreengrassV2TokenExchangeRole* 替换为 IAM 角色的名称。
+ 将策略 ARN 替换为您在上一步中创建的 IAM 策略的 ARN。
```
aws iam attach-role-policy --role-name GreengrassV2TokenExchangeRole --policy-arn arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess
```
如果请求成功，则该命令没有任何输出。
1. 创建 AWS IoT 指向代币交换角色的角色别名。
+ *GreengrassCoreTokenExchangeRoleAlias*替换为要创建的角色别名的名称。
+ 将角色 ARN 替换为您在上一步中创建的 IAM 角色的 ARN。
```
aws iot create-role-alias --role-alias GreengrassCoreTokenExchangeRoleAlias --role-arn arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole
```
如果请求成功，响应类似如下示例。
```
{
"roleAlias": "GreengrassCoreTokenExchangeRoleAlias",
"roleAliasArn": "arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
```
**注意**
要创建角色别名，您必须有权将令牌交换 IAM 角色传递到 AWS IoT。如果您在尝试创建角色别名时收到错误消息，请检查您的 AWS 用户是否具有此权限。有关更多信息，请参阅[《用户*指南》中的授予AWS Identity and Access Management 用户*向 AWS 服务传递角色的权限](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_passrole.html)。
## 创建 AWS IoT 策略
将设备注册为 AWS IoT 事物后，该设备可以使用数字证书进行身份验证 AWS。该证书包含一个或多个 AWS IoT 策略，这些策略定义了设备可以与证书一起使用的权限。这些策略允许设备与 AWS IoT 和通信 AWS IoT Greengrass。
通过 AWS IoT 队列配置，设备可以 AWS IoT 连接到以创建和下载设备证书。在下一节中创建的队列配置模板中，您可以指定是将相同的 AWS IoT 策略 AWS IoT 附加到所有设备的证书，还是为每台设备创建新策略。
在本节中，您将创建一个 AWS IoT 附加到所有设备证书的 AWS IoT 策略。通过这种方法，您可以以实例集的形式管理所有设备的权限。如果您想为每台设备创建新 AWS IoT 策略，则可以跳过本节，在定义队列模板时参考其中的策略。
**创建 AWS IoT 策略**
+ 创建 AWS IoT 策略来定义您的 Greengrass 核心设备队列的 AWS IoT 权限。以下策略允许访问所有 MQTT 主题和 Greengrass 操作，因此您的设备可以处理需要新 Greengrass 操作的自定义应用程序和未来更改。此策略还允许 `iot:AssumeRoleWithCertificate` 权限，允许您的设备使用您在上一节中创建的令牌交换角色。您可以根据自己的使用案例来限制此策略。有关更多信息，请参阅 [AWS IoT Greengrass V2 核心设备的最低 AWS IoT 政策](device-auth.md#greengrass-core-minimal-iot-policy)。
执行以下操作：
1. 创建一个包含 Greengrass 核心设备所需的 AWS IoT 策略文档的文件。
例如，在基于 Linux 的系统上，您可以运行以下命令来使用 GNU nano 创建该文件。
```
nano greengrass-v2-iot-policy.json
```
将以下 JSON 复制到该文件中。
+ 将`iot:AssumeRoleWithCertificate`资源替换为您在上一节中创建的 AWS IoT 角色别名的 ARN。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Publish",
"iot:Subscribe",
"iot:Receive",
"iot:Connect",
"greengrass:*"
],
"Resource": [
"*"
]
},
{
"Effect": "Allow",
"Action": "iot:AssumeRoleWithCertificate",
"Resource": "arn:aws:iot:us-east-1:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
]
}
```
------
1. 根据 AWS IoT 策略文档创建策略。
+ *GreengrassV2IoTThingPolicy*替换为要创建的策略的名称。
```
aws iot create-policy --policy-name GreengrassV2IoTThingPolicy --policy-document file://greengrass-v2-iot-policy.json
```
如果请求成功，响应类似如下示例。
------
#### [ JSON ]
****
```
{
"policyName": "GreengrassV2IoTThingPolicy",
"policyArn": "arn:aws:iot:us-west-2:123456789012:policy/GreengrassV2IoTThingPolicy",
"policyDocument": "{
\"Version\": \"2012-10-17\",
\"Statement\": [
{
\"Effect\": \"Allow\",
\"Action\": [
\"iot:Publish\",
\"iot:Subscribe\",
\"iot:Receive\",
\"iot:Connect\",
\"greengrass:*\"
],
\"Resource\": [
\"*\"
]
},
{
\"Effect\": \"Allow\",
\"Action\": \"iot:AssumeRoleWithCertificate\",
\"Resource\": \"arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias\"
}
]
}",
"policyVersionId": "1"
}
```
------
## 创建实例集预置模板
AWS IoT 舰队配置模板定义了如何配置 AWS IoT 内容、策略和证书。要使用实例集预置插件预置 Greengrass 核心设备，您必须创建一个模板，指定以下各项：
+ AWS IoT 事物资源。您可以指定一系列现有事物组，在每台设备联机时为设备部署组件。
+ 一种 AWS IoT 策略资源。此资源可以定义下列属性之一：
+ 现有 AWS IoT 策略的名称。如果选择此选项，则根据此模板创建的核心设备将使用相同的 AWS IoT 策略，并且您可以像队列一样管理它们的权限。
+ 一份 AWS IoT 政策文件。如果选择此选项，则根据此模板创建的每台核心设备都使用唯一的 AWS IoT 策略，并且您可以管理每台核心设备的权限。
+ AWS IoT 证书资源。此证书资源必须使用 `AWS::IoT::Certificate::Id` 参数将证书附加到核心设备。有关更多信息，请参阅《*AWS IoT 开发人员指南*》中的[Just-in-time 配置](https://docs.aws.amazon.com/iot/latest/developerguide/jit-provisioning.html)。
在模板中，您可以指定将 AWS IoT 事物添加到现有事物组列表中。当核心设备首次连接到 AWS IoT Greengrass 时，它会收到其所属的每个事物组的 Greengrass 部署。您可以使用事物组，在每台设备联机后立即为设备部署最新的软件。有关更多信息，请参阅 [将 AWS IoT Greengrass 组件部署到设备](manage-deployments.md)。
在配置设备 AWS 账户 时，该 AWS IoT 服务需要权限才能在您中创建和更新 AWS IoT 资源。要授予 AWS IoT 服务访问权限，您需要创建一个 IAM 角色并在创建模板时提供该角色。 AWS IoT 提供了一个名为 “[AWSIoTThings注册](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/service-role/AWSIoTThingsRegistration)” 的托管策略，允许访问在配置设备时 AWS IoT 可能使用的所有权限。您可以使用此托管策略，也可以创建自定义策略，根据您的使用案例缩小托管策略中的权限范围。
在本节中，您将创建一个允许 AWS IoT 为设备配置资源的 IAM 角色，并创建使用该 IAM 角色的队列配置模板。
**创建实例集预置模板**
1. 创建一个 IAM 角色，该角色 AWS IoT 可以代入在您的中配置资源 AWS 账户。执行以下操作：
1. 创建一个包含允许 AWS IoT 担任该角色的信任策略文档的文件。
例如，在基于 Linux 的系统上，您可以运行以下命令来使用 GNU nano 创建该文件。
```
nano aws-iot-trust-policy.json
```
将以下 JSON 复制到该文件中。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. 使用信任策略文档创建 IAM 角色。
+ *GreengrassFleetProvisioningRole*替换为要创建的 IAM 角色的名称。
```
aws iam create-role --role-name GreengrassFleetProvisioningRole --assume-role-policy-document file://aws-iot-trust-policy.json
```
如果请求成功，响应类似如下示例。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Connect",
"iot:Publish",
"iot:Subscribe",
"iot:Receive"
],
"Resource": "*"
}
]
}
```
------
1. 查看[AWSIoTThings注册](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/service-role/AWSIoTThingsRegistration)策略，该策略允许访问配置设备时 AWS IoT 可能使用的所有权限。您可以使用此托管策略，也可以创建自定义策略，为您的使用案例定义缩小范围的权限。如果您选择创建自定义策略，请立即创建。
1. 将 IAM 策略附加到实例集预置角色。
+ 将 *GreengrassFleetProvisioningRole* 替换为 IAM 角色的名称。
+ 如果您在上一步中创建了自定义策略，请将策略 ARN 替换为要使用的 IAM 策略的 ARN。
```
aws iam attach-role-policy --role-name GreengrassFleetProvisioningRole --policy-arn arn:aws:iam::aws:policy/service-role/AWSIoTThingsRegistration
```
如果请求成功，则该命令没有任何输出。
1. （可选）创建一个*预置前钩子*，该钩子是 AWS Lambda 函数，用于验证设备在注册期间提供的模板参数。您可以使用预置前钩子来更好地控制您的 AWS 账户中注册的设备和设备数量。有关更多信息，请参阅《AWS IoT Core 开发人员指南》中的[预置前钩子](https://docs.aws.amazon.com/iot/latest/developerguide/pre-provisioning-hook.html)。**
1. 创建实例集预置模板。执行以下操作：
1. 创建一个文件以包含预置模版文档。
例如，在基于 Linux 的系统上，您可以运行以下命令来使用 GNU nano 创建该文件。
```
nano greengrass-fleet-provisioning-template.json
```
编写一个预置模板文档。您可以从以下示例配置模板开始，该模板指定创建具有以下属性的 AWS IoT 事物：
+ 事物的名称是您在 `ThingName` 模板参数中指定的值。
+ 事物是您在 `ThingGroupName` 模板参数中指定的事物组的成员。事物组必须存在于您的中 AWS 账户。
+ 事物的证书上`GreengrassV2IoTThingPolicy`附有名为的 AWS IoT 策略。
有关更多信息，请参阅《AWS IoT Core 开发人员指南》中的[预置模板](https://docs.aws.amazon.com/iot/latest/developerguide/provision-template.html)。**
```
{
"Parameters": {
"ThingName": {
"Type": "String"
},
"ThingGroupName": {
"Type": "String"
},
"AWS::IoT::Certificate::Id": {
"Type": "String"
}
},
"Resources": {
"MyThing": {
"OverrideSettings": {
"AttributePayload": "REPLACE",
"ThingGroups": "REPLACE",
"ThingTypeName": "REPLACE"
},
"Properties": {
"AttributePayload": {},
"ThingGroups": [
{
"Ref": "ThingGroupName"
}
],
"ThingName": {
"Ref": "ThingName"
}
},
"Type": "AWS::IoT::Thing"
},
"MyPolicy": {
"Properties": {
"PolicyName": "GreengrassV2IoTThingPolicy"
},
"Type": "AWS::IoT::Policy"
},
"MyCertificate": {
"Properties": {
"CertificateId": {
"Ref": "AWS::IoT::Certificate::Id"
},
"Status": "Active"
},
"Type": "AWS::IoT::Certificate"
}
}
}
```
**注意**
*MyThing**MyPolicy*、和*MyCertificate*是任意名称，用于标识队列置备模板中的每个资源规范。 AWS IoT 不会在根据模板创建的资源中使用这些名称。您可以使用这些名称，也可以将其替换为有助于识别模板中每项资源的值。
1. 通过预置模板文档创建实例集预置模板。
+ 将 *GreengrassFleetProvisioningTemplate* 替换为要创建的模板的名称。
+ 将模板描述替换为您的模板描述。
+ 将预置角色 ARN 替换为您之前创建的角色的 ARN。
------
#### [ Linux or Unix ]
```
aws iot create-provisioning-template \
--template-name GreengrassFleetProvisioningTemplate \
--description "A provisioning template for Greengrass core devices." \
--provisioning-role-arn "arn:aws:iam::123456789012:role/GreengrassFleetProvisioningRole" \
--template-body file://greengrass-fleet-provisioning-template.json \
--enabled
```
------
#### [ Windows Command Prompt (CMD) ]
```
aws iot create-provisioning-template ^
--template-name GreengrassFleetProvisioningTemplate ^
--description "A provisioning template for Greengrass core devices." ^
--provisioning-role-arn "arn:aws:iam::123456789012:role/GreengrassFleetProvisioningRole" ^
--template-body file://greengrass-fleet-provisioning-template.json ^
--enabled
```
------
#### [ PowerShell ]
```
aws iot create-provisioning-template `
--template-name GreengrassFleetProvisioningTemplate `
--description "A provisioning template for Greengrass core devices." `
--provisioning-role-arn "arn:aws:iam::123456789012:role/GreengrassFleetProvisioningRole" `
--template-body file://greengrass-fleet-provisioning-template.json `
--enabled
```
------
**注意**
如果您创建了预置前钩子，请使用 `--pre-provisioning-hook` 参数指定预置前钩子的 Lambda 函数的 ARN。
```
--pre-provisioning-hook targetArn=arn:aws:lambda:us-west-2:123456789012:function:GreengrassPreProvisioningHook
```
如果请求成功，响应类似如下示例。
```
{
"templateArn": "arn:aws:iot:us-west-2:123456789012:provisioningtemplate/GreengrassFleetProvisioningTemplate",
"templateName": "GreengrassFleetProvisioningTemplate",
"defaultVersionId": 1
}
```
## 创建预置声明证书和私钥
声明证书是 X.509 证书，允许设备注册为 AWS IoT 事物并检索用于常规操作的唯一 X.509 设备证书。创建索赔证书后，您可以附加一个 AWS IoT 策略，允许设备使用该策略来创建唯一的设备证书并使用队列配置模板进行配置。具有声明证书的设备只能使用您在 AWS IoT 策略中允许的预置模板进行预置。
在本节中，您将创建声明证书并为设备配置该证书，以便与您在上一节中创建的实例集预置模版一起使用。
**重要**
预置声明私钥应始终得到保护，包括在 Greengrass 核心设备上时。我们建议您使用 Amazon CloudWatch 指标和日志来监控是否存在滥用迹象，例如未经授权使用索赔证书来配置设备。如果您检测到滥用，请禁用预置声明证书，以使其不能用于设备预置。有关更多信息，请参阅 *AWS IoT Core 开发人员指南* 中的 [监控 AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/monitoring_overview.html)。
为了帮助您更好地管理自己在您的设备中注册的设备数量和设备 AWS 账户，您可以在创建队列配置模板时指定预配置挂钩。预配置挂钩是一种验证设备在注册期间提供的模板参数的 AWS Lambda 功能。例如，您可以创建一个预置前钩子，根据数据库检查设备 ID，以验证设备是否有权进行预置。有关更多信息，请参阅《AWS IoT Core 开发人员指南》中的[预置前钩子](https://docs.aws.amazon.com/iot/latest/developerguide/pre-provisioning-hook.html)。**
**创建预置声明证书和私钥**
1. 创建一个文件夹，用于下载声明证书和私钥。
```
mkdir claim-certs
```
1. 创建并保存用于置备的证书和私钥。 AWS IoT 提供由 Amazon 根证书颁发机构 (CA) 签署的客户证书。
------
#### [ Linux or Unix ]
```
aws iot create-keys-and-certificate \
--certificate-pem-outfile "claim-certs/claim.pem.crt" \
--public-key-outfile "claim-certs/claim.public.pem.key" \
--private-key-outfile "claim-certs/claim.private.pem.key" \
--set-as-active
```
------
#### [ Windows Command Prompt (CMD) ]
```
aws iot create-keys-and-certificate ^
--certificate-pem-outfile "claim-certs/claim.pem.crt" ^
--public-key-outfile "claim-certs/claim.public.pem.key" ^
--private-key-outfile "claim-certs/claim.private.pem.key" ^
--set-as-active
```
------
#### [ PowerShell ]
```
aws iot create-keys-and-certificate `
--certificate-pem-outfile "claim-certs/claim.pem.crt" `
--public-key-outfile "claim-certs/claim.public.pem.key" `
--private-key-outfile "claim-certs/claim.private.pem.key" `
--set-as-active
```
------
如果请求成功，则响应将包含有关证书的信息。保存证书的 ARN 以供将来使用。
1. 创建并附加一项 AWS IoT 策略，允许设备使用该证书创建唯一的设备证书，并使用队列配置模板进行配置。以下策略允许访问设备预置 MQTT API。有关更多信息，请参阅《AWS IoT Core 开发人员指南》中的[设备预置 MQTT API](https://docs.aws.amazon.com/iot/latest/developerguide/fleet-provision-api.html)。**
执行以下操作：
1. 创建一个包含 Greengrass 核心设备所需的 AWS IoT 策略文档的文件。
例如，在基于 Linux 的系统上，您可以运行以下命令来使用 GNU nano 创建该文件。
```
nano greengrass-provisioning-claim-iot-policy.json
```
将以下 JSON 复制到该文件中。
+ 将的*region*每个实例替换为您设置队列配置 AWS 区域 的位置。
+ 将的*account-id*每个实例替换为您的 AWS 账户 ID。
+ 将的*GreengrassFleetProvisioningTemplate*每个实例替换为您在上一节中创建的队列配置模板的名称。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iot:Connect",
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"iot:Publish",
"iot:Receive"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/$aws/certificates/create/*",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/provisioning-templates/GreengrassFleetProvisioningTemplate/provision/*"
]
},
{
"Effect": "Allow",
"Action": "iot:Subscribe",
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/certificates/create/*",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/provisioning-templates/GreengrassFleetProvisioningTemplate/provision/*"
]
}
]
}
```
------
1. 根据 AWS IoT 策略文档创建策略。
+ *GreengrassProvisioningClaimPolicy*替换为要创建的策略的名称。
```
aws iot create-policy --policy-name GreengrassProvisioningClaimPolicy --policy-document file://greengrass-provisioning-claim-iot-policy.json
```
如果请求成功，响应类似如下示例。
------
#### [ JSON ]
****
```
{
"policyName": "GreengrassProvisioningClaimPolicy",
"policyArn": "arn:aws:iot:us-west-2:123456789012:policy/GreengrassProvisioningClaimPolicy",
"policyDocument": "{
\"Version\": \"2012-10-17\",
\"Statement\": [
{
\"Effect\": \"Allow\",
\"Action\": \"iot:Connect\",
\"Resource\": \"*\"
},
{
\"Effect\": \"Allow\",
\"Action\": [
\"iot:Publish\",
\"iot:Receive\"
],
\"Resource\": [
\"arn:aws:iot:us-east-1:123456789012:topic/$aws/certificates/create/*\",
\"arn:aws:iot:us-east-1:123456789012:topic/$aws/provisioning-templates/GreengrassFleetProvisioningTemplate/provision/*\"
]
},
{
\"Effect\": \"Allow\",
\"Action\": \"iot:Subscribe\",
\"Resource\": [
\"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/certificates/create/*\",
\"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/provisioning-templates/GreengrassFleetProvisioningTemplate/provision/*\"
]
}
]
}",
"policyVersionId": "1"
}
```
------
1. 将 AWS IoT 策略附加到置备声明证书。
+ *GreengrassProvisioningClaimPolicy*替换为要附加的策略的名称。
+ 将目标 ARN 替换为预置声明证书的 ARN。
```
aws iot attach-policy --policy-name GreengrassProvisioningClaimPolicy --target arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4
```
如果请求成功，则该命令没有任何输出。
现在，您有了配置声明证书和私钥，设备可以使用这些证书和私钥注册 AWS IoT 并配置自己为 Greengrass 核心设备。您可以在制造过程中将索赔证书和私钥嵌入设备中，或者在安装 C AWS IoT Greengrass ore 软件之前将证书和密钥复制到设备。有关更多信息，请参阅 [安装具有 AWS IoT 队列配置功能的 C AWS IoT Greengrass ore 软件](fleet-provisioning.md)。
# 配置 AWS IoT 舰队配置插件
AWS IoT 队列配置插件提供了以下配置参数，当你[安装带有队列配置的 AWS IoT Greengrass Core 软件时，你可以自定义这些](fleet-provisioning.md)参数。
`rootPath`
用作 AWS IoT Greengrass 核心软件根目录的文件夹的路径。
`awsRegion`
舰队配置插件用于配置 AWS 资源的。 AWS 区域
`iotDataEndpoint`
您的 AWS IoT 数据端点 AWS 账户。
`iotCredentialEndpoint`
您的 AWS IoT 凭证终端节点 AWS 账户。
`iotRoleAlias`
指向令牌交换 IAM 角色的角色别名。 AWS IoT AWS IoT 凭证提供者扮演此角色是为了允许 Greengrass 核心设备与服务进行交互。 AWS 有关更多信息，请参阅 [授权核心设备与 AWS 服务交互](device-service-role.md)。
`provisioningTemplate`
用于配置 AWS 资源的 AWS IoT 队列配置模板。此模板必须指定以下各项：
+ AWS IoT 事物资源。您可以指定一系列现有事物组，在每台设备联机时为设备部署组件。
+ 一种 AWS IoT 策略资源。此资源可以定义下列属性之一：
+ 现有 AWS IoT 策略的名称。如果选择此选项，则根据此模板创建的核心设备将使用相同的 AWS IoT 策略，并且您可以像队列一样管理它们的权限。
+ 一份 AWS IoT 政策文件。如果选择此选项，则根据此模板创建的每台核心设备都使用唯一的 AWS IoT 策略，并且您可以管理每台核心设备的权限。
+ AWS IoT 证书资源。此证书资源必须使用 `AWS::IoT::Certificate::Id` 参数将证书附加到核心设备。有关更多信息，请参阅《*AWS IoT 开发人员指南*》中的[Just-in-time 配置](https://docs.aws.amazon.com/iot/latest/developerguide/jit-provisioning.html)。
有关更多信息，请参阅《AWS IoT Core 开发人员指南》中的[预置模板](https://docs.aws.amazon.com/iot/latest/developerguide/provision-template.html)。**
`claimCertificatePath`
您在 `provisioningTemplate` 中指定的预置模板的预置声明证书的路径。有关更多信息，请参阅《AWS IoT Core API Reference》**中的 [CreateProvisioningClaim](https://docs.aws.amazon.com/iot/latest/apireference/API_CreateProvisioningClaim.html)。
`claimCertificatePrivateKeyPath`
您在 `provisioningTemplate` 中指定的预置模板的预置声明证书私钥的路径。有关更多信息，请参阅《AWS IoT Core API Reference》**中的 [CreateProvisioningClaim](https://docs.aws.amazon.com/iot/latest/apireference/API_CreateProvisioningClaim.html)。
预置声明私钥应始终得到保护，包括在 Greengrass 核心设备上时。我们建议您使用 Amazon CloudWatch 指标和日志来监控是否存在滥用迹象，例如未经授权使用索赔证书来配置设备。如果您检测到滥用，请禁用预置声明证书，以使其不能用于设备预置。有关更多信息，请参阅 *AWS IoT Core 开发人员指南* 中的 [监控 AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/monitoring_overview.html)。
为了帮助您更好地管理自己在您的设备中注册的设备数量和设备 AWS 账户，您可以在创建队列配置模板时指定预配置挂钩。预配置挂钩是一种验证设备在注册期间提供的模板参数的 AWS Lambda 功能。例如，您可以创建一个预置前钩子，根据数据库检查设备 ID，以验证设备是否有权进行预置。有关更多信息，请参阅《AWS IoT Core 开发人员指南》中的[预置前钩子](https://docs.aws.amazon.com/iot/latest/developerguide/pre-provisioning-hook.html)。**
`rootCaPath`
Amazon 根证书颁发机构（CA）证书的路径。
`templateParameters`
（可选）要提供给实例集预置模板的参数映射。有关更多信息，请参阅《AWS IoT Core 开发人员指南》中的[预置模板的参数部分](https://docs.aws.amazon.com/iot/latest/developerguide/provision-template.html#parameters-section)。**
`deviceId`
（可选）当实例集预置插件创建与 AWS IoT的 MQTT 连接时，用作客户端 ID 的设备标识符。
默认：随机的 UUID。
`mqttPort`
（可选）用于 MQTT 连接的端口。
默认值：`8883`
`proxyUrl`
（可选）代理服务器的 URL，格式为 `scheme://userinfo@host:port`。要使用 HTTPS 代理，您必须使用 1.1.0 版本或更高版本的实例集预置插件。
+ `scheme` – 方案，必须是 `http` 或 `https`。
**重要**
Greengrass 核心设备必须运行 [Greengrass Nucleus](greengrass-nucleus-component.md) v2.5.0 或更高版本才能使用 HTTPS 代理。
如果您配置 HTTPS 代理，则必须将代理服务器 CA 证书添加到核心设备的 Amazon 根 CA 证书中。有关更多信息，请参阅 [使核心设备信任 HTTPS 代理](configure-greengrass-core-v2.md#https-proxy-certificate-trust)。
+ `userinfo` –（可选）用户名和密码信息。如果您在 `url` 中指定此信息，则 Greengrass 核心设备将忽略 `username` 和 `password` 字段。
+ `host` – 代理服务器的主机名或 IP 地址。
+ `port` –（可选）端口号。如果您未指定端口，则 Greengrass 核心设备将使用以下默认值：
+ `http` – 80
+ `https` – 443
`proxyUserName`
（可选）代理服务器进行身份验证时使用的用户名。
`proxyPassword`
（可选）代理服务器进行身份验证时使用的用户名。
csrPath
（可选）证书签名请求（CSR）文件的路径，用于通过 CSR 创建设备证书。有关更多信息，请参阅《 AWS IoT Core 开发人员指南》中的[通过声明进行预置](https://docs.aws.amazon.com/iot/latest/developerguide/provision-wo-cert.html#claim-based)。**
csrPrivateKey路径
（可选，如果声明了 `csrPath`，则必须提供）用于生成 CSR 的私钥的路径。私钥必须已用于生成 CSR。有关更多信息，请参阅《AWS IoT Core 开发人员指南》中的[通过声明进行预置](https://docs.aws.amazon.com/iot/latest/developerguide/provision-wo-cert.html#claim-based)。**
certificatePath
（可选）可保存下载设备证书的路径。
privateKeyPath
（可选）可保存已下载设备私钥的路径。
# AWS IoT 实例集预置插件更改日志
下表通过声明插件（`aws.greengrass.FleetProvisioningByClaim`）描述了每个版本的 AWS IoT 实例集预置的更改。
| 版本 | 更改 |
| --- | --- |
| 1.2.2 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/greengrass/v2/developerguide/fleet-provisioning-changelog.html) |
| 1.2.1 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/greengrass/v2/developerguide/fleet-provisioning-changelog.html) |
| 1.2.0 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/greengrass/v2/developerguide/fleet-provisioning-changelog.html) |
| 1.1.0 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/greengrass/v2/developerguide/fleet-provisioning-changelog.html) |
| 1.0.0 | 初始版本。 |
# 安装具有自定义资源配置功能的 C AWS IoT Greengrass ore 软件
此功能适用于 [Greengrass Nucleus 组件](greengrass-nucleus-component.md)的 v2.4.0 及更高版本。
AWS IoT Greengrass Core 软件安装程序提供了 Java 接口，您可以在配置所需 AWS 资源的自定义插件中实现该接口。您可以开发预置插件以使用自定义 X.509 客户端证书或运行其他安装过程不支持的复杂预置步骤。有关更多信息，请参阅《AWS IoT Core 开发人员指南》**中的[创建您自己的客户端证书](https://docs.aws.amazon.com/iot/latest/developerguide/device-certs-your-own.html)。
要在安装 C AWS IoT Greengrass ore 软件时运行自定义配置插件，需要创建提供给安装程序的 JAR 文件。安装程序运行插件，插件返回一个配置，该配置定义了 Greengrass 核心设备的 AWS 资源。安装程序使用此信息在设备上配置 AWS IoT Greengrass Core 软件。有关更多信息，请参阅 [开发自定义预置插件](develop-custom-provisioning-plugins.md)。
**重要**
在下载 AWS IoT Greengrass 酷睿软件之前，请检查您的核心设备是否满足安装和运行 AWS IoT Greengrass 酷睿软件 v2.0 的[要求](greengrass-nucleus-component.md#greengrass-v2-requirements)。
**Topics**
+ [先决条件](#custom-provisioning-prerequisites)
+ [设置设备环境](#set-up-device-environment)
+ [下载 AWS IoT Greengrass 核心软件](#download-greengrass-core-v2)
+ [安装 AWS IoT Greengrass 核心软件](#run-greengrass-core-v2-installer-custom)
+ [开发自定义预置插件](develop-custom-provisioning-plugins.md)
## 先决条件
要使用自定义配置安装 AWS IoT Greengrass 核心软件，您必须具备以下条件：
+ 用于实施 `DeviceIdentityInterface` 的自定义预置插件的 JAR 文件。自定义预置插件必须返回每个系统和核心配置参数的值。否则，在安装过程中，您必须在配置文件中提供这些值。有关更多信息，请参阅 [开发自定义预置插件](develop-custom-provisioning-plugins.md)。
## 设置设备环境
按照本节中的步骤，将 Linux 或 Windows 设备设置为您的 AWS IoT Greengrass 核心设备。
### 设置 Linux 设备
**设置 Linux 设备用于 AWS IoT Greengrass V2**
1. 安装 Java 运行时， AWS IoT Greengrass 核心软件需要运行该运行时。我们建议您使用 [Amazon Corretto](https://aws.amazon.com/corretto/) 或 [OpenJDK](https://openjdk.java.net/) 长期支持版本。需要版本 8 或更高版本。以下命令向您展示如何在您的设备上安装 OpenJDK。
+ 对于基于 Debian 或基于 Ubuntua 的发行版：
```
sudo apt install default-jdk
```
+ 对于基于 Red Hat 的发行版：
```
sudo yum install java-11-openjdk-devel
```
+ 对于 Amazon Linux 2：
```
sudo amazon-linux-extras install java-openjdk11
```
+ 对于 Amazon Linux 2023：
```
sudo dnf install java-11-amazon-corretto -y
```
安装完成后，运行以下命令以验证 Java 是否在您的 Linux 设备上运行。
```
java -version
```
此命令会打印设备上运行的 Java 版本。例如，在基于 Debian 的发行版上，输出可能与以下示例类似。
```
openjdk version "11.0.9.1" 2020-11-04
OpenJDK Runtime Environment (build 11.0.9.1+1-post-Debian-1deb10u2)
OpenJDK 64-Bit Server VM (build 11.0.9.1+1-post-Debian-1deb10u2, mixed mode)
```
1. （可选）创建在设备上运行组件的默认系统用户和组。您也可以选择让 AWS IoT Greengrass 核心软件安装程序在安装过程中使用安装程序参数创建此用户和组。`--component-default-user`有关更多信息，请参阅 [安装程序参数](configure-installer.md)。
```
sudo useradd --system --create-home ggc_user
sudo groupadd --system ggc_group
```
1. 验证运行 AWS IoT Greengrass Core 软件的用户（通常`root`）是否有权`sudo`与任何用户和任何组一起运行。
1. 运行以下命令以打开 `/etc/sudoers` 文件。
```
sudo visudo
```
1. 验证用户的权限是否如以下示例所示。
```
root ALL=(ALL:ALL) ALL
```
1. （可选）要[运行容器化 Lambda 函数](run-lambda-functions.md)，必须启用 [cgroups](https://en.wikipedia.org/wiki/Cgroups) v1，且必须启用并装载*内存*和*设备* cgroups。如果您不打算运行容器化 Lambda 函数，则可跳过此步骤。
要启用这些 cgroups 选项，请使用以下 Linux 内核参数启动设备。
```
cgroup_enable=memory cgroup_memory=1 systemd.unified_cgroup_hierarchy=0
```
有关查看和设置设备内核参数的信息，请参阅适用于您操作系统和启动加载程序的文档。按照说明永久设置内核参数。
1. 按照 [设备要求](greengrass-nucleus-component.md#greengrass-v2-requirements) 中的要求列表所示，在您的设备上安装所有其他必需的依赖关系。
### 设置 Windows 设备
**注意**
此功能适用于 [Greengrass Nucleus 组件](greengrass-nucleus-component.md) v2.5.0 及更高版本。
**要将 Windows 设备设置为 AWS IoT Greengrass V2**
1. 安装 Java 运行时， AWS IoT Greengrass 核心软件需要运行该运行时。我们建议您使用 [Amazon Corretto](https://aws.amazon.com/corretto/) 或 [OpenJDK](https://openjdk.java.net/) 长期支持版本。需要版本 8 或更高版本。
1. 检查在 [PATH](https://en.wikipedia.org/wiki/PATH_(variable)) 系统变量上是否有 Java 可用，如果没有，请进行添加。该 LocalSystem 帐户运行 AWS IoT Greengrass Core 软件，因此您必须将 Java 添加到 PATH 系统变量中，而不是用户的 PATH 用户变量。执行以下操作：
1. 按下 Windows 键打开开始菜单。
1. 键入 **environment variables** 以从开始菜单中搜索系统选项。
1. 在开始菜单搜索结果中，选择**编辑系统环境变量**，以打开**系统属性**窗口。
1. 选择**环境变量...**，打开**环境变量**窗口。
1. 在**系统变量**下，选择**路径**，然后选择**编辑**。在**编辑环境变量**窗口中，您可以分行查看每个路径。
1. 检查 Java 安装的 `bin` 文件夹的路径是否存在。路径可能与以下示例类似。
```
C:\\Program Files\\Amazon Corretto\\jdk11.0.13_8\\bin
```
1. 如果**路径**中缺少 Java 安装的 `bin` 文件夹，请选择**新建**，添加该文件夹，然后选择**确定**。
1. 以管理员身份打开 Windows 命令提示符 (`cmd.exe`)。
1. 在 Windows 设备上的 LocalSystem 帐户中创建默认用户。*password*替换为安全密码。
```
net user /add ggc_user password
```
**提示**
根据您的 Windows 配置，用户密码可能会设置为在将来某个日期过期。为确保您的 Greengrass 应用程序继续运行，请跟踪密码过期时间，并在密码过期之前对其进行更新。您还可以将用户的密码设置为永不过期。
要检查用户及其密码的过期时间，请运行以下命令。
```
net user ggc_user | findstr /C:expires
```
要将用户密码设置为永不过期，请运行以下命令。
```
wmic UserAccount where "Name='ggc_user'" set PasswordExpires=False
```
如果你使用的是[已弃用该`wmic`命令的](https://learn.microsoft.com/en-us/windows/win32/wmisdk/wmic) Windows 10 或更高版本，请运行以下 PowerShell 命令。
```
Get-CimInstance -Query "SELECT * from Win32_UserAccount WHERE name = 'ggc_user'" | Set-CimInstance -Property @{PasswordExpires="False"}
```
1. 从微软下载该[PsExec实用程序](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec)并将其安装到设备上。
1. 使用该 PsExec 实用程序将默认用户的用户名和密码存储在 LocalSystem 账户的凭据管理器实例中。*password*替换为您之前设置的用户密码。
```
psexec -s cmd /c cmdkey /generic:ggc_user /user:ggc_user /pass:password
```
如果系统打开 **PsExec License Agreement**，请选择 **Accept** 以同意许可并运行命令。
**注意**
在 Windows 设备上，该 LocalSystem 帐户运行 Greengrass 核心，您必须使用 PsExec 该实用程序在帐户中存储默认用户信息。 LocalSystem 使用凭据管理器应用程序将此信息存储在当前登录用户的 Windows 帐户中，而不是 LocalSystem 帐户中。
## 下载 AWS IoT Greengrass 核心软件
您可以从以下位置下载最新版本的 AWS IoT Greengrass Core 软件：
+ [https://d2s8p88vqu9w66.cloudfront。 net/releases/greengrass](https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip)-nucleus-latest.zip
**注意**
您可以从以下位置下载特定版本的 AWS IoT Greengrass Core 软件。*version*替换为要下载的版本。
```
https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-version.zip
```
**下载 AWS IoT Greengrass 核心软件**
1. 在您的核心设备上，将 AWS IoT Greengrass Core 软件下载到名为的文件中`greengrass-nucleus-latest.zip`。
------
#### [ Linux or Unix ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
iwr -Uri https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip -OutFile greengrass-nucleus-latest.zip
```
------
下载此软件即表示您同意[Greengrass Core 软件许可协议](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf)。
1. （可选）验证 Greengrass Nucleus 软件签名
**注意**
此功能适用于 Greengrass Nucleus 版本 2.9.5 及更高版本。
1. 使用以下命令验证您 Greengrass Nucleus 构件的签名：
------
#### [ Linux or Unix ]
```
jarsigner -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
根据您安装的 JDK 版本，文件名可能有所不同。将 *`jdk17.0.6_10`* 替换为您安装的 JDK 版本。
```
"C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe" -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
根据您安装的 JDK 版本，文件名可能有所不同。将 *`jdk17.0.6_10`* 替换为您安装的 JDK 版本。
```
'C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe' -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
1. `jarsigner` 调用会生成输出，指示验证结果。
1. 如果 Greengrass Nucleus ZIP 文件已签署，则输出将包含以下语句：
```
jar verified.
```
1. 如果 Greengrass Nucleus ZIP 文件未签署，则输出将包含以下语句：
```
jar is unsigned.
```
1. 如果您提供了 Jarsigner `-certs` 选项以及 `-verify` 和 `-verbose` 选项，则输出还将包含详细的签名者证书信息。
1. 将 AWS IoT Greengrass Core 软件解压缩到设备上的某个文件夹。*GreengrassInstaller*替换为要使用的文件夹。
------
#### [ Linux or Unix ]
```
unzip greengrass-nucleus-latest.zip -d GreengrassInstaller && rm greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
mkdir GreengrassInstaller && tar -xf greengrass-nucleus-latest.zip -C GreengrassInstaller && del greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
Expand-Archive -Path greengrass-nucleus-latest.zip -DestinationPath .\\GreengrassInstaller
rm greengrass-nucleus-latest.zip
```
------
1. （可选）运行以下命令以查看 AWS IoT Greengrass Core 软件的版本。
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
**重要**
如果您安装了 v2.4.0 之前的 Greengrass nucleus 版本，则在安装 Core 软件后请勿删除此文件夹。 AWS IoT Greengrass C AWS IoT Greengrass ore 软件使用此文件夹中的文件运行。
如果您下载的是最新版本的软件，则需要安装 v2.4.0 或更高版本，并且可以在安装 C AWS IoT Greengrass ore 软件后删除此文件夹。
## 安装 AWS IoT Greengrass 核心软件
使用可指定以下操作的参数运行安装程序：
+ 从部分配置文件进行安装，该文件指定使用您的自定义配置插件来配置 AWS 资源。 AWS IoT Greengrass Core 软件使用配置文件来指定设备上每个 Greengrass 组件的配置。安装程序根据您提供的部分配置文件和自定义配置插件创建的 AWS 资源创建完整的配置文件。
+ 指定使用 `ggc_user` 系统用户在核心设备上运行软件组件。在 Linux 设备上，此命令还指定使用 `ggc_group` 系统组，安装程序会为您创建系统用户和组。
+ 将 AWS IoT Greengrass Core 软件设置为启动时运行的系统服务。在 Linux 设备上，这需要 [Systemd](https://en.wikipedia.org/wiki/Systemd) 初始化系统。
**重要**
在 Windows 核心设备上，必须将 AWS IoT Greengrass 核心软件设置为系统服务。
有关您可以指定的参数的更多信息，请参阅[安装程序参数](configure-installer.md)。
**注意**
如果您在内存有限的设备 AWS IoT Greengrass 上运行，则可以控制 AWS IoT Greengrass 酷睿软件使用的内存量。要控制内存分配，您可以在 Nucleus 组件的 `jvmOptions` 配置参数中设置 JVM 堆大小选项。有关更多信息，请参阅 [使用 JVM 选项控制内存分配](configure-greengrass-core-v2.md#jvm-tuning)。
**安装 AWS IoT Greengrass 核心软件 (Linux)**
1. 检查 AWS IoT Greengrass 核心软件的版本。
+ *GreengrassInstaller*替换为包含该软件的文件夹的路径。
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
1. 使用文本编辑器创建名为 `config.yaml` 的配置文件，以提供给安装程序。
例如，在基于 Linux 的系统上，您可以运行以下命令来使用 GNU nano 创建该文件。
```
nano GreengrassInstaller/config.yaml
```
将以下 YAML 内容复制到该文件中。
```
---
system:
rootpath: "/greengrass/v2"
# The following values are optional. Return them from the provisioning plugin or set them here.
# certificateFilePath: ""
# privateKeyPath: ""
# rootCaPath: ""
# thingName: ""
services:
aws.greengrass.Nucleus:
version: "2.17.0"
configuration:
# The following values are optional. Return them from the provisioning plugin or set them here.
# awsRegion: ""
# iotRoleAlias: ""
# iotDataEndpoint: ""
# iotCredEndpoint: ""
com.example.CustomProvisioning:
configuration:
# You can specify configuration parameters to provide to your plugin.
# pluginParameter: ""
```
然后执行以下操作：
+ *2.17.0*替换为 AWS IoT Greengrass Core 软件的版本。
+ 将每个 `/greengrass/v2` 实例替换为 Greengrass 根文件夹。
+ （可选）指定系统和核心配置值。如果您的预置插件不提供这些值，则您必须设置这些值。
+ （可选）指定要提供给预置插件的配置参数。
**注意**
在此配置文件中，您可以自定义其他配置选项（例如要使用的端口和网络代理），如以下示例所示。有关更多信息，请参阅 [Greengrass Nucleus 配置](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration)。
```
---
system:
rootpath: "/greengrass/v2"
# The following values are optional. Return them from the provisioning plugin or set them here.
# certificateFilePath: ""
# privateKeyPath: ""
# rootCaPath: ""
# thingName: ""
services:
aws.greengrass.Nucleus:
version: "2.17.0"
configuration:
mqtt:
port: 443
greengrassDataPlanePort: 443
networkProxy:
noProxyAddresses: "http://192.168.0.1,www.example.com"
proxy:
url: "http://my-proxy-server:1100"
username: "Mary_Major"
password: "pass@word1357"
# The following values are optional. Return them from the provisioning plugin or set them here.
# awsRegion: ""
# iotRoleAlias: ""
# iotDataEndpoint: ""
# iotCredEndpoint: ""
com.example.CustomProvisioning:
configuration:
# You can specify configuration parameters to provide to your plugin.
# pluginParameter: ""
```
1. 运行安装程序。指定 `--trusted-plugin` 提供您的自定义预置插件，并指定 `--init-config` 提供配置文件。
**注意**
Windows 的路径长度限制为 260 个字符。如果您使用的是 Windows，请使用 `C:\greengrass\v2` 或 `D:\greengrass\v2` 等根文件夹，将 Greengrass 组件的路径保持在 260 个字符的限制以下。
+ 用 Greengrass 根文件夹替换`/greengrass/v2`或*C:\$1greengrass\$1v2*。
+ 将的*GreengrassInstaller*每个实例替换为解压安装程序所在的文件夹。
+ 将自定义预置插件 JAR 文件的路径替换为插件 JAR 文件的路径。
------
#### [ Linux or Unix ]
```
sudo -E java -Droot="/greengrass/v2" -Dlog.store=FILE \
-jar ./GreengrassInstaller/lib/Greengrass.jar \
--trusted-plugin /path/to/com.example.CustomProvisioning.jar \
--init-config ./GreengrassInstaller/config.yaml \
--component-default-user ggc_user:ggc_group \
--setup-system-service true
```
------
#### [ Windows Command Prompt (CMD) ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" ^
-jar ./GreengrassInstaller/lib/Greengrass.jar ^
--trusted-plugin /path/to/com.example.CustomProvisioning.jar ^
--init-config ./GreengrassInstaller/config.yaml ^
--component-default-user ggc_user ^
--setup-system-service true
```
------
#### [ PowerShell ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" `
-jar ./GreengrassInstaller/lib/Greengrass.jar `
--trusted-plugin /path/to/com.example.CustomProvisioning.jar `
--init-config ./GreengrassInstaller/config.yaml `
--component-default-user ggc_user `
--setup-system-service true
```
------
**重要**
在 Windows 核心设备上，`--setup-system-service true`必须指定将 AWS IoT Greengrass 核心软件设置为系统服务。
如果指定 `--setup-system-service true`，则安装程序会在将软件设置为系统服务并运行后打印 `Successfully set up Nucleus as a system service`。否则，如果安装程序成功安装软件，则不会输出任何消息。
**注意**
在没有 `deploy-dev-tools` 参数的情况下运行安装程序时，您不能使用 `--provision true` 参数来部署本地开发工具。有关直接在您的设备上部署 Greengrass CLI 的信息，请参阅 [Greengrass 命令行界面](gg-cli.md)。
1. 通过查看根文件夹中的文件来验证安装情况。
------
#### [ Linux or Unix ]
```
ls /greengrass/v2
```
------
#### [ Windows Command Prompt (CMD) ]
```
dir C:\greengrass\v2
```
------
#### [ PowerShell ]
```
ls C:\greengrass\v2
```
------
如果安装成功，则根文件夹中包含多个文件夹，例如 `config`、`packages` 和 `logs`。
如果您将 AWS IoT Greengrass Core 软件作为系统服务安装，则安装程序会为您运行该软件。否则，您必须手动运行该软件。有关更多信息，请参阅 [运行 AWS IoT Greengrass 核心软件](run-greengrass-core-v2.md)。
有关如何配置和使用软件的更多信息 AWS IoT Greengrass，请参阅以下内容：
+ [配置 AWS IoT Greengrass 核心软件](configure-greengrass-core-v2.md)
+ [开发 AWS IoT Greengrass 组件](develop-greengrass-components.md)
+ [将 AWS IoT Greengrass 组件部署到设备](manage-deployments.md)
+ [Greengrass 命令行界面](gg-cli.md)
# 开发自定义预置插件
要开发自定义预置插件，请创建实现该 `com.aws.greengrass.provisioning.DeviceIdentityInterface` 接口的 Java 类。您可以在项目中包含 Greengrass Nucleus JAR 文件来访问此接口及其类。此接口定义了一种输入插件配置并输出预置配置的方法。预置配置定义了系统和 [Greengrass Nucleus 组件](greengrass-nucleus-component.md)的配置。C AWS IoT Greengrass ore 软件安装程序使用此配置在设备上配置 AWS IoT Greengrass Core 软件。
开发自定义配置插件后，将其构建为 JAR 文件，您可以将其提供给 AWS IoT Greengrass Core 软件安装程序，以便在安装期间运行您的插件。安装程序在其使用的同一 JVM 中运行您的自定义配置插件，因此您可以创建仅包含插件代码的 JAR。
**注意**
[AWS IoT 实例集预置插件](fleet-provisioning.md)在安装过程中实现 `DeviceIdentityInterface`，以使用实例集预置。实例集预置插件是开源的，因此您可以浏览其源代码，查看预置插件接口使用示例。有关更多信息，请参阅上的[AWS IoT 舰队配置插件](https://github.com/aws-greengrass/aws-greengrass-fleet-provisioning-by-claim) GitHub。
**Topics**
+ [要求](#custom-provisioning-plugin-requirements)
+ [实现接 DeviceIdentityInterface 口](#implement-device-identity-interface)
## 要求
要开发自定义预置插件，必须创建满足以下要求的 Java 类：
+ 使用 `com.aws.greengrass` 程序包或 `com.aws.greengrass` 中的程序包。
+ 有一个不带任何参数的构造函数。
+ 实现 `DeviceIdentityInterface` 接口。有关更多信息，请参阅 [实现接 DeviceIdentityInterface 口](#implement-device-identity-interface)。
## 实现接 DeviceIdentityInterface 口
要在自定义插件中使用该 `com.aws.greengrass.provisioning.DeviceIdentityInterface` 接口，请将 Greengrass Nucleus 作为依赖关系添加到您的项目中。
**DeviceIdentityInterface 在自定义配置插件项目中使用**
+ 您可以将 Greengrass Nucleus JAR 文件添加为库，也可以将 Greengrass Nucleus 作为 Maven 依赖关系添加。请执行以下操作之一：
+ 要将 Greengrass nucleus JAR 文件添加为库，请下载包含 Greengrass nucleus JAR AWS IoT Greengrass 的核心软件。您可以从以下位置下载最新版本的 AWS IoT Greengrass Core 软件：
+ [https://d2s8p88vqu9w66.cloudfront。 net/releases/greengrass](https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip)-nucleus-latest.zip
您可以在 ZIP 文件的 `lib` 文件夹中找到 Greengrass Nucleus JAR 文件（`Greengrass.jar`）。将此 JAR 文件添加到您的项目中。
+ 要在 Maven 项目中使用 Greengrass Nucleus，请在 `com.aws.greengrass` 组中添加 `nucleus` 构件依赖关系。您还须添加 `greengrass-common` 存储库，因为 Greengrass Nucleus 在 Maven 中央存储库中不可用。
```
...
greengrass-common
greengrass common
https://d2jrmugq4soldf.cloudfront.net/snapshots
...
com.aws.greengrass
nucleus
2.5.0-SNAPSHOT
provided
```
### 该 DeviceIdentityInterface 接口
`com.aws.greengrass.provisioning.DeviceIdentityInterface` 接口具有以下形态。
**注意**
[你也可以在 Greengrass nucleus 源代码的 [com.aws.greengrass.provisioning 包](https://github.com/aws-greengrass/aws-greengrass-nucleus/tree/main/src/main/java/com/aws/greengrass/provisioning)中探索这些类。](https://github.com/aws-greengrass/aws-greengrass-nucleus) GitHub
```
public interface com.aws.greengrass.provisioning.DeviceIdentityInterface {
ProvisionConfiguration updateIdentityConfiguration(ProvisionContext context)
throws RetryableProvisioningException, InterruptedException;
// Return the name of the plugin.
String name();
}
com.aws.greengrass.provisioning.ProvisionConfiguration {
SystemConfiguration systemConfiguration;
NucleusConfiguration nucleusConfiguration
}
com.aws.greengrass.provisioning.ProvisionConfiguration.SystemConfiguration {
String certificateFilePath;
String privateKeyPath;
String rootCAPath;
String thingName;
}
com.aws.greengrass.provisioning.ProvisionConfiguration.NucleusConfiguration {
String awsRegion;
String iotCredentialsEndpoint;
String iotDataEndpoint;
String iotRoleAlias;
}
com.aws.greengrass.provisioning.ProvisioningContext {
Map parameterMap;
String provisioningPolicy; // The policy is always "PROVISION_IF_NOT_PROVISIONED".
}
com.aws.greengrass.provisioning.exceptions.RetryableProvisioningException {}
```
`SystemConfiguration`和中的每个配置值`NucleusConfiguration`都是安装 AWS IoT Greengrass 核心软件所必需的，但您可以返回`null`。如果您的自定义配置插件返回`null`任何配置值，则在创建要提供给 C AWS IoT Greengrass ore 软件安装程序`config.yaml`的文件时，必须在系统或 nucleus 配置中提供该值。如果您的自定义预置插件为您在 `config.yaml` 中也定义的选项返回一个非空值，则安装程序会用插件返回的值替换 `config.yaml` 中的值。
# 安装程序参数
AWS IoT Greengrass Core 软件包含一个安装程序，用于设置软件并预置 Greengrass 核心设备运行所需的 AWS 资源。该安装程序包含以下参数，您可以指定这些参数来配置安装：
`-h`, `--help`
（可选）显示安装程序的帮助信息。
`--version`
（可选）显示 AWS IoT Greengrass Core 软件的版本。
`-Droot`
（可选）用作 AWS IoT Greengrass Core 软件根目录的文件夹路径。
此参数会设置一个 JVM 属性，因此在运行安装程序时，必须在 `-jar` 前指定该属性。例如，指定 `java -Droot="/greengrass/v2" -jar /path/to/Greengrass.jar`。
默认值：
+ Linux：`~/.greengrass`
+ Windows：`%USERPROFILE%/.greengrass`
`-ar`, `--aws-region`
AWS IoT Greengrass Core 软件用来检索或创建其所需 AWS 资源的 AWS 区域。
`-p`, `--provision`
（可选）您可以将此设备注册为 AWS IoT 事物，并预置核心设备所需的 AWS 资源。如果您指定 `true`，则 AWS IoT Greengrass Core 软件会预置一个 AWS IoT 事物、（可选）一个 AWS IoT 事物组、一个 IAM 角色和一个 AWS IoT 角色别名。
默认值：`false`
`-tn`, `--thing-name`
（可选）您注册为此核心设备的 AWS IoT 事物的名称。如果您的 AWS 账户 中不存在具有该名称的事物，则 AWS IoT Greengrass Core 软件会自行创建。
事物名称不得包含英文冒号 (`:`) 字符。
必须指定 `--provision true` 才能应用此参数。
默认值：`GreengrassV2IotThing_` 加一个随机 UUID。
`-tgn`, `--thing-group-name`
（可选）您在其中添加此核心设备的 AWS IoT 事物的 AWS IoT 事物组的名称。如果部署以该事物组为目标，则此核心设备在连接到 AWS IoT Greengrass 时会收到该部署。如果您的 AWS 账户 中不存在具有该名称的事物组，则 AWS IoT Greengrass Core 软件会自行创建。
事物组名称不得包含英文冒号 (`:`) 字符。
必须指定 `--provision true` 才能应用此参数。
`-tpn`, `--thing-policy-name`
此功能适用于 [Greengrass Nucleus 组件](greengrass-nucleus-component.md)的 v2.4.0 及更高版本。
（可选）要附加到此核心设备的 AWS IoT 事物证书的 AWS IoT 策略的名称。如果您的 AWS 账户中不存在具有该名称的 AWS IoT 策略，则 AWS IoT Greengrass Core 软件会自行创建。
默认情况下，AWS IoT Greengrass Core 软件会创建宽松的 AWS IoT 策略。您可以缩小此策略的范围，也可以创建自定义策略来限制使用案例的权限。有关更多信息，请参阅[AWS IoT Greengrass V2 核心设备的最低 AWS IoT 政策](device-auth.md#greengrass-core-minimal-iot-policy)。
必须指定 `--provision true` 才能应用此参数。
默认值：`GreengrassV2IoTThingPolicy`
`-trn`, `--tes-role-name`
（可选）用于获取允许核心设备与 AWS 服务交互的 AWS 凭证的 IAM 角色的名称。如果您的 AWS IoT Greengrass 中不存在具有该名称的角色，则 AWS 账户 Core 软件会使用 `GreengrassV2TokenExchangeRoleAccess` 策略自行创建。此角色无权访问您用于托管组件构件的 S3 存储桶。因此，在创建组件时，您必须为构件的 S3 存储桶和对象添加权限。有关更多信息，请参阅[授权核心设备与 AWS 服务交互](device-service-role.md)。
必须指定 `--provision true` 才能应用此参数。
默认值：`GreengrassV2TokenExchangeRole`
`-tra`, `--tes-role-alias-name`
（可选）指向为该核心设备提供 AWS 凭证的 IAM 角色的 AWS IoT 角色别名的名称。如果您的 AWS 账户 中不存在具有该名称的角色别名，则 AWS IoT Greengrass Core 软件会自行创建，并将其指向您指定的 IAM 角色。
必须指定 `--provision true` 才能应用此参数。
默认值：`GreengrassV2TokenExchangeRoleAlias`
`-ss`, `--setup-system-service`
（可选）您可以将 AWS IoT Greengrass Core 软件设置为在该设备开机时运行的系统服务。系统服务名称为 `greengrass`。有关更多信息，请参阅[将 Greengrass Nucleus 配置为系统服务](configure-greengrass-core-v2.md#configure-system-service)。
在 Linux 操作系统上，此参数要求设备上具有 systemd 初始化系统。
在 Windows 核心设备上，必须将 AWS IoT Greengrass Core 软件设置为系统服务。
默认值：`false`
`-u`, `--component-default-user`
AWS IoT Greengrass Core 软件用于运行组件的用户的名称或 ID。例如，您可以指定 **ggc\$1user**。在 Windows 操作系统上运行安装程序时，必须使用此值。
在 Linux 操作系统上，您还可以选择指定组。指定用户和组，用英文冒号分隔。例如 **ggc\$1user:ggc\$1group**。
以下更多注意事项适用于 Linux 操作系统：
+ 如果您以根用户身份运行，则默认组件用户是在配置文件中定义的用户。如果配置文件未定义用户，则默认为 `ggc_user:ggc_group`。如果 `ggc_user` 或 `ggc_group` 不存在，则软件将自行创建。
+ 如果您以非根用户身份运行，则 AWS IoT Greengrass Core 软件会使用该用户来运行组件。
+ 如果您未指定组，则 AWS IoT Greengrass Core 软件会使用系统用户的主要组。
有关更多信息，请参阅[配置运行组件的用户](configure-greengrass-core-v2.md#configure-component-user)。
`-d`, `--deploy-dev-tools`
（可选）您可以将 [Greengrass CLI](greengrass-cli-component.md) 组件下载并部署到此核心设备上。您可以使用此工具来开发和调试此核心设备。
我们建议您仅在开发环境中使用此组件，不要在生产环境中使用。此组件允许访问您在生产环境中通常不需要的信息和操作。遵循最低权限原则，将此组件仅部署到有需求的核心设备。
必须指定 `--provision true` 才能应用此参数。
默认值：`false`
`-init`, `--init-config`
（可选）用于安装 AWS IoT Greengrass Core 软件的配置文件的路径。例如，您可以使用此选项来设置具有特定内核配置的新核心设备。
您指定的配置文件与核心设备上现有的配置文件合并。这包括核心设备上的组件和组件配置。我们建议配置文件仅列出您正在尝试更改的配置。
`-tp`, `--trusted-plugin`
（可选）要作为可信插件加载的 JAR 文件的路径。使用此选项提供预置插件 JAR 文件，例如使用[实例集预置](fleet-provisioning.md)或[自定义预置](custom-provisioning.md)进行安装，或者使用私有密钥和证书安装在[硬件安全模块](hardware-security.md)中。
`-s`, `--start`
（可选）您可以在安装 AWS IoT Greengrass Core 软件后启动该软件，也可以选择预置资源。
默认值：`true`
# 运行 AWS IoT Greengrass 核心软件
[安装 AWS IoT Greengrass Core 软件](install-greengrass-core-v2.md)后，运行它以将您的设备连接到 AWS IoT Greengrass。
在安装 AWS IoT Greengrass Core 软件时，可以指定是否将其作为系统服务与 [systemd](https://en.wikipedia.org/wiki/Systemd) 一起安装。如果您选择此选项，则安装程序会为您运行该软件，并将其配置为在设备启动时运行。
**重要**
在 Windows 核心设备上，必须将 AWS IoT Greengrass 核心软件设置为系统服务。
**Topics**
+ [检查 AWS IoT Greengrass Core 软件是否作为系统服务运行](#check-system-service)
+ [将 AWS IoT Greengrass Core 软件作为系统服务运行](#run-greengrass-core-system-service)
+ [在没有系统服务的情况下运行 C AWS IoT Greengrass ore 软件](#run-greengrass-core-no-system-service)
## 检查 AWS IoT Greengrass Core 软件是否作为系统服务运行
安装 AWS IoT Greengrass Core 软件时，可以指定将 AWS IoT Greengrass 核心软件安装为系统服务的`--setup-system-service true`参数。Linux 设备需要 [systemd](https://en.wikipedia.org/wiki/Systemd) 初始化系统才能将 AWS IoT Greengrass 核心软件设置为系统服务。如果您使用此选项，则安装程序会为您运行该软件，并将其配置为在设备启动时运行。如果安装程序成功将 C AWS IoT Greengrass ore 软件安装为系统服务，则会输出以下消息。
```
Successfully set up Nucleus as a system service
```
如果您之前安装了 AWS IoT Greengrass Core 软件但没有安装程序输出，则可以检查该软件是否作为系统服务安装。
**检查 AWS IoT Greengrass Core 软件是否作为系统服务安装**
+ 运行以下命令以查看 Greengrass 系统服务的状态。
------
#### [ Linux or Unix (systemd) ]
```
sudo systemctl status greengrass.service
```
如果 C AWS IoT Greengrass ore 软件作为系统服务安装并处于活动状态，则响应类似于以下示例。
```
● greengrass.service - Greengrass Core
Loaded: loaded (/etc/systemd/system/greengrass.service; enabled; vendor preset: disabled)
Active: active (running) since Thu 2021-02-11 01:33:44 UTC; 4 days ago
Main PID: 16107 (sh)
CGroup: /system.slice/greengrass.service
├─16107 /bin/sh /greengrass/v2/alts/current/distro/bin/loader
└─16111 java -Dlog.store=FILE -Droot=/greengrass/v2 -jar /greengrass/v2/alts/current/distro/lib/Greengrass...
```
如果`greengrass.service`未找到`systemctl`或未找到，则 AWS IoT Greengrass Core 软件不会作为系统服务安装。要运行 [在没有系统服务的情况下运行 C AWS IoT Greengrass ore 软件](#run-greengrass-core-no-system-service)软件，请参阅。
------
#### [ Windows Command Prompt (CMD) ]
```
sc query greengrass
```
如果 C AWS IoT Greengrass ore 软件作为 Windows 服务安装并处于活动状态，则响应类似于以下示例。
```
SERVICE_NAME: greengrass
TYPE : 10 WIN32_OWN_PROCESS
STATE : 4 RUNNING
(STOPPABLE, NOT_PAUSABLE, ACCEPTS_SHUTDOWN)
WIN32_EXIT_CODE : 0 (0x0)
SERVICE_EXIT_CODE : 0 (0x0)
CHECKPOINT : 0x0
WAIT_HINT : 0x0
```
------
#### [ PowerShell ]
```
Get-Service greengrass
```
如果 C AWS IoT Greengrass ore 软件作为 Windows 服务安装并处于活动状态，则响应类似于以下示例。
```
Status Name DisplayName
------ ---- -----------
Running greengrass greengrass
```
------
## 将 AWS IoT Greengrass Core 软件作为系统服务运行
如果将 AWS IoT Greengrass Core 软件作为系统服务安装，则可以使用系统服务管理器启动、停止和管理该软件。有关更多信息，请参阅 [将 Greengrass Nucleus 配置为系统服务](configure-greengrass-core-v2.md#configure-system-service)。
**运行 AWS IoT Greengrass 核心软件**
+ 运行以下命令以启动 AWS IoT Greengrass Core 软件。
------
#### [ Linux or Unix (systemd) ]
```
sudo systemctl start greengrass.service
```
------
#### [ Windows Command Prompt (CMD) ]
```
sc start greengrass
```
------
#### [ PowerShell ]
```
Start-Service greengrass
```
------
## 在没有系统服务的情况下运行 C AWS IoT Greengrass ore 软件
在 Linux 核心设备上，如果 AWS IoT Greengrass 核心软件未作为系统服务安装，则可以运行该软件的加载器脚本来运行该软件。
**在没有系统服务的情况下运行 AWS IoT Greengrass Core 软件**
+ 运行以下命令以启动 AWS IoT Greengrass Core 软件。如果您在终端中运行此命令，则必须保持终端会话处于打开状态，以保持 AWS IoT Greengrass Core 软件的运行。
+ 将`/greengrass/v2`或*C:\$1greengrass\$1v2*替换为您使用的 Greengrass 根文件夹。
```
sudo /greengrass/v2/alts/current/distro/bin/loader
```
如果软件成功启动，则会打印以下消息。
```
Launched Nucleus successfully.
```
# 在 Docker 容器中运行 AWS IoT Greengrass 核心软件
AWS IoT Greengrass 可以配置为在 Docker 容器中运行。Docker 是一个平台，为您提供了构建、运行、测试和部署基于 Linux 容器的应用程序的工具。运行 AWS IoT Greengrass Docker 镜像时，您可以选择是否向 Docker 容器提供 AWS 凭据，并允许 C AWS IoT Greengrass ore 软件安装程序自动配置 Greengrass 核心设备运行 AWS 所需的资源。如果您不想提供 AWS 凭证，则可以手动配置 AWS 资源并在 Docker 容器中运行 C AWS IoT Greengrass ore 软件。
**Topics**
+ [支持的平台和要求](#greengrass-docker-supported-platforms)
+ [软件下载](#greengrass-docker-downloads)
+ [选择如何配置 AWS 资源](#greengrass-docker-resource-provisioning)
+ [从 Dockerfile 中生成 AWS IoT Greengrass 镜像](build-greengrass-dockerfile.md)
+ [通过自动 AWS IoT Greengrass 配置在 Docker 中运行](run-greengrass-docker-automatic-provisioning.md)
+ [使用手动 AWS IoT Greengrass 配置在 Docker 中运行](run-greengrass-docker-manual-provisioning.md)
+ [在 Docker AWS IoT Greengrass 容器中进行故障排除](docker-troubleshooting.md)
## 支持的平台和要求
主机必须满足以下最低要求才能在 Docker 容器中安装和运行 C AWS IoT Greengrass ore 软件：
+ 支持互联网连接的基于 Linux 的操作系统。
+ [Docker Engine](https://docs.docker.com/engine/install/) 18.09 版本或更高版本。
+ （可选）[Docker Compose](https://docs.docker.com/compose/install/) 1.22 版本或更高版本。只有当您想使用 Docker Compose CLI 来运行 Docker 映像时，才需要 Docker Compose。
要在 Docker 容器内运行 Lambda 函数组件，必须配置容器以满足其它要求。有关更多信息，请参阅[Lambda 函数要求](setting-up.md#greengrass-v2-lambda-requirements)。
### 在进程模式下运行组件
AWS IoT Greengrass 不支持在 Docker 容器内的隔离运行时环境中运行 Lambda 函数或 AWS提供的组件。 AWS IoT Greengrass 您必须在没有任何隔离的情况下在进程模式下运行这些组件。
配置 Lambda 函数组件时，请将隔离模式设置为**无容器**。有关更多信息，请参阅 [运行 AWS Lambda 函数](run-lambda-functions.md)。
部署以下任何 AWS提供的组件时，请更新要将`containerMode`参数设置为的每个组件的配置。`NoContainer`有关配置更新的更多信息，请参阅[更新组件配置](update-component-configurations.md)。
+ [CloudWatch metrics](cloudwatch-metrics-component.md)
+ [Device Defender](device-defender-component.md)
+ [Firehose](kinesis-firehose-component.md)
+ [Modbus-RTU 协议适配器](modbus-rtu-protocol-adapter-component.md)
+ [Amazon SNS](sns-component.md)
## AWS IoT Greengrass Docker 软件下载
AWS IoT Greengrass 提供了 Dockerfile 来构建在亚马逊 Linux 2 (x86\$164) 基础映像上安装了 AWS IoT Greengrass 核心软件和依赖项的容器镜像。您可以修改 Dockerfile 中的基础映像，使其在不同的平台架构 AWS IoT Greengrass 上运行。
从中下载 Dockerfile 软件包。[GitHub](https://github.com/aws-greengrass/aws-greengrass-docker)
Dockerfile 使用的是旧版本的 Greengrass。您应该更新文件，以使用您需要的 Greengrass 版本。有关从 Dockerfile 构建 AWS IoT Greengrass 容器镜像的信息，请参阅。[从 Dockerfile 中构建 AWS IoT Greengrass 容器镜像](build-greengrass-dockerfile.md)
## 选择如何配置 AWS 资源
在 Docker 容器中安装 AWS IoT Greengrass 核心软件时，您可以选择是自动配置 Greengrass 核心设备运行所需的 AWS 资源，还是使用手动配置的资源。
+ **自动资源预置**-当您首次运行 AWS IoT Greengrass 容器映像时，安装程序会预置 AWS IoT 事物、事物组、IAM AWS IoT 角色和角色别名。 AWS IoT 安装程序还可以将本地开发工具部署到核心设备，因此您可以使用该设备开发和测试自定义软件组件。要选择自动预置这些资源，您必须向 Docker 映像提供 AWS 凭证作为环境变量。
要使用自动预置，您必须设置 Docker 环境变量 `PROVISION=true` 并挂载凭证文件，才能为容器提供 AWS 凭证。
+ **手动资源配置**-如果您不想为容器提供 AWS 凭证，则可以在运行 AWS IoT Greengrass 容器映像之前手动配置 AWS 资源。您必须创建配置文件，以便向 Docker 容器中的 C AWS IoT Greengrass ore 软件安装程序提供有关这些资源的信息。
要使用手动预置，您必须设置 Docker 环境变量 `PROVISION=false`。手动预置是默认选项。
有关更多信息，请参阅[从 Dockerfile 中构建 AWS IoT Greengrass 容器镜像](build-greengrass-dockerfile.md)。
# 从 Dockerfile 中构建 AWS IoT Greengrass 容器镜像
AWS 提供了一个 Dockerfile，你可以下载并使用它来在 Docker AWS IoT Greengrass 容器中运行核心软件。Dockerfiles 包含用于构建 AWS IoT Greengrass 容器镜像的源代码。
在构建 AWS IoT Greengrass 容器镜像之前，必须配置 Dockerfile 以选择要安装的 AWS IoT Greengrass 核心软件版本。您还可以配置环境变量以选择在安装过程中如何配置资源，并自定义其他安装选项。本节介绍如何从 Dockerfile 配置和构建 AWS IoT Greengrass Docker 镜像。
## 下载 Dockerfile 包
你可以从以下网址下载 AWS IoT Greengrass Dockerfile 软件包： GitHub
[AWS Greengrass Docker 存储库](https://github.com/aws-greengrass/aws-greengrass-docker)
下载包后，将内容解提取到计算机上的 `download-directory/aws-greengrass-docker-nucleus-version` 文件夹。Dockerfile 使用的是旧版本的 Greengrass。您应该更新文件，以使用您需要的 Greengrass 版本。
## 指定 AWS IoT Greengrass 核心软件版本
在 Dockerfile 中使用以下构建参数来指定要在 Doc AWS IoT Greengrass ker 镜像中使用的 AWS IoT Greengrass 核心软件的版本。默认情况下，Dockerfile 使用最新版本的 AWS IoT Greengrass 核心软件。
`GREENGRASS_RELEASE_VERSION`
AWS IoT Greengrass 核心软件的版本。默认情况下，Dockerfile 会下载 Greengrass Nucleus 的最新可用版本。将值设置为您要下载的 Nucleus 的版本。
## 设置环境变量
环境变量使您可以自定义 C AWS IoT Greengrass ore 软件在 Docker 容器中的安装方式。您可以通过多种方式为 AWS IoT Greengrass Docker 镜像设置环境变量。
+ 要使用相同的环境变量来创建多个映像，请直接在 Dockerfile 中设置环境变量。
+ 如果您使用 `docker run` 启动容器，请在命令中将环境变量作为参数进行传递，或者在环境变量文件中设置环境变量，然后将该文件作为参数进行传递。有关在 Docker 中设置环境变量的更多信息，请参阅 Docker 文档中的[环境变量](https://docs.docker.com/engine/reference/commandline/run/#env)。
+ 如果您使用 `docker-compose up` 启动容器，请在环境变量文件中设置环境变量，然后将该文件作为参数进行传递。有关在 Compose 中设置环境变量的更多信息，请参阅 [Docker 文档](https://docs.docker.com/compose/environment-variables/)。
您可以为 AWS IoT Greengrass Docker 镜像配置以下环境变量。
**注意**
不要修改 Dockerfile 中的 `TINI_KILL_PROCESS_GROUP` 变量。此变量允许转发`SIGTERM`给 PID 组 PIDs 中的所有人，这样 C AWS IoT Greengrass ore 软件就可以在 Docker 容器停止时正确关闭。
`GGC_ROOT_PATH`
（可选）容器内用作 AWS IoT Greengrass 核心软件根目录的文件夹的路径。
默认值：`/greengrass/v2`
`PROVISION`
（可选）确定 AWS IoT Greengrass 核心是否提供 AWS 资源。
+ 如果您指定`true`， AWS IoT Greengrass Core 软件会将容器镜像注册为 AWS IoT 事物，并配置 Greengrass 核心设备 AWS 所需的资源。 AWS IoT Greengrass Core 软件预置 AWS IoT 事物、（可选） AWS IoT 事物组、IAM 角色和 AWS IoT 角色别名。有关更多信息，请参阅 [AWS IoT Greengrass 在具有自动资源配置功能的 Docker 容器中运行](run-greengrass-docker-automatic-provisioning.md)。
+ 如果您指定`false`，则必须创建一个配置文件以提供给 AWS IoT Greengrass Core 安装程序，该文件指定使用您手动创建的 AWS 资源和证书。有关更多信息，请参阅 [AWS IoT Greengrass 在 Docker 容器中运行，手动配置资源](run-greengrass-docker-manual-provisioning.md)。
默认值：`false`
`AWS_REGION`
（可选） AWS IoT Greengrass Core 软件用于检索或创建所需 AWS 资源的。 AWS 区域
默认值：`us-east-1`。
`THING_NAME`
（可选）您注册为该核心设备的设备名称。 AWS IoT 如果你的名字中不存在带有这个名字的东西 AWS 账户， AWS IoT Greengrass Core 软件就会创建它。
您必须指定 `PROVISION=true` 才能应用此参数。
默认值：`GreengrassV2IotThing_` 加一个随机 UUID。
`THING_GROUP_NAME`
（可选）在其中添加此核心设备 AWS IoT 的事物组的名称。 AWS IoT 如果部署以该事物组为目标，则该设备和该组中的其他核心设备在连接到时会收到该部署 AWS IoT Greengrass。如果您中不存在具有此名称的事物组 AWS 账户，则 AWS IoT Greengrass Core 软件会创建它。
您必须指定 `PROVISION=true` 才能应用此参数。
`TES_ROLE_NAME`
（可选）用于获取允许 Greengrass 核心设备与服务交互的 AWS 证书的 IAM 角色名称。 AWS 如果您的角色中不存在具有此名称的角色 AWS 账户，则 AWS IoT Greengrass 核心软件会使用`GreengrassV2TokenExchangeRoleAccess`策略创建该角色。此角色无权访问您用于托管组件构件的 S3 存储桶。因此，在创建组件时，您必须为构件的 S3 存储桶和对象添加权限。有关更多信息，请参阅 [授权核心设备与 AWS 服务交互](device-service-role.md)。
默认值：`GreengrassV2TokenExchangeRole`
`TES_ROLE_ALIAS_NAME`
（可选）指向 IAM AWS IoT 角色的角色别名的名称，该角色为 Greengrass 核心设备提供 AWS 证书。如果您的中不存在具有此名称的角色别名 AWS 账户，则 AWS IoT Greengrass Core 软件会创建该别名并将其指向您指定的 IAM 角色。
默认值：`GreengrassV2TokenExchangeRoleAlias`
`COMPONENT_DEFAULT_USER`
（可选） AWS IoT Greengrass 核心软件用于运行组件的系统用户和组的名称或 ID。指定用户和组，用冒号分隔。组是可选的。举例来说，可以指定 **ggc\$1user:ggc\$1group** 或 **ggc\$1user**。
+ 如果您以根用户身份运行，则默认为配置文件定义的用户和组。如果配置文件未定义用户和组，则默认为 `ggc_user:ggc_group`。如果 `ggc_user` 或 `ggc_group` 不存在，则软件将自行创建。
+ 如果您以非 root 用户身份运行，则 AWS IoT Greengrass Core 软件将使用该用户来运行组件。
+ 如果您未指定组，则 AWS IoT Greengrass Core 软件将使用系统用户的主组。
有关更多信息，请参阅 [配置运行组件的用户](configure-greengrass-core-v2.md#configure-component-user)。
`DEPLOY_DEV_TOOLS`
定义是否在容器映像中下载和部署 [Greengrass CLI 组件](greengrass-cli-component.md)。您可以使用 Greengrass CLI 在本地开发和调试组件。
我们建议您仅在开发环境中使用此组件，不要在生产环境中使用。此组件允许访问您在生产环境中通常不需要的信息和操作。遵循最低权限原则，将此组件仅部署到有需求的核心设备。
默认值：`false`
`INIT_CONFIG`
（可选）用于安装 AWS IoT Greengrass 核心软件的配置文件的路径。例如，您可以使用此选项来设置具有特定内核配置的新 Greengrass 核心设备，或者指定手动预置的资源。您必须将配置文件装载到此参数中指定的路径。
`TRUSTED_PLUGIN`
此功能适用于 [Greengrass Nucleus 组件](greengrass-nucleus-component.md)的 v2.4.0 及更高版本。
（可选）要作为可信插件加载的 JAR 文件的路径。使用此选项可提供预置插件 JAR 文件，例如使用[队列预置](fleet-provisioning.md)或[自定义预置](custom-provisioning.md)进行安装。
`THING_POLICY_NAME`
此功能适用于 [Greengrass Nucleus 组件](greengrass-nucleus-component.md)的 v2.4.0 及更高版本。
（可选）要附加到该核心设备 AWS IoT 的事物证书的 AWS IoT 策略名称。如果您的 Core 软件中不存在带有此名称的 AWS IoT 策略，则 AWS 账户 该策略将由 AWS IoT Greengrass 核心软件创建。
您必须指定 `PROVISION=true` 才能应用此参数。
默认情况下， AWS IoT Greengrass Core 软件会创建宽松 AWS IoT 策略。您可以缩小此策略的范围，也可以创建自定义策略来限制使用案例的权限。有关更多信息，请参阅 [AWS IoT Greengrass V2 核心设备的最低 AWS IoT 政策](device-auth.md#greengrass-core-minimal-iot-policy)。
## 指定要安装的依赖关系
AWS IoT Greengrass Dockerfile 中的 RUN 指令为运行 AWS IoT Greengrass 核心软件安装程序做好了容器环境的准备。在 AWS IoT Greengrass Core 软件安装程序在 Docker 容器中运行之前，您可以自定义安装的依赖关系。
## 构建 AWS IoT Greengrass 镜像
使用 AWS IoT Greengrass Dockerfile 来构建 AWS IoT Greengrass 容器镜像。您可以使用 Docker CLI 或 Docker Compose CLI 来构建映像并启动容器。您还可以使用 Docker CLI 来构建映像，然后使用 Docker Compose 从该映像启动您的容器。
------
#### [ Docker ]
1. 在主机上，运行以下命令以切换到包含已配置 Dockerfile 的目录。
```
cd download-directory/aws-greengrass-docker-nucleus-version
```
1. 运行以下命令从 Dockerfile 构建 AWS IoT Greengrass 容器镜像。
```
sudo docker build -t "platform/aws-iot-greengrass:nucleus-version" ./
```
------
#### [ Docker Compose ]
1. 在主机上，运行以下命令以切换到包含 Dockerfile 和 Compose 文件的目录。
```
cd download-directory/aws-greengrass-docker-nucleus-version
```
1. 运行以下命令以使用 Compose 文件构建 AWS IoT Greengrass 容器镜像。
```
docker-compose -f docker-compose.yml build
```
------
您已成功创建 AWS IoT Greengrass 容器镜像。Docker 镜像安装了 AWS IoT Greengrass 核心软件。现在，您可以在 Docker 容器中运行 AWS IoT Greengrass 核心软件。
# AWS IoT Greengrass 在具有自动资源配置功能的 Docker 容器中运行
本教程向您展示如何使用自动配置的 AWS 资源和本地开发工具在 Docker 容器中安装和运行 C AWS IoT Greengrass ore 软件。您可以使用此开发环境来探索 Docker 容器中的 AWS IoT Greengrass 功能。该软件要求提供 AWS 凭证来配置这些资源及部署本地开发工具。
如果您无法向容器提供 AWS 凭证，则可以预配置核心设备运行所需的 AWS 资源。您还可以将开发工具部署到核心设备上，用作开发设备。这使您能够在运行容器时向设备提供较少的权限。有关更多信息，请参阅[AWS IoT Greengrass 在 Docker 容器中运行，手动配置资源](run-greengrass-docker-manual-provisioning.md)。
## 先决条件
要完成本教程，您需要以下要素。
+ 一个 AWS 账户。如果没有，请参阅[设置一个 AWS 账户](setting-up.md#set-up-aws-account)。
+ 有权为 AWS Greengrass 核心设备配置 AWS IoT 和 IAM 资源的 IAM 用户。C AWS IoT Greengrass ore 软件安装程序使用您的 AWS 凭据自动配置这些资源。有关自动预置资源的最低 IAM 策略的信息，请参阅[安装程序配置资源的最低 IAM 策略](provision-minimal-iam-policy.md)。
+ 一张 AWS IoT Greengrass Docker 镜像。你可以[从 AWS IoT Greengrass Dockerfile 中生成镜像](build-greengrass-dockerfile.md)。
+ 运行 Docker 容器的主机必须满足以下要求：
+ 支持互联网连接的基于 Linux 的操作系统。
+ [Docker Engine](https://docs.docker.com/engine/install/) 18.09 版本或更高版本。
+ （可选）[Docker Compose](https://docs.docker.com/compose/install/) 1.22 版本或更高版本。只有当您想使用 Docker Compose CLI 来运行 Docker 映像时，才需要 Docker Compose。
## 配置您的 AWS 凭证
在此步骤中，您将在主机上创建一个包含 AWS 安全凭证的凭证文件。运行 AWS IoT Greengrass Docker 镜像时，必须将包含此凭证文件的文件夹挂载到 Docker 容器`/root/.aws/`中。 AWS IoT Greengrass 安装程序使用这些凭据在中配置资源 AWS 账户。有关安装程序自动预置资源所需的最低 IAM 策略的信息，请参阅[安装程序配置资源的最低 IAM 策略](provision-minimal-iam-policy.md)。
1. 检索以下其中一项。
+ IAM 用户的长期凭证。有关如何检索长期凭证的信息，请参阅《IAM 用户指南》**中的[管理 IAM 用户的访问密钥](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html)。
+ （推荐）IAM 角色的临时凭证。有关如何检索临时凭证的信息，请参阅《IAM 用户指南》**中的[将临时安全凭证用于 AWS CLI](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html#using-temp-creds-sdk-cli)。
1. 创建一个用于存放凭证文件的文件夹。
```
mkdir ./greengrass-v2-credentials
```
1. 使用文本编辑器在 `./greengrass-v2-credentials` 文件夹中创建名为 `credentials` 的配置文件。
例如，您可以运行以下命令来使用 GNU nano 创建 `credentials` 文件。
```
nano ./greengrass-v2-credentials/credentials
```
1. 按以下格式将您的 AWS 凭证添加到`credentials`文件中。
```
[default]
aws_access_key_id = AKIAIOSFODNN7EXAMPLE
aws_secret_access_key = wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
aws_session_token = AQoEXAMPLEH4aoAH0gNCAPy...truncated...zrkuWJOgQs8IZZaIv2BXIa2R4Olgk
```
仅为临时凭证包含 `aws_session_token`。
**重要**
启动 AWS IoT Greengrass 容器后，将凭据文件从主机中删除。如果您不删除凭证文件，则您的 AWS 凭证将保持挂载在容器中。有关更多信息，请参阅 [在容器中运行 AWS IoT Greengrass Core 软件](#run-greengrass-image-automatic-provisioning)。
## 创建环境文件
本教程使用环境文件来设置环境变量，这些变量将传递给 Docker 容器内的 C AWS IoT Greengrass ore 软件安装程序。您还可以在 `docker run` 命令中使用 [`-e` 或 `--env` 参数](https://docs.docker.com/engine/reference/commandline/run/#env)在 Docker 容器中设置环境变量，或在 `docker-compose.yml` 文件中的 [`environment` 块](https://docs.docker.com/compose/compose-file/compose-file-v3/#environment)中设置变量。
1. 使用文本编辑器创建名为 `.env` 的环境文件。
例如，在基于 Linux 的系统上，您可以运行以下命令来使用 GNU nano 在当前目录中创建 `.env`。
```
nano .env
```
1. 将以下内容复制到该文件中。
```
GGC_ROOT_PATH=/greengrass/v2
AWS_REGION=region
PROVISION=true
THING_NAME=MyGreengrassCore
THING_GROUP_NAME=MyGreengrassCoreGroup
TES_ROLE_NAME=GreengrassV2TokenExchangeRole
TES_ROLE_ALIAS_NAME=GreengrassCoreTokenExchangeRoleAlias
COMPONENT_DEFAULT_USER=ggc_user:ggc_group
```
然后，替换以下值。
+ `/greengrass/v2`。要用于安装的 Greengrass 根文件夹。您可以使用 `GGC_ROOT` 环境变量来设置此值。
+ *region*。 您创建资源 AWS 区域 的位置。
+ *MyGreengrassCore*。 AWS IoT 事物的名字。如果该事物不存在，安装程序会进行创建。安装程序下载证书以进行身份 AWS IoT 验证。
+ *MyGreengrassCoreGroup*。 AWS IoT 事物组的名称。如果该事物组不存在，安装程序会进行创建并向其中添加事物。如果事物组存在且有活动的部署，则核心设备将下载并运行部署指定的软件。
+ *GreengrassV2TokenExchangeRole*。 替换为允许 Greengrass 核心设备获取临时证书的 IAM 令牌交换角色的名称。 AWS 如果该角色不存在，则安装程序会创建该角色并创建并附加名为 A *GreengrassV2TokenExchangeRole* ccess 的策略。有关更多信息，请参阅 [授权核心设备与 AWS 服务交互](device-service-role.md)。
+ *GreengrassCoreTokenExchangeRoleAlias*。 代币交换角色别名。如果该角色别名不存在，安装程序会进行创建，并将其指向您指定的 IAM 令牌交换角色。有关更多信息，请参阅
**注意**
您可以将 `DEPLOY_DEV_TOOLS` 环境变量设置为 `true`，以部署 [Greengrass CLI 组件](greengrass-cli-component.md)，进而在 Docker 容器内开发自定义组件。我们建议您仅在开发环境中使用此组件，不要在生产环境中使用。此组件允许访问您在生产环境中通常不需要的信息和操作。遵循最低权限原则，将此组件仅部署到有需求的核心设备。
## 在容器中运行 AWS IoT Greengrass Core 软件
本教程向您展示了如何启动在 Docker 容器中构建的 Docker 映像。你可以使用 Docker CLI 或 Docker Compose CLI 在 Docker AWS IoT Greengrass 容器中运行核心软件镜像。
------
#### [ Docker ]
1. 运行以下命令来启动 Docker 容器。
```
docker run --rm --init -it --name docker-image \
-v path/to/greengrass-v2-credentials:/root/.aws/:ro \
--env-file .env \
-p 8883 \
your-container-image:version
```
此示例命令为 [docker run](https://docs.docker.com/engine/reference/commandline/run/) 使用以下参数：
+ [https://docs.docker.com/engine/reference/run/#clean-up---rm](https://docs.docker.com/engine/reference/run/#clean-up---rm)。当容器退出时，清理容器。
+ [https://docs.docker.com/engine/reference/run/#specify-an-init-process](https://docs.docker.com/engine/reference/run/#specify-an-init-process)。在容器中使用 init 进程。
**注意**
当你停止 Docker 容器时，需要使用该`--init`参数才能关闭 C AWS IoT Greengrass ore 软件。
+ [https://docs.docker.com/engine/reference/run/#foreground](https://docs.docker.com/engine/reference/run/#foreground)。（可选）作为交互式进程在前台运行 Docker 容器。您可以将此项替换为 `-d` 参数，以在分离模式下运行 Docker 容器。有关更多信息，请参阅 Docker 文档中的[分离模式与前台模式](https://docs.docker.com/engine/reference/run/#detached-vs-foreground)。
+ [https://docs.docker.com/engine/reference/run/#name---name](https://docs.docker.com/engine/reference/run/#name---name)。运行名为 `aws-iot-greengrass` 的容器
+ [https://docs.docker.com/storage/volumes/](https://docs.docker.com/storage/volumes/)。 将卷挂载到 Docker 容器中，使配置文件和证书文件可供在容器内 AWS IoT Greengrass 运行。
+ [https://docs.docker.com/engine/reference/commandline/run/#env](https://docs.docker.com/engine/reference/commandline/run/#env)。 （可选）指定环境文件以设置将传递给 Docker 容器内的 C AWS IoT Greengrass ore 软件安装程序的环境变量。只有在创建[环境文件](run-greengrass-docker-manual-provisioning.md#create-env-file-manual-provisioning)来设置环境变量时，才需要此参数。如果您没有创建环境文件，则可以直接在 Docker run 命令中使用 `--env` 参数设置环境变量。
+ [https://docs.docker.com/engine/reference/commandline/run/#publish](https://docs.docker.com/engine/reference/commandline/run/#publish)。（可选）将 8883 容器端口发布到主机。如果您想通过 MQTT 进行连接和通信，需要使用此参数，因为 AWS IoT Greengrass 将端口 8883 用于 MQTT 流量。要打开其它端口，请使用其它 `-p` 参数。
**注意**
要以更高的安全性运行 Docker 容器，您可以使用 `--cap-drop` 和 `--cap-add` 参数选择性地为容器启用 Linux 功能。有关更多信息，请参阅 Docker 文档中的[运行时权限和 Linux 功能](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities)。
1. 从主机设备上的 `./greengrass-v2-credentials` 中移除凭证。
```
rm -rf ./greengrass-v2-credentials
```
**重要**
您之所以移除这些凭证，是因为它们提供了核心设备仅在设置期间才需要的广泛权限。如果您不移除这些凭证，Greengrass 组件以及容器中运行的其它进程可以访问这些凭证。如果您需要向 Greengrass 组件提供 AWS 凭证，请使用令牌交换服务。有关更多信息，请参阅 [与 AWS 服务交互](interact-with-aws-services.md)。
------
#### [ Docker Compose ]
1. 使用文本编辑器创建名为 `docker-compose.yml` 的 Docker Compose 文件。
例如，在基于 Linux 的系统上，您可以运行以下命令来使用 GNU nano 在当前目录中创建 `docker-compose.yml`。
```
nano docker-compose.yml
```
**注意**
您也可以从中下载和使用 AWS提供的 Compose 文件的最新版本。[GitHub](https://github.com/aws-greengrass/aws-greengrass-docker/releases/)
1. 将以下内容添加到 Compose 文件。您的文件应类似于以下示例。*docker-image*替换为你的 Docker 镜像的名称。
```
version: '3.7'
services:
greengrass:
init: true
container_name: aws-iot-greengrass
image: docker-image
volumes:
- ./greengrass-v2-credentials:/root/.aws/:ro
env_file: .env
ports:
- "8883:8883"
```
此示例 Compose 文件中的以下参数是可选的：
+ `ports` – 将 8883 容器端口发布到主机。如果您想通过 MQTT 进行连接和通信，则需要使用此参数，因为 MQTT 流量 AWS IoT Greengrass 使用端口 8883。
+ `env_file`— 指定环境文件以设置将传递给 Docker 容器内的 C AWS IoT Greengrass ore 软件安装程序的环境变量。只有在创建[环境文件](run-greengrass-docker-manual-provisioning.md#create-env-file-manual-provisioning)来设置环境变量时，才需要该参数。如果您没有创建环境文件，则可以使用[环境](https://docs.docker.com/compose/compose-file/compose-file-v3/#environment)参数直接在 Compose 文件中设置变量。
**注意**
要以更高的安全性运行 Docker 容器，您可以使用 Compose 文件中的 `cap_drop` 和 `cap_add` 选择性地为容器启用 Linux 功能。有关更多信息，请参阅 Docker 文档中的[运行时权限和 Linux 功能](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities)。
1. 运行以下命令来启动 Docker 容器。
```
docker-compose -f docker-compose.yml up
```
1. 从主机设备上的 `./greengrass-v2-credentials` 中移除凭证。
```
rm -rf ./greengrass-v2-credentials
```
**重要**
您之所以移除这些凭证，是因为它们提供了核心设备仅在设置期间才需要的广泛权限。如果您不移除这些凭证，Greengrass 组件以及容器中运行的其它进程可以访问这些凭证。如果您需要向 Greengrass 组件提供 AWS 凭证，请使用令牌交换服务。有关更多信息，请参阅 [与 AWS 服务交互](interact-with-aws-services.md)。
------
## 后续步骤
AWS IoT Greengrass 核心软件现在在 Docker 容器中运行。运行以下命令以检索当前运行容器的容器 ID。
```
docker ps
```
然后，您可以运行以下命令来访问容器并浏览容器内运行的 AWS IoT Greengrass Core 软件。
```
docker exec -it container-id /bin/bash
```
有关创建简单组件的信息，请参阅[教程：AWS IoT Greengrass V2 入门](getting-started.md)中的[第 4 步：在设备上开发和测试组件](create-first-component.md)。
**注意**
当您使用 `docker exec` 在 Docker 容器内运行命令时，这些命令不会记录在 Docker 日志中。要将命令记录在 Docker 日志中，请将交互式 Shell 附加到 Docker 容器。有关更多信息，请参阅 [将交互式 Shell 附加到 Docker 容器](docker-troubleshooting.md#debugging-docker-attach-shell)。
C AWS IoT Greengrass ore 日志文件被调用`greengrass.log`，位于中`/greengrass/v2/logs`。组件日志文件也位于同一目录中。要将 Greengrass 日志复制到主机上的临时目录，请运行以下命令：
```
docker cp container-id:/greengrass/v2/logs /tmp/logs
```
如果您想在容器退出或移除后保留日志，我们建议您仅将 `/greengrass/v2/logs` 目录绑定挂载到主机上的临时日志目录，而不是挂载整个 Greengrass 目录。有关更多信息，请参阅 [在 Docker 容器之外保留 Greengrass 日志](docker-troubleshooting.md#debugging-docker-persist-logs)。
要停止正在运行的 AWS IoT Greengrass Docker 容器，请运行`docker stop`或`docker-compose -f docker-compose.yml stop`。此操作可将 `SIGTERM` 发送到 Greengrass 进程，并关闭容器中启动的所有关联进程。Docker 容器通过 `docker-init` 可执行文件初始化为进程 PID 1，这有助于移除任何剩余的僵尸进程。有关更多信息，请参阅 Docker 文档中的[指定 init 进程](https://docs.docker.com/engine/reference/run/#specify-an-init-process)。
有关对在 Docker 容器中运行 AWS IoT Greengrass 的问题进行排查的信息，请参阅[在 Docker AWS IoT Greengrass 容器中进行故障排除](docker-troubleshooting.md)。
# AWS IoT Greengrass 在 Docker 容器中运行，手动配置资源
本教程向您展示如何使用手动配置的资源在 Docker 容器中安装和运行 C AWS IoT Greengrass ore 软件。 AWS
**Topics**
+ [先决条件](#docker-manual-provisioning-prereqs)
+ [检索 AWS IoT 端点](#retrieve-iot-endpoints)
+ [创建 AWS IoT 事物](#create-iot-thing)
+ [创建事物证书](#create-thing-certificate-mp)
+ [创建令牌交换角色](#create-token-exchange-role)
+ [将证书下载到设备](#download-thing-certificates)
+ [创建配置文件](#create-docker-install-configuration-file)
+ [创建环境文件](#create-env-file-manual-provisioning)
+ [在容器中运行 AWS IoT Greengrass Core 软件](#run-greengrass-image-manual-provisioning)
+ [后续步骤](#run-greengrass-docker-next-steps)
## 先决条件
要完成本教程，您需要：
+ 一个 AWS 账户。如果没有，请参阅[设置一个 AWS 账户](setting-up.md#set-up-aws-account)。
+ 一张 AWS IoT Greengrass Docker 镜像。你可以[从 AWS IoT Greengrass Dockerfile 中生成镜像](build-greengrass-dockerfile.md)。
+ 运行 Docker 容器的主机必须满足以下要求：
+ 支持互联网连接的基于 Linux 的操作系统。
+ [Docker Engine](https://docs.docker.com/engine/install/) 18.09 版本或更高版本。
+ （可选）[Docker Compose](https://docs.docker.com/compose/install/) 1.22 版本或更高版本。只有当您想使用 Docker Compose CLI 来运行 Docker 映像时，才需要 Docker Compose。
## 检索 AWS IoT 端点
获取您的终 AWS IoT 端节点 AWS 账户，然后将其保存以备后用。您的设备使用这些端点来连接 AWS IoT。执行以下操作：
1. 获取您的 AWS IoT 数据端点 AWS 账户。
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS
```
如果请求成功，响应类似如下示例。
```
{
"endpointAddress": "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
}
```
1. 获取您的 AWS IoT 凭证终端节点 AWS 账户。
```
aws iot describe-endpoint --endpoint-type iot:CredentialProvider
```
如果请求成功，响应类似如下示例。
```
{
"endpointAddress": "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
}
```
## 创建 AWS IoT 事物
AWS IoT *事物*代表连接到的设备和逻辑实体 AWS IoT。Greengrass 的核心设备就是东西。 AWS IoT 当您将设备注册为 AWS IoT 事物时，该设备可以使用数字证书进行身份验证 AWS。
在本节中，您将创建一个代表您的设备的 AWS IoT 东西。
**创建 AWS IoT 事物**
1. 为你的设备创建 AWS IoT 一件东西。在开发计算机上运行以下命令。
+ *MyGreengrassCore*替换为要使用的事物名称。此名称也是您 Greengrass 核心设备的名称。
**注意**
事物名称不得包含英文冒号 (`:`) 字符。
```
aws iot create-thing --thing-name MyGreengrassCore
```
如果请求成功，响应类似如下示例。
```
{
"thingName": "MyGreengrassCore",
"thingArn": "arn:aws:iot:us-west-2:123456789012:thing/MyGreengrassCore",
"thingId": "8cb4b6cd-268e-495d-b5b9-1713d71dbf42"
}
```
1. （可选）将 AWS IoT 事物添加到新的或现有的事物组。您可以使用事物组来管理 Greengrass 核心设备实例集。将软件组件部署到设备时，可以以单个设备或设备组为目标。您可以将设备添加到有活动 Greengrass 部署的事物组，以将该事物组的软件组件部署到该设备。执行以下操作：
1. （可选）创建 AWS IoT 事物组。
+ *MyGreengrassCoreGroup*替换为要创建的事物组的名称。
**注意**
事物组名称不得包含英文冒号 (`:`) 字符。
```
aws iot create-thing-group --thing-group-name MyGreengrassCoreGroup
```
如果请求成功，响应类似如下示例。
```
{
"thingGroupName": "MyGreengrassCoreGroup",
"thingGroupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/MyGreengrassCoreGroup",
"thingGroupId": "4df721e1-ff9f-4f97-92dd-02db4e3f03aa"
}
```
1. 将 AWS IoT 事物添加到事物组。
+ *MyGreengrassCore*用你的 AWS IoT 东西的名字替换。
+ *MyGreengrassCoreGroup*替换为事物组的名称。
```
aws iot add-thing-to-thing-group --thing-name MyGreengrassCore --thing-group-name MyGreengrassCoreGroup
```
如果请求成功，则该命令没有任何输出。
## 创建事物证书
当您将设备注册为 AWS IoT 事物时，该设备可以使用数字证书进行身份验证 AWS。此证书允许设备与 AWS IoT 和通信 AWS IoT Greengrass。
在本节中，您将创建和下载可供您的设备连接 AWS的证书。
**创建事物证书**
1. 创建一个文件夹，用于下载 AWS IoT 事物的证书。
```
mkdir greengrass-v2-certs
```
1. 为该 AWS IoT 事物创建并下载证书。
```
aws iot create-keys-and-certificate --set-as-active --certificate-pem-outfile greengrass-v2-certs/device.pem.crt --public-key-outfile greengrass-v2-certs/public.pem.key --private-key-outfile greengrass-v2-certs/private.pem.key
```
如果请求成功，响应类似如下示例。
```
{
"certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
"certificateId": "aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
"certificatePem": "-----BEGIN CERTIFICATE-----
MIICiTCCAfICCQD6m7oRw0uXOjANBgkqhkiG9w
0BAQUFADCBiDELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZ
WF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIw
EAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5
jb20wHhcNMTEwNDI1MjA0NTIxWhcNMTIwNDI0MjA0NTIxWjCBiDELMAkGA1UEBh
MCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBb
WF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMx
HzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5jb20wgZ8wDQYJKoZIhvcNAQE
BBQADgY0AMIGJAoGBAMaK0dn+a4GmWIWJ21uUSfwfEvySWtC2XADZ4nB+BLYgVI
k60CpiwsZ3G93vUEIO3IyNoH/f0wYK8m9TrDHudUZg3qX4waLG5M43q7Wgc/MbQ
ITxOUSQv7c7ugFFDzQGBzZswY6786m86gpEIbb3OhjZnzcvQAaRHhdlQWIMm2nr
AgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAtCu4nUhVVxYUntneD9+h8Mg9q6q+auN
KyExzyLwaxlAoo7TJHidbtS4J5iNmZgXL0FkbFFBjvSfpJIlJ00zbhNYS5f6Guo
EDmFJl0ZxBHjJnyp378OD8uTs7fLvjx79LjSTbNYiytVbZPQUQ5Yaxu2jXnimvw
3rrszlaEXAMPLE=
-----END CERTIFICATE-----",
"keyPair": {
"PublicKey": "-----BEGIN PUBLIC KEY-----\
MIIBIjANBgkqhkEXAMPLEQEFAAOCAQ8AMIIBCgKCAQEAEXAMPLE1nnyJwKSMHw4h\
MMEXAMPLEuuN/dMAS3fyce8DW/4+EXAMPLEyjmoF/YVF/gHr99VEEXAMPLE5VF13\
59VK7cEXAMPLE67GK+y+jikqXOgHh/xJTwo+sGpWEXAMPLEDz18xOd2ka4tCzuWEXAMPLEahJbYkCPUBSU8opVkR7qkEXAMPLE1DR6sx2HocliOOLtu6Fkw91swQWEXAMPLE\\GB3ZPrNh0PzQYvjUStZeccyNCx2EXAMPLEvp9mQOUXP6plfgxwKRX2fEXAMPLEDa\
hJLXkX3rHU2xbxJSq7D+XEXAMPLEcw+LyFhI5mgFRl88eGdsAEXAMPLElnI9EesG\
FQIDAQAB\
-----END PUBLIC KEY-----\
",
"PrivateKey": "-----BEGIN RSA PRIVATE KEY-----\
key omitted for security reasons\
-----END RSA PRIVATE KEY-----\
"
}
}
```
保存证书的 Amazon 资源名称（ARN），以便稍后用于配置证书。
接下来，配置事物证书。有关更多信息，请参阅 [配置事物证书](manual-installation.md#configure-thing-certificate)。
## 创建令牌交换角色
Greengrass 核心设备使用 IAM 服务角色（称为*令牌交换角色）来授权对*服务的调用。 AWS 设备使用 AWS IoT 证书提供程序来获取此角色的临时 AWS 证书，从而允许设备与 Amazon Logs 进行交互 AWS IoT、向 Amazon Logs 发送 CloudWatch 日志以及从 Amazon S3 下载自定义组件项目。有关更多信息，请参阅 [授权核心设备与 AWS 服务交互](device-service-role.md)。
您可以使用 AWS IoT *角色别名*为 Greengrass 核心设备配置令牌交换角色。角色别名允许您更改设备的令牌交换角色，但设备配置保持不变。有关更多信息，请参阅《AWS IoT Core 开发人员指南》**中的[授权直接调用 AWS 服务](https://docs.aws.amazon.com/iot/latest/developerguide/authorizing-direct-aws.html)。
在本节中，您将创建令牌交换 IAM 角色和指向该 AWS IoT 角色的角色别名。如果您已经设置了 Greengrass 核心设备，则可以使用其令牌交换角色和角色别名，而不必新建。然后，您将设备的 AWS IoT 事物配置为使用该角色和别名。
**创建令牌交换 IAM 角色**
1. 创建设备可将其用作令牌交换角色的 IAM 角色。执行以下操作：
1. 创建包含令牌交换角色所需的信任策略文档的文件。
例如，在基于 Linux 的系统上，您可以运行以下命令来使用 GNU nano 创建该文件。
```
nano device-role-trust-policy.json
```
将以下 JSON 复制到该文件中。
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
1. 通过信任策略文档创建令牌交换角色。
+ *GreengrassV2TokenExchangeRole*替换为要创建的 IAM 角色的名称。
```
aws iam create-role --role-name GreengrassV2TokenExchangeRole --assume-role-policy-document file://device-role-trust-policy.json
```
如果请求成功，响应类似如下示例。
```
{
"Role": {
"Path": "/",
"RoleName": "GreengrassV2TokenExchangeRole",
"RoleId": "AROAZ2YMUHYHK5OKM77FB",
"Arn": "arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole",
"CreateDate": "2021-02-06T00:13:29+00:00",
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
}
```
1. 创建一个包含令牌交换角色所需的访问策略文档的文件。
例如，在基于 Linux 的系统上，您可以运行以下命令来使用 GNU nano 创建该文件。
```
nano device-role-access-policy.json
```
将以下 JSON 复制到该文件中。
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents",
"logs:DescribeLogStreams",
"s3:GetBucketLocation"
],
"Resource": "*"
}
]
}
```
**注意**
此访问策略不允许访问 S3 存储桶中的组件构件。要在 Amazon S3 中部署可定义构件的自定义组件，您必须为该角色添加权限以允许核心设备检索组件构件。有关更多信息，请参阅 [允许访问 S3 存储桶中的组件构件](device-service-role.md#device-service-role-access-s3-bucket)。
如果您还没有适用于组件构件的 S3 存储桶，则可以在创建存储桶后添加这些权限。
1. 通过策略文档创建 IAM 策略
+ *GreengrassV2TokenExchangeRoleAccess*替换为要创建的 IAM 策略的名称。
```
aws iam create-policy --policy-name GreengrassV2TokenExchangeRoleAccess --policy-document file://device-role-access-policy.json
```
如果请求成功，响应类似如下示例。
```
{
"Policy": {
"PolicyName": "GreengrassV2TokenExchangeRoleAccess",
"PolicyId": "ANPAZ2YMUHYHACI7C5Z66",
"Arn": "arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess",
"Path": "/",
"DefaultVersionId": "v1",
"AttachmentCount": 0,
"PermissionsBoundaryUsageCount": 0,
"IsAttachable": true,
"CreateDate": "2021-02-06T00:37:17+00:00",
"UpdateDate": "2021-02-06T00:37:17+00:00"
}
}
```
1. 将 IAM 策略附加到令牌交换角色。
+ 将 *GreengrassV2TokenExchangeRole* 替换为 IAM 角色的名称。
+ 将策略 ARN 替换为您在上一步中创建的 IAM 策略的 ARN。
```
aws iam attach-role-policy --role-name GreengrassV2TokenExchangeRole --policy-arn arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess
```
如果请求成功，则该命令没有任何输出。
1. 创建 AWS IoT 指向代币交换角色的角色别名。
+ *GreengrassCoreTokenExchangeRoleAlias*替换为要创建的角色别名的名称。
+ 将角色 ARN 替换为您在上一步中创建的 IAM 角色的 ARN。
```
aws iot create-role-alias --role-alias GreengrassCoreTokenExchangeRoleAlias --role-arn arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole
```
如果请求成功，响应类似如下示例。
```
{
"roleAlias": "GreengrassCoreTokenExchangeRoleAlias",
"roleAliasArn": "arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
```
**注意**
要创建角色别名，您必须有权将令牌交换 IAM 角色传递到 AWS IoT。如果您在尝试创建角色别名时收到错误消息，请检查您的 AWS 用户是否具有此权限。有关更多信息，请参阅[《用户*指南》中的授予AWS Identity and Access Management 用户*向 AWS 服务传递角色的权限](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_passrole.html)。
1. 创建并附加 AWS IoT 允许您的 Greengrass 核心设备使用角色别名担任令牌交换角色的策略。如果您之前设置过 Greengrass 核心设备，则可以附加其角色 AWS IoT 别名策略，而不必创建新的角色别名策略。执行以下操作：
1. （可选）创建一个包含角色别名所需的 AWS IoT 策略文档的文件。
例如，在基于 Linux 的系统上，您可以运行以下命令来使用 GNU nano 创建该文件。
```
nano greengrass-v2-iot-role-alias-policy.json
```
将以下 JSON 复制到该文件中。
+ 将资源 ARN 替换为您角色别名的 ARN。
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iot:AssumeRoleWithCertificate",
"Resource": "arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
]
}
```
1. 根据 AWS IoT 策略文档创建策略。
+ *GreengrassCoreTokenExchangeRoleAliasPolicy*替换为要创建的 AWS IoT 策略的名称。
```
aws iot create-policy --policy-name GreengrassCoreTokenExchangeRoleAliasPolicy --policy-document file://greengrass-v2-iot-role-alias-policy.json
```
如果请求成功，响应类似如下示例。
```
{
"policyName": "GreengrassCoreTokenExchangeRoleAliasPolicy",
"policyArn": "arn:aws:iot:us-west-2:123456789012:policy/GreengrassCoreTokenExchangeRoleAliasPolicy",
"policyDocument": "{
\\"Version\\":\\"2012-10-17 \\",
\\"Statement\\": [
{
\\"Effect\\": \\"Allow\\",
\\"Action\\": \\"iot:AssumeRoleWithCertificate\\",
\\"Resource\\": \\"arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias\\"
}
]
}",
"policyVersionId": "1"
}
```
1. 将 AWS IoT 策略附加到 AWS IoT 事物的证书上。
+ *GreengrassCoreTokenExchangeRoleAliasPolicy*替换为角色别名 AWS IoT 策略的名称。
+ 将目标 ARN 替换为您的 AWS IoT 事物证书的 ARN。
```
aws iot attach-policy --policy-name GreengrassCoreTokenExchangeRoleAliasPolicy --target arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4
```
如果请求成功，则该命令没有任何输出。
## 将证书下载到设备
之前，您已将设备的证书下载到开发计算机上。在本节中，您可以下载 Amazon 根证书颁发机构（CA）证书。然后，如果您计划在 Docker 中与开发计算机不同的计算机上运行 C AWS IoT Greengrass ore 软件，则可以将证书复制到该主机。C AWS IoT Greengrass ore 软件使用这些证书连接到 AWS IoT 云服务。
**将证书下载到设备**
1. 在您的开发计算机上，下载 Amazon 根证书颁发机构 (CA) 证书。 AWS IoT 默认情况下，证书与亚马逊的根 CA 证书相关联。
------
#### [ Linux or Unix ]
```
sudo curl -o ./greengrass-v2-certs/AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -o .\greengrass-v2-certs\AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ PowerShell ]
```
iwr -Uri https://www.amazontrust.com/repository/AmazonRootCA1.pem -OutFile .\greengrass-v2-certs\AmazonRootCA1.pem
```
------
1. 如果您计划在 Docker 中与开发计算机不同的设备上运行 C AWS IoT Greengrass ore 软件，请将证书复制到主机。如果在开发计算机和主机上启用了 SSH 和 SCP，则可以在开发计算机上使用 `scp` 命令来传输证书。*device-ip-address*替换为主机的 IP 地址。
```
scp -r greengrass-v2-certs/ device-ip-address:~
```
## 创建配置文件
1. 在主机上，创建一个用于存放配置文件的文件夹。
```
mkdir ./greengrass-v2-config
```
1. 使用文本编辑器在 `./greengrass-v2-config` 文件夹中创建名为 `config.yaml` 的配置文件。
例如，您可以运行以下命令来使用 GNU nano 创建 `config.yaml`。
```
nano ./greengrass-v2-config/config.yaml
```
1. 将以下 YAML 内容复制到该文件中。此部分配置文件会指定系统参数和 Greengrass Nucleus 参数。
```
---
system:
certificateFilePath: "/tmp/certs/device.pem.crt"
privateKeyPath: "/tmp/certs/private.pem.key"
rootCaPath: "/tmp/certs/AmazonRootCA1.pem"
rootpath: "/greengrass/v2"
thingName: "MyGreengrassCore"
services:
aws.greengrass.Nucleus:
componentType: "NUCLEUS"
version: "nucleus-version"
configuration:
awsRegion: "region"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
iotDataEndpoint: "device-data-prefix-ats.iot.region.amazonaws.com"
iotCredEndpoint: "device-credentials-prefix.credentials.region.amazonaws.com"
```
然后，替换以下值：
+ */tmp/certs*。 Docker 容器中的目录，您在启动容器时将下载的证书挂载到该目录。
+ `/greengrass/v2`。要用于安装的 Greengrass 根文件夹。您可以使用 `GGC_ROOT` 环境变量来设置此值。
+ *MyGreengrassCore*。 AWS IoT 事物的名字。
+ *nucleus-version*。 要安装的 AWS IoT Greengrass Core 软件的版本。此值必须与您下载的 Docker 映像或 Dockerfile 的版本匹配。如果您下载了带有 `latest` 标签的 Greengrass Docker 映像，请使用 ****docker inspect *image-id***** 查看映像版本。
+ *region*。 您创建 AWS IoT 资源 AWS 区域 的位置。您还必须在[环境文件](#create-env-file-manual-provisioning)中为 `AWS_REGION` 环境变量指定相同的值。
+ *GreengrassCoreTokenExchangeRoleAlias*。 代币交换角色别名。
+ *device-data-prefix*。 您的 AWS IoT 数据端点的前缀。
+ *device-credentials-prefix*。 您的 AWS IoT 凭证端点的前缀。
## 创建环境文件
本教程使用环境文件来设置环境变量，这些变量将传递给 Docker 容器内的 C AWS IoT Greengrass ore 软件安装程序。您还可以在 `docker run` 命令中使用 [`-e` 或 `--env` 参数](https://docs.docker.com/engine/reference/commandline/run/#env)在 Docker 容器中设置环境变量，或在 `docker-compose.yml` 文件中的 [`environment` 块](https://docs.docker.com/compose/compose-file/compose-file-v3/#environment)中设置变量。
1. 使用文本编辑器创建名为 `.env` 的环境文件。
例如，在基于 Linux 的系统上，您可以运行以下命令来使用 GNU nano 在当前目录中创建 `.env`。
```
nano .env
```
1. 将以下内容复制到该文件中。
```
GGC_ROOT_PATH=/greengrass/v2
AWS_REGION=region
PROVISION=false
COMPONENT_DEFAULT_USER=ggc_user:ggc_group
INIT_CONFIG=/tmp/config/config.yaml
```
然后，替换以下值。
+ `/greengrass/v2`。 用于安装 C AWS IoT Greengrass ore 软件的根文件夹的路径。
+ *region*。 您创建 AWS IoT 资源 AWS 区域 的位置。您必须在[配置文件](#create-docker-install-configuration-file)中为 `awsRegion` 配置参数指定相同的值。
+ */tmp/config/*。 启动 Docker 容器时用于挂载配置文件的文件夹。
**注意**
您可以将 `DEPLOY_DEV_TOOLS` 环境变量设置为 `true`，以部署 [Greengrass CLI 组件](greengrass-cli-component.md)，进而在 Docker 容器内开发自定义组件。我们建议您仅在开发环境中使用此组件，不要在生产环境中使用。此组件允许访问您在生产环境中通常不需要的信息和操作。遵循最低权限原则，将此组件仅部署到有需求的核心设备。
## 在容器中运行 AWS IoT Greengrass Core 软件
本教程向您展示了如何启动在 Docker 容器中构建的 Docker 映像。你可以使用 Docker CLI 或 Docker Compose CLI 在 Docker AWS IoT Greengrass 容器中运行核心软件镜像。
------
#### [ Docker ]
+ 本教程向您展示了如何启动在 Docker 容器中构建的 Docker 映像。
```
docker run --rm --init -it --name docker-image \
-v path/to/greengrass-v2-config:/tmp/config/:ro \
-v path/to/greengrass-v2-certs:/tmp/certs:ro \
--env-file .env \
-p 8883 \
your-container-image:version
```
此示例命令为 [docker run](https://docs.docker.com/engine/reference/commandline/run/) 使用以下参数：
+ [https://docs.docker.com/engine/reference/run/#clean-up---rm](https://docs.docker.com/engine/reference/run/#clean-up---rm)。当容器退出时，清理容器。
+ [https://docs.docker.com/engine/reference/run/#specify-an-init-process](https://docs.docker.com/engine/reference/run/#specify-an-init-process)。在容器中使用 init 进程。
**注意**
当你停止 Docker 容器时，需要使用该`--init`参数才能关闭 C AWS IoT Greengrass ore 软件。
+ [https://docs.docker.com/engine/reference/run/#foreground](https://docs.docker.com/engine/reference/run/#foreground)。（可选）作为交互式进程在前台运行 Docker 容器。您可以将此项替换为 `-d` 参数，以在分离模式下运行 Docker 容器。有关更多信息，请参阅 Docker 文档中的[分离模式与前台模式](https://docs.docker.com/engine/reference/run/#detached-vs-foreground)。
+ [https://docs.docker.com/engine/reference/run/#name---name](https://docs.docker.com/engine/reference/run/#name---name)。运行名为 `aws-iot-greengrass` 的容器
+ [https://docs.docker.com/storage/volumes/](https://docs.docker.com/storage/volumes/)。 将卷挂载到 Docker 容器中，使配置文件和证书文件可供在容器内 AWS IoT Greengrass 运行。
+ [https://docs.docker.com/engine/reference/commandline/run/#env](https://docs.docker.com/engine/reference/commandline/run/#env)。 （可选）指定环境文件以设置将传递给 Docker 容器内的 C AWS IoT Greengrass ore 软件安装程序的环境变量。只有在创建[环境文件](#create-env-file-manual-provisioning)来设置环境变量时，才需要此参数。如果您没有创建环境文件，则可以直接在 Docker run 命令中使用 `--env` 参数设置环境变量。
+ [https://docs.docker.com/engine/reference/commandline/run/#publish](https://docs.docker.com/engine/reference/commandline/run/#publish)。（可选）将 8883 容器端口发布到主机。如果您想通过 MQTT 进行连接和通信，需要使用此参数，因为 AWS IoT Greengrass 将端口 8883 用于 MQTT 流量。要打开其它端口，请使用其它 `-p` 参数。
**注意**
要以更高的安全性运行 Docker 容器，您可以使用 `--cap-drop` 和 `--cap-add` 参数选择性地为容器启用 Linux 功能。有关更多信息，请参阅 Docker 文档中的[运行时权限和 Linux 功能](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities)。
------
#### [ Docker Compose ]
1. 使用文本编辑器创建名为 `docker-compose.yml` 的 Docker Compose 文件。
例如，在基于 Linux 的系统上，您可以运行以下命令来使用 GNU nano 在当前目录中创建 `docker-compose.yml`。
```
nano docker-compose.yml
```
**注意**
您也可以从中下载和使用 AWS提供的 Compose 文件的最新版本。[GitHub](https://github.com/aws-greengrass/aws-greengrass-docker/releases/)
1. 将以下内容添加到 Compose 文件。您的文件应类似于以下示例。*your-container-name:version*替换为你的 Docker 镜像的名称。
```
version: '3.7'
services:
greengrass:
init: true
build:
context: .
container_name: aws-iot-greengrass
image: your-container-name:version
volumes:
- /path/to/greengrass-v2-config:/tmp/config/:ro
- /path/to/greengrass-v2-certs:/tmp/certs:ro
env_file: .env
ports:
- "8883:8883"
```
此示例 Compose 文件中的以下参数是可选的：
+ `ports` – 将 8883 容器端口发布到主机。如果您想通过 MQTT 进行连接和通信，则需要使用此参数，因为 MQTT 流量 AWS IoT Greengrass 使用端口 8883。
+ `env_file`— 指定环境文件以设置将传递给 Docker 容器内的 C AWS IoT Greengrass ore 软件安装程序的环境变量。只有在创建[环境文件](#create-env-file-manual-provisioning)来设置环境变量时，才需要该参数。如果您没有创建环境文件，则可以使用[环境](https://docs.docker.com/compose/compose-file/compose-file-v3/#environment)参数直接在 Compose 文件中设置变量。
**注意**
要以更高的安全性运行 Docker 容器，您可以使用 Compose 文件中的 `cap_drop` 和 `cap_add` 选择性地为容器启用 Linux 功能。有关更多信息，请参阅 Docker 文档中的[运行时权限和 Linux 功能](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities)。
1. 运行以下命令来启动容器。
```
docker-compose -f docker-compose.yml up
```
------
## 后续步骤
AWS IoT Greengrass 核心软件现在在 Docker 容器中运行。运行以下命令以检索当前运行容器的容器 ID。
```
docker ps
```
然后，您可以运行以下命令来访问容器并浏览容器内运行的 AWS IoT Greengrass Core 软件。
```
docker exec -it container-id /bin/bash
```
有关创建简单组件的信息，请参阅[教程：AWS IoT Greengrass V2 入门](getting-started.md)中的[第 4 步：在设备上开发和测试组件](create-first-component.md)。
**注意**
当您使用 `docker exec` 在 Docker 容器内运行命令时，这些命令不会记录在 Docker 日志中。要将命令记录在 Docker 日志中，请将交互式 Shell 附加到 Docker 容器。有关更多信息，请参阅 [将交互式 Shell 附加到 Docker 容器](docker-troubleshooting.md#debugging-docker-attach-shell)。
C AWS IoT Greengrass ore 日志文件被调用`greengrass.log`，位于中`/greengrass/v2/logs`。组件日志文件也位于同一目录中。要将 Greengrass 日志复制到主机上的临时目录，请运行以下命令：
```
docker cp container-id:/greengrass/v2/logs /tmp/logs
```
如果您想在容器退出或移除后保留日志，我们建议您仅将 `/greengrass/v2/logs` 目录绑定挂载到主机上的临时日志目录，而不是挂载整个 Greengrass 目录。有关更多信息，请参阅 [在 Docker 容器之外保留 Greengrass 日志](docker-troubleshooting.md#debugging-docker-persist-logs)。
要停止正在运行的 AWS IoT Greengrass Docker 容器，请运行`docker stop`或`docker-compose -f docker-compose.yml stop`。此操作可将 `SIGTERM` 发送到 Greengrass 进程，并关闭容器中启动的所有关联进程。Docker 容器通过 `docker-init` 可执行文件初始化为进程 PID 1，这有助于移除任何剩余的僵尸进程。有关更多信息，请参阅 Docker 文档中的[指定 init 进程](https://docs.docker.com/engine/reference/run/#specify-an-init-process)。
有关对在 Docker 容器中运行 AWS IoT Greengrass 的问题进行排查的信息，请参阅[在 Docker AWS IoT Greengrass 容器中进行故障排除](docker-troubleshooting.md)。
# 在 Docker AWS IoT Greengrass 容器中进行故障排除
使用以下信息来帮助您解决在 Docker 容器 AWS IoT Greengrass 中运行的问题，并调试 Docker 容器 AWS IoT Greengrass 中的问题。
**Topics**
+ [对 Docker 容器运行过程中出现的问题进行故障排除](#troubleshooting-container-errors)
+ [AWS IoT Greengrass 在 Docker 容器中进行调试](#debugging-greengrass-in-docker)
## 对 Docker 容器运行过程中出现的问题进行故障排除
使用以下信息来帮助解决在 Docker 容器 AWS IoT Greengrass 中运行的问题。
**Topics**
+ [错误：无法从非 TTY 设备执行交互式登录](#docker-troubleshootin-ecr-get-login-password)
+ [错误：未知选项：-no-include-email](#docker-troubleshooting-cli-version)
+ [错误：防火墙阻止 Windows 和容器之间的文件共享。](#docker-troubleshooting-firewall)
+ [错误：调用 GetAuthorizationToken 操作时出现错误 (AccessDeniedException)：用户：arn: aws: iam::: user/ *account-id* 无权在资源上执行：ecr:: GetAuthorizationToken](#docker-troubleshooting-ecr-perms)
+ [错误：您已达到拉取率上限](#docker-troubleshooting-too-many-requests)
### 错误：无法从非 TTY 设备执行交互式登录
运行 `aws ecr get-login-password` 命令时，可能会出现此错误。确保您安装了最新的 AWS CLI 版本 2 或版本 1。我们建议您使用 AWS CLI 版本 2。有关更多信息，请参阅《AWS Command Line Interface 用户指南》**中的[安装 AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html)。
### 错误：未知选项：-no-include-email
运行 `aws ecr get-login` 命令时，可能会出现此错误。确保安装了最新 AWS CLI 版本（例如，Run:`pip install awscli --upgrade --user`）。有关更多信息，请参阅《*AWS Command Line Interface 用户指南*》中的[AWS Command Line Interface 在 Microsoft Windows 上安装](https://docs.aws.amazon.com/cli/latest/userguide/awscli-install-windows.html)。
### 错误：防火墙阻止 Windows 和容器之间的文件共享。
在 Windows 计算机上运行 Docker 时，您可能会收到此错误或 `Firewall Detected` 消息。如果您登录虚拟私有网络 (VPN) 并且网络设置阻止挂载共享驱动器，也会出现此错误。在这种情况下，请关闭 VPN 并重新运行 Docker 容器。
### 错误：调用 GetAuthorizationToken 操作时出现错误 (AccessDeniedException)：用户：arn: aws: iam::: user/ *account-id* 无权在资源上执行：ecr:: GetAuthorizationToken
如果您没有足够权限来访问 Amazon ECR 存储库，则运行 `aws ecr get-login-password` 命令时可能会收到此错误。有关更多信息，请参阅*Amazon ECR 用户指南*中的 [Amazon ECR 存储库策略示例](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-policy-examples.html)和[访问 One Amazon ECR 存储库](https://docs.aws.amazon.com/AmazonECR/latest/userguide/security_iam_id-based-policy-examples.html)。
### 错误：您已达到拉取率上限
Docker Hub 限制了匿名用户和 Free Docker Hub 用户可以发出的拉取请求的数量。如果您超过匿名或免费用户拉取请求速率限制，则会收到以下错误之一：
```
ERROR: toomanyrequests: Too Many Requests.
```
```
You have reached your pull rate limit.
```
要解决这些错误，您可以等待几个小时再尝试另一个拉取请求。如果您计划持续提交大量拉取请求，请访问 [Docker Hub 网站](https://www.docker.com/increase-rate-limits)，了解有关速率限制以及 Docker 账户身份验证和升级选项的信息。
## AWS IoT Greengrass 在 Docker 容器中进行调试
要调试 Docker 容器的问题，您可以保留 Greengrass 运行时日志或将交互式 shell 附加到 Docker 容器。
### 在 Docker 容器之外保留 Greengrass 日志
停止 AWS IoT Greengrass 容器后，您可以使用以下`docker cp `命令将 Greengrass 日志从 Docker 容器复制到临时日志目录。
```
docker cp container-id:/greengrass/v2/logs /tmp/logs
```
要在容器退出或移除后仍保留日志，您必须在绑定挂载目录后运行 AWS IoT Greengrass Docker 容器。`/greengrass/v2/logs`
要绑定挂载`/greengrass/v2/logs`目录，请在运行新的 D AWS IoT Greengrass ocker 容器时执行以下任一操作。
+ 将 `-v /tmp/logs:/greengrass/v2/logs:ro` 包括在您的 `docker run` 命令中。
在运行 `docker-compose up` 命令之前，修改 Compose 文件中的 `volumes` 块以包含以下行。
```
volumes:
- /tmp/logs:/greengrass/v2/logs:ro
```
然后，当在 Docker 容器内运行时，你可以在主机`/tmp/logs`上查看日志，查看 Greengrass 日志 AWS IoT Greengrass 。
有关运行 Greengrass Docker 容器的信息，请参阅 [使用手动 AWS IoT Greengrass 配置在 Docker 中运行](run-greengrass-docker-manual-provisioning.md) 和 [通过自动 AWS IoT Greengrass 配置在 Docker 中运行](run-greengrass-docker-automatic-provisioning.md)
### 将交互式 Shell 附加到 Docker 容器
当您使用 `docker exec` 在 Docker 容器内运行命令时，这些命令不会被记录在 Docker 日志中。在 Docker 日志中记录命令可以帮助您调查 Greengrass Docker 容器的状态。请执行以下操作之一：
+ 在另一个终端中运行以下命令，将终端的标准输入、输出和错误附加至正在运行的容器。这样您就可以从当前终端查看和控制 Docker 容器。
```
docker attach container-id
```
+ 在另一个终端运行以下命令。这样，即使没有连接容器，也可以在交互模式下运行命令。
```
docker exec -it container-id sh -c "command > /proc/1/fd/1"
```
有关一般 AWS IoT Greengrass 故障排除，请参阅[故障排除 AWS IoT Greengrass V2](troubleshooting.md)。
# 配置 AWS IoT Greengrass 核心软件
C AWS IoT Greengrass ore 软件提供了可用于配置软件的选项。您可以创建部署以在每台 AWS IoT Greengrass 核心设备上配置核心软件。
**Topics**
+ [部署 Greengrass Nucleus 组件](#configure-nucleus-component)
+ [将 Greengrass Nucleus 配置为系统服务](#configure-system-service)
+ [使用 JVM 选项控制内存分配](#jvm-tuning)
+ [配置运行组件的用户](#configure-component-user)
+ [配置组件的系统资源限制](#configure-component-system-resource-limits)
+ [通过端口 443 或网络代理进行连接](#configure-alpn-network-proxy)
+ [使用由私有 CA 签名的设备证书](#configure-nucleus-private-ca)
+ [配置 MQTT 超时和缓存设置](#configure-mqtt)
+ [在网络上配置 Greengrass Nucleus IPv6](#configure-ipv6)
## 部署 Greengrass Nucleus 组件
AWS IoT Greengrass 将 AWS IoT Greengrass 核心软件作为组件提供，您可以将其部署到 Greengrass 核心设备上。您可以创建一个部署，将同一配置应用于多个 Greengrass 核心设备。有关更多信息，请参阅[Greengrass Nucleus](greengrass-nucleus-component.md)和[更新 AWS IoT Greengrass Core 软件（OTA）](update-greengrass-core-v2.md)。
## 将 Greengrass Nucleus 配置为系统服务
要执行以下操作，您必须在设备的初始化系统中将 C AWS IoT Greengrass ore 软件配置为系统服务：
+ 设备启动时启动 AWS IoT Greengrass Core 软件。如果您管理大量设备，这是最佳实践。
+ 安装并运行插件组件。 AWS提供的几个组件是插件组件，这使它们能够直接与 Greengrass 核接口。有关组件类型的更多信息，请参阅 [组件类型](develop-greengrass-components.md#component-types)。
+ 对核心设备的 AWS IoT Greengrass 核心软件应用 over-the-air (OTA) 更新。有关更多信息，请参阅 [更新 AWS IoT Greengrass Core 软件（OTA）](update-greengrass-core-v2.md)。
+ 允许组件在部署将组件更新到新版本或更新某些配置参数时重新启动 AWS IoT Greengrass 核心软件或核心设备。有关更多信息，请参阅[引导生命周期步骤](component-recipe-reference.md#bootstrap-lifecycle-definition)。
**重要**
在 Windows 核心设备上，必须将 AWS IoT Greengrass 核心软件设置为系统服务。
**Topics**
+ [将核心配置为系统服务（Linux）](#configure-system-service-linux)
+ [将核心配置为系统服务（Windows）](#configure-system-service-windows)
### 将核心配置为系统服务（Linux）
Linux 设备支持不同的初始化系统，例如 initd、systemd 和 SystemV。在安装 AWS IoT Greengrass Core 软件时，您可以使用`--setup-system-service true`参数将 nucleus 作为系统服务启动，并将其配置为在设备启动时启动。安装程序使用 systemd 将 AWS IoT Greengrass 核心软件配置为系统服务。
您还可以手动配置核心，使其作为系统服务运行。以下示例是用于 systemd 的服务文件。
```
[Unit]
Description=Greengrass Core
[Service]
Type=simple
PIDFile=/greengrass/v2/alts/loader.pid
RemainAfterExit=no
Restart=on-failure
RestartSec=10
ExecStart=/bin/sh /greengrass/v2/alts/current/distro/bin/loader
[Install]
WantedBy=multi-user.target
```
配置系统服务后，您可以运行以下命令来配置启动设备以及启动或停止 AWS IoT Greengrass Core 软件。
+ 检查服务的状态（systemd）
```
sudo systemctl status greengrass.service
```
+ 让核心在设备开机时启动。
```
sudo systemctl enable greengrass.service
```
+ 在设备开机时阻止核心启动。
```
sudo systemctl disable greengrass.service
```
+ 启动 AWS IoT Greengrass 核心软件。
```
sudo systemctl start greengrass.service
```
+ 停止 AWS IoT Greengrass 核心软件。
```
sudo systemctl stop greengrass.service
```
### 将核心配置为系统服务（Windows）
在安装 AWS IoT Greengrass Core 软件时，您可以使用`--setup-system-service true`参数将 nucleus 作为 Windows 服务启动，并将其配置为在设备启动时启动。
配置服务后，您可以运行以下命令来配置启动设备以及启动或停止 AWS IoT Greengrass Core 软件。必须运行命令提示符或以管理员 PowerShell 身份运行这些命令。
------
#### [ Windows Command Prompt (CMD) ]
+ 检查服务状态
```
sc query "greengrass"
```
+ 让核心在设备开机时启动。
```
sc config "greengrass" start=auto
```
+ 在设备开机时阻止核心启动。
```
sc config "greengrass" start=disabled
```
+ 启动 AWS IoT Greengrass 核心软件。
```
sc start "greengrass"
```
+ 停止 AWS IoT Greengrass 核心软件。
```
sc stop "greengrass"
```
**注意**
在 Windows 设备上， AWS IoT Greengrass 酷睿软件在关闭 Greengrass 组件进程时会忽略此关闭信号。如果您运行此命令时， AWS IoT Greengrass Core 软件忽略了关机信号，请等待几秒钟，然后重试。
------
#### [ PowerShell ]
+ 检查服务状态
```
Get-Service -Name "greengrass"
```
+ 让核心在设备开机时启动。
```
Set-Service -Name "greengrass" -Status stopped -StartupType automatic
```
+ 在设备开机时阻止核心启动。
```
Set-Service -Name "greengrass" -Status stopped -StartupType disabled
```
+ 启动 AWS IoT Greengrass 核心软件。
```
Start-Service -Name "greengrass"
```
+ 停止 AWS IoT Greengrass 核心软件。
```
Stop-Service -Name "greengrass"
```
**注意**
在 Windows 设备上， AWS IoT Greengrass 酷睿软件在关闭 Greengrass 组件进程时会忽略此关闭信号。如果您运行此命令时， AWS IoT Greengrass Core 软件忽略了关机信号，请等待几秒钟，然后重试。
------
## 使用 JVM 选项控制内存分配
如果您在内存有限的设备 AWS IoT Greengrass 上运行，则可以使用 Java 虚拟机 (JVM) 选项来控制最大堆大小、垃圾收集模式和编译器选项，这些选项控制 AWS IoT Greengrass 核心软件使用的内存量。JVM 中的堆大小决定了在[垃圾回收](https://docs.oracle.com/javase/8/docs/technotes/guides/vm/gctuning/introduction.html)发生之前或应用程序耗尽内存之前，应用程序可以使用的内存量。最大堆大小指定了在占用大量内存的活动期间扩展堆时，JVM 可分配的最大内存量。
要控制内存分配，请创建一个新部署或修改包含核心组件的现有部署，然后在[核心组件配置](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration-jvm-options)的 `jvmOptions` 配置参数中指定您的 JVM 选项。
根据您的要求，您可以在减少内存分配或最小内存分配的情况下运行 C AWS IoT Greengrass ore 软件。
**减少内存分配**
要在减少内存分配的情况下运行 AWS IoT Greengrass Core 软件，我们建议您使用以下示例配置合并更新在 nucleus 配置中设置 JVM 选项：
```
{
"jvmOptions": "-XX:+UseSerialGC -XX:TieredStopAtLevel=1"
}
```
**最低内存分配**
要以最少的内存分配运行 AWS IoT Greengrass Core 软件，我们建议您使用以下示例配置合并更新在 nucleus 配置中设置 JVM 选项：
```
{
"jvmOptions": "-Xmx32m -XX:+UseSerialGC -Xint"
}
```
**重要**
以最少的内存分配运行 AWS IoT Greengrass Core 软件可能会对低规格系统产生显著的性能影响，因为 JVM 在使用更少的内存时会进行更多的处理。我们建议调整选项以平衡内存和性能需求。
这些示例配置合并更新使用了以下 JVM 选项：
`-XX:+UseSerialGC`
指定对 JVM 堆空间使用串行垃圾回收。与其它 JVM 垃圾回收实施相比，串行垃圾收集器虽然速度较慢，但占用的内存更少。
`-XX:TieredStopAtLevel=1`
指示 JVM 使用一次 Java just-in-time (JIT) 编译器。由于 JIT 编译后的代码占用设备内存空间，因此多次使用 JIT 编译器比单次编译消耗的内存更多。
`-XmxNNm`
设置最大 JVM 堆大小。
将最大堆大小设置得太低可能会导致性能下降或出 out-of-memory错。我们建议先测量您当前的堆使用量，然后再使用 `-XmxNNm` 选项设置最大大小。使用 JVM 选项配置 `-XX:NativeMemoryTracking=detail` JVM。然后，使用 [jcmd 实用程序](https://docs.oracle.com/javase/8/docs/technotes/guides/troubleshoot/tooldescr006.html)中的 `VM.native_memory` 命令请求来衡量您当前的堆使用量。
如果无法对堆进行衡量，请将 `-Xmx64m` 作为起始值，以将堆大小限制为 64 MB。然后，再在此基础上逐渐减小最大堆大小。对于最低内存分配，请使用 `-Xmx32m` 作为起始值，将堆大小限制为 32 MB。
您可以根据自己的实际需求增大或减小 `-Xmx` 值；但是我们强烈建议您不要将最大堆大小设置为 16 MB 以下。所需的 JVM 堆大小也可能会随着时间的推移而变化，具体变化取决于部署到核心设备的插件组件。如果最大堆大小对于您的环境来说太低，则 AWS IoT Greengrass Core 软件可能会因为内存不足而遇到意外错误。如果由于内存不足而导致性能下降或遇到错误，请恢复到已知的正常设置。例如，如果您正常提交的堆大小为 `41428KB`，请使用 `-Xmx40m` 来略微限制堆的使用量。
`-Xint`
指示 JVM 不要使用 just-in-time (JIT) 编译器。而指示 JVM 在“仅解释”模式下运行。此模式比运行 JIT 编译后的代码慢（在低端系统上部署可能会慢 20 倍）；但是，编译后的代码不占用任何内存空间。
有关创建配置合并更新的信息，请参阅[更新组件配置](update-component-configurations.md)。
## 配置运行组件的用户
AWS IoT Greengrass Core 软件可以以不同于运行该软件的系统用户和组的身份运行组件进程。这可以提高安全性，因为您可以以 root 用户或管理员用户身份运行 C AWS IoT Greengrass ore 软件，而无需将这些权限授予在核心设备上运行的组件。
下表显示了 AWS IoT Greengrass 核心软件可以以您指定的用户身份运行的组件类型。有关更多信息，请参阅 [组件类型](develop-greengrass-components.md#component-types)。
| 组件类型 | 配置组件用户 |
| --- | --- |
| Nucleus | ![\[No\]](http://docs.aws.amazon.com/zh_cn/greengrass/v2/developerguide/images/icon-no.png)没有 |
| 插件 | ![\[No\]](http://docs.aws.amazon.com/zh_cn/greengrass/v2/developerguide/images/icon-no.png)没有 |
| 通用 | ![\[Yes\]](http://docs.aws.amazon.com/zh_cn/greengrass/v2/developerguide/images/icon-yes.png) 是 |
| Lambda（非容器化） | ![\[Yes\]](http://docs.aws.amazon.com/zh_cn/greengrass/v2/developerguide/images/icon-yes.png) 是 |
| Lambda（容器化） | ![\[Yes\]](http://docs.aws.amazon.com/zh_cn/greengrass/v2/developerguide/images/icon-yes.png) 是 |
您必须先创建组件用户，然后才能在部署配置中指定该用户。在基于 Windows 的设备上，您还必须将用户的用户名和密码存储在账户的凭据管理器实例中。 LocalSystem 有关更多信息，请参阅 [在 Windows 设备上设置组件用户](#create-component-user-windows)。
在基于 Linux 的设备上配置组件用户时，您还可以选择指定组。您使用以下格式指定由半角冒号（`:`）分隔的用户和组：`user:group`。如果您未指定群组，则 AWS IoT Greengrass Core 软件将默认为该用户的主群组。您可以使用名称或 ID 来标识用户和组。
在基于 Linux 的设备上，您还能够以不存在的系统用户（也称为未知用户）身份运行组件，以提高安全性。Linux 进程可以向同一用户运行的任何其它进程发出信号。未知用户不会运行其它进程，因此您能够以未知用户身份运行组件，以防止组件向核心设备上的其它组件发出信号。要以未知用户身份运行组件，请指定一个核心设备上不存在的用户 ID。您还可以指定一个不存在的组 ID，以便以未知组身份运行。
您可以为每个组件和每个核心设备配置用户。
+ **为组件配置**
您可以将每个组件配置为使用特定于该组件的用户运行。创建部署时，您可以为该组件的 `runWith` 配置中的每个组件指定用户。如果您配置组件， AWS IoT Greengrass Core 软件将以指定用户身份运行组件。否则，它将默认以您为核心设备配置的默认用户的身份运行组件。有关在部署配置中指定组件用户的更多信息，请参阅[创建部署](create-deployments.md)中的 [`runWith`](create-deployments.md#component-run-with-config) 配置参数。
+ **为核心设备配置默认用户**
您可以配置 C AWS IoT Greengrass ore 软件用来运行组件的默认用户。当 AWS IoT Greengrass 核心软件运行某个组件时，它会检查您是否为该组件指定了用户，并使用它来运行该组件。如果组件未指定用户，则 AWS IoT Greengrass Core 软件将以您为核心设备配置的默认用户身份运行该组件。有关更多信息，请参阅 [配置默认组件用户](#configure-default-component-user)。
**注意**
在基于 Windows 的设备上，您必须至少指定一个默认用户来运行组件。
在基于 Linux 的设备上，如果您没有配置运行组件的用户，则需要考虑以下注意事项：
如果您以 root 用户身份运行 AWS IoT Greengrass Core 软件，则该软件将无法运行组件。如果您以根用户身份运行，则必须指定默认用户来运行组件。
如果您以非 root 用户身份运行 AWS IoT Greengrass Core 软件，则该软件将以该用户身份运行组件。
**Topics**
+ [在 Windows 设备上设置组件用户](#create-component-user-windows)
+ [配置默认组件用户](#configure-default-component-user)
### 在 Windows 设备上设置组件用户
**在基于 Windows 的设备上设置组件用户**
1. 在设备上的 LocalSystem 帐户中创建组件用户。
```
net user /add component-user password
```
1. 使用 [Microsoft 的 PsExec 实用程序](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec)将组件用户的用户名和密码存储在 LocalSystem 帐户的凭据管理器实例中。
```
psexec -s cmd /c cmdkey /generic:component-user /user:component-user /pass:password
```
**注意**
在基于 Windows 的设备上，该 LocalSystem 帐户运行 Greengrass 核，您必须使用该 PsExec 实用程序将组件用户信息存储在帐户中。 LocalSystem使用凭据管理器应用程序将此信息存储在当前登录用户的 Windows 帐户中，而不是 LocalSystem帐户中。
### 配置默认组件用户
您可以使用某个部署在核心设备上配置默认用户。在此部署中，您更新[核心组件](greengrass-nucleus-component.md)配置。
**注意**
在安装 C AWS IoT Greengrass ore 软件时，也可以使用`--component-default-user`选项设置默认用户。有关更多信息，请参阅 [安装 AWS IoT Greengrass Core 软件](install-greengrass-core-v2.md)。
[创建一个部署](create-deployments.md)，通过该部署为 `aws.greengrass.Nucleus` 组件指定以下配置更新。
------
#### [ Linux ]
```
{
"runWithDefault": {
"posixUser": "ggc_user:ggc_group"
}
}
```
------
#### [ Windows ]
```
{
"runWithDefault": {
"windowsUser": "ggc_user"
}
}
```
**注意**
您指定的用户必须存在，并且该用户的用户名和密码必须存储在您的 Windows 设备上该 LocalSystem 帐户的凭据管理器实例中。有关更多信息，请参阅 [在 Windows 设备上设置组件用户](#create-component-user-windows)。
------
以下示例定义了将 `ggc_user` 配置为默认用户和将 `ggc_group` 配置为默认组的基于 Linux 的设备的部署。`merge` 配置更新需要序列化 JSON 对象。
```
{
"components": {
"aws.greengrass.Nucleus": {
"version": "2.17.0",
"configurationUpdate": {
"merge": "{\"runWithDefault\":{\"posixUser\":\"ggc_user:ggc_group\"}}"
}
}
}
}
```
## 配置组件的系统资源限制
**注意**
[此功能适用于 Greengrass nucleus 组件的 v2.4.0 及更高版本。](greengrass-nucleus-component.md) AWS IoT Greengrass 目前不支持在 Windows 核心设备上使用此功能。
您可以配置每个组件进程可在核心设备上使用的最大 CPU 和 RAM 用量。
下表显示了支持系统资源限制的组件类型。有关更多信息，请参阅 [组件类型](develop-greengrass-components.md#component-types)。
| 组件类型 | 配置系统资源限制 |
| --- | --- |
| Nucleus | ![\[No\]](http://docs.aws.amazon.com/zh_cn/greengrass/v2/developerguide/images/icon-no.png)没有 |
| 插件 | ![\[No\]](http://docs.aws.amazon.com/zh_cn/greengrass/v2/developerguide/images/icon-no.png)没有 |
| 通用 | ![\[Yes\]](http://docs.aws.amazon.com/zh_cn/greengrass/v2/developerguide/images/icon-yes.png) 是 |
| Lambda（非容器化） | ![\[Yes\]](http://docs.aws.amazon.com/zh_cn/greengrass/v2/developerguide/images/icon-yes.png) 是 |
| Lambda（容器化） | ![\[No\]](http://docs.aws.amazon.com/zh_cn/greengrass/v2/developerguide/images/icon-no.png)没有 |
**重要**
在 [Docker 容器中运行 C AWS IoT Greengrass ore 软件时，](run-greengrass-docker.md)不支持系统资源限制。
您可以为每个组件和每个核心设备配置系统资源限制。
+ **为组件配置**
您可以为每个组件配置特定于该组件的系统资源限制。创建部署时，您可以为部署中的每个组件指定系统资源限制。如果组件支持系统资源限制，则 AWS IoT Greengrass Core 软件会将限制应用于组件进程。如果您没有为组件指定系统资源限制，则 AWS IoT Greengrass Core 软件将使用您为核心设备配置的任何默认值。有关更多信息，请参阅 [创建部署](create-deployments.md)。
+ **为核心设备配置默认值**
您可以配置 C AWS IoT Greengrass ore 软件应用于支持这些限制的组件的默认系统资源限制。当 AWS IoT Greengrass 核心软件运行某个组件时，它会应用您为该组件指定的系统资源限制。如果该组件未指定系统资源限制，则 AWS IoT Greengrass Core 软件将应用您为核心设备配置的默认系统资源限制。如果您未指定默认的系统资源限制，则默认情况下， AWS IoT Greengrass Core 软件不会应用任何系统资源限制。有关更多信息，请参阅 [配置默认系统资源限制](#configure-default-component-system-resource-limits)。
### 配置默认系统资源限制
您可以部署 [Greengrass Nucleus 组件](greengrass-nucleus-component.md)，以为核心设备配置默认系统资源限制。要配置默认的系统资源限制，请[创建一个部署](create-deployments.md)，通过该部署为 `aws.greengrass.Nucleus` 组件指定以下配置更新。
```
{
"runWithDefault": {
"systemResourceLimits": {
"cpu": cpuTimeLimit,
"memory": memoryLimitInKb
}
}
}
```
以下示例定义了一个部署，该部署将 CPU 时间限制配置为 `2`，这相当于在具有 4 个 CPU 内核的设备上使用 50% 的时间。此示例还将内存使用量配置为 100 MB。
```
{
"components": {
"aws.greengrass.Nucleus": {
"version": "2.17.0",
"configurationUpdate": {
"merge": "{\"runWithDefault\":{\"systemResourceLimits\":\"cpus\":2,\"memory\":102400}}}"
}
}
}
}
```
## 通过端口 443 或网络代理进行连接
AWS IoT Greengrass 核心设备 AWS IoT Core 使用带有 TLS 客户端身份验证的 MQTT 消息协议与之通信。按照惯例，基于 TLS 的 MQTT 使用端口 8883。但是，作为一项安全措施，限制性环境可能会将入站和出站流量限制到一个较小的 TCP 端口范围。例如，企业防火墙可能会为 HTTPS 流量打开端口 443，但关闭不常用协议使用的其他端口，例如用于 MQTT 流量的端口 8883。其它限制性环境可能要求所有流量经由代理连接到互联网。
**注意**
运行 Greengrass 核心组件 v2.0.3 及更早版本的 [Greengrass 核心设备使用端口 8443 连接到数据](greengrass-nucleus-component.md)平面端点。 AWS IoT Greengrass 这些设备必须能够通过端口 8443 连接到此端点。有关更多信息，请参阅 [允许设备流量通过代理或防火墙](allow-device-traffic.md)。
为了在这些情况下启用通信， AWS IoT Greengrass 提供了以下配置选项：
+ **通过端口 443 进行 MQTT 通信**。如果您的网络允许连接到端口 443，则可以将 Greengrass 核心设备配置为使用端口 443（而非默认端口 8883）进行 MQTT 通信。这可以是与端口 443 的直接连接，也可以是通过网络代理服务器的连接。与使用基于证书的客户端身份验证的默认配置不同，端口 443 上的 MQTT 使用[设备服务角色](device-service-role.md)进行身份验证。
有关更多信息，请参阅 [通过端口 443 配置 MQTT](#configure-mqtt-port-443)。
+ **通过端口 443 进行 HTTPS 通信**。默认情况下， AWS IoT Greengrass 核心软件通过端口 8443 发送 HTTPS 流量，但您可以将其配置为使用端口 443。 AWS IoT Greengrass 使用[应用层协议网络](https://tools.ietf.org/html/rfc7301) (ALPN) TLS 扩展来启用此连接。与默认配置一样，端口 443 上的 HTTPS 使用基于证书的客户端身份验证。
**重要**
要使用 ALPN 并通过端口 443 启用 HTTPS 通信，您的核心设备必须运行 Java 8 更新 252 或更高版本。Java 版本 9 及更高版本的所有更新也支持 ALPN。
有关更多信息，请参阅 [通过端口 443 配置 HTTPS](#configure-https-port-443)。
+ **通过网络代理连接**。您可以配置一个网络代理服务器来充当连接到 Greengrass 核心设备的媒介。 AWS IoT Greengrass 支持针对 HTTP 和 HTTPS 代理的基本身份验证。
Greengrass 核心设备必须运行 [Greengrass Nucleus](greengrass-nucleus-component.md) v2.5.0 或更高版本才能使用 HTTPS 代理。
C AWS IoT Greengrass ore 软件通过`ALL_PROXY`、`HTTP_PROXY``HTTPS_PROXY`、和`NO_PROXY`环境变量将代理配置传递给组件。组件必须使用这些设置才能经由代理进行连接。组件使用通常默认使用这些环境变量的公用库（例如 boto3、URL 和 python `requests` 程序包）建立连接。如果组件还指定了这些环境变量，则 AWS IoT Greengrass 不会覆盖它们。
有关更多信息，请参阅 [配置网络代理](#configure-network-proxy)。
### 通过端口 443 配置 MQTT
您可以在现有核心设备上配置通过端口 443 的 MQTT，也可以在新的核心设备上安装 AWS IoT Greengrass Core 软件时进行此配置。
**Topics**
+ [在现有核心设备上配置通过端口 443 的 MQTT](#configure-mqtt-port-443-deployment)
+ [在安装过程中通过端口 443 配置 MQTT](#configure-mqtt-port-443-installer)
#### 在现有核心设备上配置通过端口 443 的 MQTT
您可以使用某个部署在单个核心设备或一组核心设备上配置通过端口 443 的 MQTT。在此部署中，您更新[核心组件](greengrass-nucleus-component.md)配置。当您更新核心的 `mqtt` 配置时，核心会重新启动。
要通过端口 443 配置 MQTT，请[创建一个部署](create-deployments.md)，通过该部署为 `aws.greengrass.Nucleus` 组件指定以下配置更新。
```
{
"mqtt": {
"port": 443
}
}
```
以下示例定义了一个部署，该部署配置了通过端口 443 的 MQTT。`merge` 配置更新需要序列化 JSON 对象。
```
{
"components": {
"aws.greengrass.Nucleus": {
"version": "2.17.0",
"configurationUpdate": {
"merge": "{\"mqtt\":{\"port\":443}}"
}
}
}
}
```
#### 在安装过程中通过端口 443 配置 MQTT
在核心设备上安装 AWS IoT Greengrass 核心软件时，可以通过端口 443 配置 MQTT。使用 `--init-config` 安装程序参数配置通过端口 443 的 MQTT。在使用[手动预置](manual-installation.md)、[实例集预置](fleet-provisioning.md)或[自定义预置](custom-provisioning.md)进行安装时，您可以指定此参数。
### 通过端口 443 配置 HTTPS
此功能需要 [Greengrass Nucleus](greengrass-nucleus-component.md) v2.0.40 或更高版本。
您可以在现有核心设备上配置通过端口 443 的 HTTPS，也可以在新的核心设备上安装 AWS IoT Greengrass Core 软件时进行此配置。
**Topics**
+ [在现有核心设备上配置通过端口 443 的 HTTPS](#configure-https-port-443-deployment)
+ [在安装过程中配置通过端口 443 的 HTTPS](#configure-https-port-443-installer)
#### 在现有核心设备上配置通过端口 443 的 HTTPS
您可以使用某个部署在单个核心设备或一组核心设备上配置通过端口 443 的 HTTPS。在此部署中，您更新[核心组件](greengrass-nucleus-component.md)配置。
要通过端口 443 配置 HTTPS，请[创建一个部署](create-deployments.md)，通过该部署为 `aws.greengrass.Nucleus` 组件指定以下配置更新。
```
{
"greengrassDataPlanePort": 443
}
```
以下示例定义了一个部署，该部署配置了通过端口 443 的 HTTPS。`merge` 配置更新需要序列化 JSON 对象。
```
{
"components": {
"aws.greengrass.Nucleus": {
"version": "2.17.0",
"configurationUpdate": {
"merge": "{\"greengrassDataPlanePort\":443}"
}
}
}
}
```
#### 在安装过程中配置通过端口 443 的 HTTPS
在核心设备上安装 AWS IoT Greengrass 核心软件时，可以通过端口 443 配置 HTTPS。使用 `--init-config` 安装程序参数配置通过端口 443 的 HTTPS。在使用[手动预置](manual-installation.md)、[实例集预置](fleet-provisioning.md)或[自定义预置](custom-provisioning.md)进行安装时，您可以指定此参数。
### 配置网络代理
按照本节中的步骤将 Greengrass 核心设备配置为经由 HTTP 或 HTTPS 网络代理连接到互联网。有关核心设备使用的端点和端口的更多信息，请参阅[允许设备流量通过代理或防火墙](allow-device-traffic.md)。
**重要**
如果您的核心设备运行的 [Greengrass Nucleus](greengrass-nucleus-component.md) 版本低于 v2.4.0，则设备的角色必须具有以下权限才能使用网络代理：
`iot:Connect`
`iot:Publish`
`iot:Receive`
`iot:Subscribe`
这是必要的，因为设备使用来自令牌交换服务的 AWS 凭证来验证与 MQTT 的连接。 AWS IoT设备使用 MQTT 接收和安装来自的部署 AWS 云，因此，除非您对其角色定义这些权限，否则您的设备将无法运行。设备通常使用 X.509 证书对 MQTT 连接进行身份验证，但是设备在使用代理时无法使用此证书进行身份验证。
有关如何配置设备角色的更多信息，请参阅[授权核心设备与 AWS 服务交互](device-service-role.md)。
**Topics**
+ [在现有核心设备上配置网络代理](#configure-network-proxy-deployment)
+ [在安装过程中配置网络代理](#configure-network-proxy-installer)
+ [使核心设备信任 HTTPS 代理](#https-proxy-certificate-trust)
+ [networkProxy 对象](#network-proxy-object)
#### 在现有核心设备上配置网络代理
您可以使用某个部署在单个核心设备或一组核心设备上配置网络代理。在此部署中，您更新[核心组件](greengrass-nucleus-component.md)配置。当您更新核心的 `networkProxy` 配置时，核心会重新启动。
要配置网络代理，请为 `aws.greengrass.Nucleus` 组件[创建一个部署](create-deployments.md)，通过该部署合并以下配置更新。此配置更新包含 [networkProxy 对象](#network-proxy-object)。
```
{
"networkProxy": {
"noProxyAddresses": "http://192.168.0.1,www.example.com",
"proxy": {
"url": "https://my-proxy-server:1100"
}
}
}
```
以下示例定义了一个部署，该部署配置了网络代理。`merge` 配置更新需要序列化 JSON 对象。
```
{
"components": {
"aws.greengrass.Nucleus": {
"version": "2.17.0",
"configurationUpdate": {
"merge": "{\"networkProxy\":{\"noProxyAddresses\":\"http://192.168.0.1,www.example.com\",\"proxy\":{\"url\":\"https://my-proxy-server:1100\",\"username\":\"Mary_Major\",\"password\":\"pass@word1357\"}}}"
}
}
}
}
```
#### 在安装过程中配置网络代理
在 AWS IoT Greengrass 核心设备上安装 Core 软件时，可以配置网络代理。使用 `--init-config` 安装程序参数配置网络代理。在使用[手动预置](manual-installation.md)、[实例集预置](fleet-provisioning.md)或[自定义预置](custom-provisioning.md)进行安装时，您可以指定此参数。
#### 使核心设备信任 HTTPS 代理
将核心设备配置为使用 HTTPS 代理时，必须将代理服务器证书链添加到核心设备中，使其能够信任 HTTPS 代理。否则，核心设备在尝试通过代理路由流量时可能会遇到错误。将代理服务器 CA 证书添加到核心设备的 Amazon 根 CA 证书文件中。
**使核心设备信任 HTTPS 代理的步骤**
1. 在核心设备上找到 Amazon 根 CA 证书文件。
+ 如果您安装了具有[自动配置功能](quick-installation.md)的 C AWS IoT Greengrass ore 软件，则 Amazon 根 CA 证书文件位于中`/greengrass/v2/rootCA.pem`。
+ 如果您使用[手动](manual-installation.md)或[队列配置](fleet-provisioning.md)安装 AWS IoT Greengrass 核心软件，则 Amazon 根 CA 证书文件可能存在于`/greengrass/v2/AmazonRootCA1.pem`。
如果这些位置不存在 Amazon 根 CA 证书，请查看 `/greengrass/v2/config/effectiveConfig.yaml` 中的 `system.rootCaPath` 属性，来查找其位置。
1. 将代理服务器 CA 证书文件的内容添加到 Amazon 根 CA 证书文件中。
以下示例显示了添加到 Amazon 根 CA 证书文件中的代理服务器 CA 证书。
```
-----BEGIN CERTIFICATE-----
MIIEFTCCAv2gAwIQWgIVAMHSAzWG/5YVRYtRQOxXUTEpHuEmApzGCSqGSIb3DQEK
\nCwUAhuL9MQswCQwJVUzEPMAVUzEYMBYGA1UECgwP1hem9uLmNvbSBJbmMuMRww
... content of proxy CA certificate ...
+vHIRlt0e5JAm5\noTIZGoFbK82A0/nO7f/t5PSIDAim9V3Gc3pSXxCCAQoFYnui
GaPUlGk1gCE84a0X\n7Rp/lND/PuMZ/s8YjlkY2NmYmNjMCAXDTE5MTEyN2cM216
gJMIADggEPADf2/m45hzEXAMPLE=
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
MIIDQTCCAimgF6AwIBAgITBmyfz/5mjAo54vB4ikPmljZKyjANJmApzyMZFo6qBg
ADA5MQswCQYDVQQGEwJVUzEPMA0tMVT8QtPHRh8jrdkGA1UEChMGDV3QQDExBBKW
... content of root CA certificate ...
o/ufQJQWUCyziar1hem9uMRkwFwYVPSHCb2XV4cdFyQzR1KldZwgJcIQ6XUDgHaa
5MsI+yMRQ+hDaXJiobldXgjUka642M4UwtBV8oK2xJNDd2ZhwLnoQdeXeGADKkpy
rqXRfKoQnoZsG4q5WTP46EXAMPLE
-----END CERTIFICATE-----
```
#### networkProxy 对象
使用 `networkProxy` 对象指定有关网络代理的信息。该对象包含以下信息：
`noProxyAddresses`
（可选）不使用代理的 IP 地址或主机名的逗号分隔列表。
`proxy`
要连接的代理。该对象包含以下信息：
`url`
代理服务器的 URL，格式为 `scheme://userinfo@host:port`。
+ `scheme` – 方案，必须是 `http` 或 `https`。
**重要**
Greengrass 核心设备必须运行 [Greengrass Nucleus](greengrass-nucleus-component.md) v2.5.0 或更高版本才能使用 HTTPS 代理。
如果您配置 HTTPS 代理，则必须将代理服务器 CA 证书添加到核心设备的 Amazon 根 CA 证书中。有关更多信息，请参阅 [使核心设备信任 HTTPS 代理](#https-proxy-certificate-trust)。
+ `userinfo` –（可选）用户名和密码信息。如果您在 `url` 中指定此信息，则 Greengrass 核心设备将忽略 `username` 和 `password` 字段。
+ `host` – 代理服务器的主机名或 IP 地址。
+ `port` –（可选）端口号。如果您未指定端口，则 Greengrass 核心设备将使用以下默认值：
+ `http` – 80
+ `https` – 443
`username`
（可选）代理服务器进行身份验证时使用的用户名。
`password`
（可选）用于对代理服务器进行身份验证的密码。
## 使用由私有 CA 签名的设备证书
如果您使用自定义私有证书颁发机构（CA），则必须将 Greengrass Nucleus 的 **greengrassDataPlaneEndpoint** 设置为 **iotdata**。您可以在部署或安装期间使用 **--init-config** [ 安装程序参数](configure-installer.md)设置此选项。
您可以自定义设备连接的 Greengrass 数据面板端点。您可以将此配置选项设置为 **iotdata**，以将 Greengrass 数据面板端点设置为与 IoT 数据端点相同的端点，您可以使用 **iotDataEndpoint** 指定该端点。
## 配置 MQTT 超时和缓存设置
在 AWS IoT Greengrass 环境中，组件可以使用 MQTT 进行 AWS IoT Core通信。 AWS IoT Greengrass 核心软件管理组件的 MQTT 消息。当核心设备与 AWS 云断开连接时，软件会缓存 MQTT 消息，以便稍后在连接恢复后重试。您可以配置消息超时和缓存大小等设置。有关更多信息，请参阅 [Greengrass Nucleus 组件](greengrass-nucleus-component.md)的 `mqtt` 和 `mqtt.spooler` 配置参数。
AWS IoT Core 对其 MQTT 消息代理施加服务配额。这些配额可能适用于您在核心设备和 AWS IoT Core之间发送的消息。有关更多信息，请参阅 *AWS 一般参考* 中的 [AWS IoT Core 消息代理服务配额](https://docs.aws.amazon.com/general/latest/gr/iot-core.html#message-broker-limits)。
## 在网络上配置 Greengrass Nucleus IPv6
[Greengrass Nucleus 通过 Greengrass 与之交谈。 AWS IoT Core APIs](https://docs.aws.amazon.com/general/latest/gr/greengrassv2.html)双栈环境下支持 APIs Greengr IPv6 ass。
要启用双栈端点，请执行以下操作： IPv6
+ 添加系统属性 `aws.useDualstackEndpoint=true` 和 `java.net.preferIPv6Addresses=true` 至 `jvmOptions`
+ 将 `s3EndpointType` 设置为 `DUALSTACK`
在[部署](https://docs.aws.amazon.com/greengrass/v2/developerguide/create-deployments.html)期间设置此选项，或者使用 `--init-config` [安装程序参数](https://docs.aws.amazon.com/greengrass/v2/developerguide/configure-installer.html)手动配置。请参阅[使用 Amazon S3 双堆栈端点](https://docs.aws.amazon.com/AmazonS3/latest/API/dual-stack-endpoints.html)了解更多详细信息。
**Example 部署代码：**
```
{
"jvmOptions": "-Daws.useDualstackEndpoint=true",
"s3EndpointType":"DUALSTACK"
}
```
**Example 通过手动配置进行 `config.yaml`：**
```
---
system:
...
services:
aws.greengrass.Nucleus:
...
configuration:
...
jvmOptions: "-Daws.useDualstackEndpoint=true -Djava.net.preferIPv6Addresses=true"
s3EndpointType: "DUALSTACK"
```
# 更新 AWS IoT Greengrass Core 软件（OTA）
AWS IoT Greengrass Core 软件包括 [Greengrass Nucleus 组件](greengrass-nucleus-component.md)和其它可选组件，您可以将这些组件部署到设备上，以执行软件的空中下载（OTA）更新。此功能内置在 AWS IoT Greengrass Core 软件中。
OTA 更新可以更高效地执行以下操作：
+ 修复安全漏洞。
+ 解决软件稳定性问题。
+ 部署新的或改进的功能。
**Topics**
+ [要求](#ota-update-requirements)
+ [核心设备注意事项](#ota-update-considerations)
+ [Greengrass Nucleus 更新行为](#ota-update-behavior-nucleus)
+ [执行 OTA 更新](#create-ota-update)
## 要求
以下要求适用于部署 AWS IoT Greengrass Core 软件的 OTA 更新：
+ Greengrass 核心设备必须连接到 AWS 云 才能接收部署。
+ 必须使用证书和密钥正确配置和预置 Greengrass 核心设备，以便对 AWS IoT Core 和 AWS IoT Greengrass 进行身份验证。
+ AWS IoT Greengrass Core 软件必须作为系统服务进行设置和运行。如果您通过 JAR 文件 `Greengrass.jar` 运行 Nucleus，OTA 更新将不起作用。有关更多信息，请参阅 [将 Greengrass Nucleus 配置为系统服务](configure-greengrass-core-v2.md#configure-system-service)。
## 核心设备注意事项
在执行 OTA 更新之前，请注意对您更新的核心设备及其连接的客户端设备的影响：
+ Greengrass Nucleus 会关闭。
+ 在核心设备上运行的所有组件也会关闭。如果这些组件写入本地资源，除非正常关闭，否则它们可能会导致这些资源的状态不正确。组件可以使用[进程间通信](interprocess-communication.md)来让 Nucleus 组件推迟更新，直到它们清理所使用的资源。
+ 当 Nucleus 组件关闭时，核心设备会失去与 AWS 云和本地设备的连接。核心设备关闭后不会路由来自客户端设备的消息。
+ 作为组件运行且长时间存在的 Lambda 函数会丢失其动态状态信息，并丢弃所有待处理的工作。
## Greengrass Nucleus 更新行为
部署组件时，AWS IoT Greengrass 会安装该组件所有依赖关系的最新受支持版本。因此，如果您向事物组添加新设备或更新针对这些设备的部署，则 AWS 提供的公有组件的新补丁版本可能会自动部署到您的核心设备上。某些自动更新（例如 Nucleus 更新）可能会导致您的设备意外重启。
当 [Greengrass Nucleus 组件](greengrass-nucleus-component.md)的版本发生更改时，AWS IoT Greengrass Core 软件（包括 Nucleus 和设备上的所有其它组件）会重启以应用更改。由于更新 Nucleus 组件时会[对核心设备产生影响](#ota-update-considerations)，因此您可能需要控制何时将新 Nucleus 补丁版本部署到您的设备。为此，您必须直接将 Greengrass Nucleus 组件包括在部署中。直接包含组件意味着您在部署配置中包含该组件的特定版本，而不依赖组件依赖关系将该组件部署到您的设备上。有关在组件配方中定义依赖关系的更多信息，请参阅[配方格式](component-recipe-reference.md#recipe-format)。
根据您的操作和部署配置，查看下表，了解 Greengrass Nucleus 组件的更新行为。
| 操作 | 部署配置 | Nucleus 更新行为 |
| --- | --- | --- |
| 在现有部署的目标事物组中添加新设备，而无需修改部署。 | 该部署不直接包括 Greengrass Nucleus。该部署直接包括至少一个由 AWS 提供的组件，或者包括依赖于 AWS 提供的组件或 Greengrass Nucleus 的自定义组件。 | 在新设备上，安装符合所有组件依赖关系要求的最新补丁版本的 Nucleus。在现有设备上，不会更新已安装的 Nucleus 版本。 |
| 在现有部署的目标事物组中添加新设备，而无需修改部署。 | 该部署直接包括特定版本的 Greengrass Nucleus。 | 在新设备上，安装指定的 Nucleus 版本。在现有设备上，不会更新已安装的 Nucleus 版本。 |
| 创建新部署或修改现有部署。 | 该部署不直接包括 Greengrass Nucleus。该部署直接包括至少一个由 AWS 提供的组件，或者包括依赖于 AWS 提供的组件或 Greengrass Nucleus 的自定义组件。 | 在所有目标设备（包括您添加至目标事物组的任何新设备）上，安装符合所有组件依赖关系要求的最新补丁版本的 Nucleus。 |
| 创建新部署或修改现有部署。 | 该部署直接包括特定版本的 Greengrass Nucleus。 | 在所有目标设备（包括您添加至目标事物组的任何新设备）上，安装指定的 Nucleus 版本。 |
## 执行 OTA 更新
要执行 OTA 更新，请[创建一个部署](create-deployments.md)，其中包括 [Nucleus 组件](greengrass-nucleus-component.md)和要安装的版本。
# 卸载 AWS IoT Greengrass Core 软件
您可以卸载 AWS IoT Greengrass Core 软件，将其从不想用作 Greengrass 核心设备的设备中移除。您也可以使用这些步骤来清理失败的安装。
**卸载 AWS IoT Greengrass Core 软件**
1. 如果将软件作为系统服务运行，则必须停止、禁用和移除该服务。运行适用于您的操作系统的命令。
------
#### [ Linux ]
1. 停止 服务。
```
sudo systemctl stop greengrass.service
```
1. 禁用服务。
```
sudo systemctl disable greengrass.service
```
1. 移除服务。
```
sudo rm /etc/systemd/system/greengrass.service
```
1. 确认服务是否删除。
```
sudo systemctl daemon-reload && sudo systemctl reset-failed
```
------
#### [ Windows (Command Prompt) ]
**注意**
必须以管理员身份运行命令提示符才能运行这些命令。
1. 停止 服务。
```
sc stop "greengrass"
```
1. 禁用服务。
```
sc config "greengrass" start=disabled
```
1. 移除服务。
```
sc delete "greengrass"
```
1. 重启设备。
------
#### [ Windows (PowerShell) ]
**注意**
您必须以管理员身份运行 PowerShell 才能运行这些命令。
1. 停止 服务。
```
Stop-Service -Name "greengrass"
```
1. 禁用服务。
```
Set-Service -Name "greengrass" -Status stopped -StartupType disabled
```
1. 移除服务。
+ 适用于 PowerShell 6.0 和更高版本：
```
Remove-Service -Name "greengrass" -Confirm:$false -Verbose
```
+ 适用于 6.0 之前的 PowerShell 版本：
```
Get-Item HKLM:\SYSTEM\CurrentControlSet\Services\greengrass | Remove-Item -Force -Verbose
```
1. 重启设备。
------
1. 从设备中移除根文件夹。将 `/greengrass/v2` 或 *C:\$1greengrass\$1v2* 替换为根文件夹路径。
------
#### [ Linux ]
```
sudo rm -rf /greengrass/v2
```
------
#### [ Windows (Command Prompt) ]
```
rmdir /s /q C:\greengrass\v2
```
------
#### [ Windows (PowerShell) ]
```
cmd.exe /c "rmdir /s /q C:\greengrass\v2"
```
------
1. 从 AWS IoT Greengrass 服务中删除该核心设备。此步骤将从 AWS 云 中移除核心设备的状态信息。如果您计划将 AWS IoT Greengrass Core 软件重新安装到同名的核心设备上，请务必完成此步骤。
+ 要从 AWS IoT Greengrass 控制台删除核心设备，请执行以下操作：
1. 导航至 [AWS IoT Greengrass 控制台](https://console.aws.amazon.com/greengrass)。
1. 选择**核心设备**。
1. 选择要删除的核心设备。
1. 选择**删除**。
1. 在确认模态窗口中，选择**删除**。
+ 要使用 AWS Command Line Interface 删除核心设备，请使用 [DeleteCoreDevice](https://docs.aws.amazon.com/greengrass/v2/APIReference/API_DeleteCoreDevice.html) 操作。运行以下命令，然后将 *MyGreengrassCore* 替换为核心设备的名称。
```
aws greengrassv2 delete-core-device --core-device-thing-name MyGreengrassCore
```