本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。 # 教程：AWS IoT Greengrass V2 入门 您可以完成本入门教程来学习 AWS IoT Greengrass V2 的基本功能。在本教程中，您将执行以下操作： 1. 在 Linux 设备（例如 Raspberry Pi）或 Windows 设备上安装和配置 AWS IoT Greengrass Core 软件。此设备是 Greengrass 核心设备。 1. 在您的 Greengrass 核心设备上开发一个 Hello World 组件。组件是在 Greengrass 核心设备上运行的软件模块。 1. 将该组件上传到 AWS 云 中的 AWS IoT Greengrass V2。 1. 将该组件从 AWS 云 部署到您的 Greengrass 核心设备。 **注意** 本教程介绍如何设置开发环境并探索 AWS IoT Greengrass 的功能。有关如何设置和配置生产设备的更多信息，请参阅以下内容： [设置 AWS IoT Greengrass 核心设备](setting-up.md) [安装 AWS IoT Greengrass Core 软件](install-greengrass-core-v2.md) 您预计需要花费 20 到 30 分钟来完成本教程。 **Topics** + [先决条件](getting-started-prerequisites.md) + [第 1 步：设置 AWS 账户](getting-started-set-up-aws-account.md) + [第 2 步：设置环境](getting-started-set-up-environment.md) + [步骤 3：安装 AWS IoT Greengrass 核心软件](install-greengrass-v2.md) + [第 4 步：在设备上开发和测试组件](create-first-component.md) + [步骤 5：在 AWS IoT Greengrass 服务中创建您的组件](upload-first-component.md) + [第 6 步：部署组件](deploy-first-component.md) + [后续步骤](getting-started-next-steps.md) # 先决条件 要完成本入门教程，您需要以下条件： + AWS 账户。如果没有，请参阅[第 1 步：设置 AWS 账户](getting-started-set-up-aws-account.md)。 + 使用支持 AWS IoT Greengrass V2 的 [AWS 区域](https://en.wikipedia.org/wiki/Amazon_Web_Services#Availability_and_topology)。有关支持的区域列表，请参见 *AWS 一般参考* 中的 [AWS IoT Greengrass V2 端点和配额](https://docs.aws.amazon.com/general/latest/gr/greengrassv2.html)。 + 具有管理员权限的 AWS Identity and Access Management（IAM）用户。 + 设置为 Greengrass 核心设备的设备，例如支持 [Raspberry Pi 操作系统](https://www.raspberrypi.org/downloads/)（以前称为 Raspbian）的 Raspberry Pi或 Windows 10 设备。您必须拥有此设备的管理员权限，或者能够（例如通过 `sudo`）获得管理员权限。此设备必须连接互联网。 您还可以选择使用符合要求的其他设备来安装和运行 AWS IoT Greengrass Core 软件。 如果您的开发计算机满足这些要求，则可以按照本教程将其设置为 Greengrass 核心设备。 + [Python](https://www.python.org/downloads/) 3.5 或更高版本已为所有用户安装在设备上，并已添加到 `PATH` 环境变量中。在 Windows 上，您还必须为所有用户安装适用于 Windows 的 Python 启动程序。 **重要** 在 Windows 中，默认情况下不会为所有用户安装 Python。安装 Python 时，您必须自定义安装以对其进行配置，以便 AWS IoT Greengrass 软件运行 Python 脚本。例如，如果您使用图形化 Python 安装程序，则执行以下操作： 选择**为所有用户安装启动程序（推荐）**。 选择 **Customize installation**。 选择 **Next**。 选择 **Install for all users**。 选择 **Add Python to environment variables**。 选择**安装**。 有关更多信息，请参阅 [Python 3 文档](https://docs.python.org/3/using/windows.html)中的*在 Windows 上使用 Python*。 + 已在您的开发计算机和设备上安装 AWS Command Line Interface（AWS CLI），并使用凭证进行配置。请务必使用相同的 AWS 区域在开发计算机和设备上配置 AWS CLI。要结合使用 AWS IoT Greengrass V2 与 AWS CLI，您必须拥有以下版本之一或更高版本： + 最低 AWS CLI V1 版本：v1.18.197 + 最低 AWS CLI V2 版本：v2.1.11 **提示** 您可以运行以下命令以核查您所拥有的 AWS CLI 版本。 ``` aws --version ``` 有关更多信息，请参阅《AWS Command Line Interface 用户指南》中的[安装、更新和卸载 AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) 以及[配置 AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html)。** **注意** 如果您使用 32 位 ARM 设备，例如支持 32 位操作系统的 Raspberry Pi，请安装 AWS CLI V1。AWS CLIV2 不适用于 32 位 ARM 设备。有关更多信息，请参阅[安装、更新和卸载 AWS CLI 版本 1](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv1.html)。 # 第 1 步：设置 AWS 账户 ## 注册获取 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)。 AWS 注册过程完成后会向您发送一封确认电子邮件。您可以随时前往 [https://aws.amazon.com/](https://aws.amazon.com/)并选择 “**我的账户”，查看您当前的账户活动并管理您的账户**。 ## 创建具有管理访问权限的用户 注册后，请保护您的安全 AWS 账户 AWS 账户根用户 AWS IAM Identity Center，启用并创建管理用户，这样您就不会使用 root 用户执行日常任务。 **保护你的 AWS 账户根用户** 1. 选择 **Root 用户**并输入您的 AWS 账户 电子邮件地址，以账户所有者的身份登录。[AWS 管理控制台](https://console.aws.amazon.com/)在下一页上，输入您的密码。 要获取使用根用户登录方面的帮助，请参阅《AWS 登录 用户指南》**中的 [Signing in as the root user](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial)。 1. 为您的根用户启用多重身份验证（MFA）。 有关说明，请参阅 I [A *M* 用户指南中的为 AWS 账户 根用户启用虚拟 MFA 设备（控制台）](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html)。 **创建具有管理访问权限的用户** 1. 启用 IAM Identity Center。 有关说明，请参阅**《AWS IAM Identity Center 用户指南》中的 [Enabling AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html)。 1. 在 IAM Identity Center 中，为用户授予管理访问权限。 有关使用 IAM Identity Center 目录 作为身份源的教程，请参阅《[用户*指南》 IAM Identity Center 目录中的使用默认设置配置AWS IAM Identity Center 用户*访问权限](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html)。 **以具有管理访问权限的用户身份登录** + 要使用您的 IAM Identity Center 用户身份登录，请使用您在创建 IAM Identity Center 用户时发送到您的电子邮件地址的登录网址。 有关使用 IAM Identity Center 用户[登录的帮助，请参阅*AWS 登录 用户指南*中的登录 AWS 访问门户](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html)。 **将访问权限分配给其他用户** 1. 在 IAM Identity Center 中，创建一个权限集，该权限集遵循应用最低权限的最佳做法。 有关说明，请参阅《AWS IAM Identity Center 用户指南》**中的 [Create a permission set](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html)。 1. 将用户分配到一个组，然后为该组分配单点登录访问权限。 有关说明，请参阅《AWS IAM Identity Center 用户指南》**中的 [Add groups](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html)。 # 第 2 步：设置环境 **注意** 这些步骤不适用于 Nucleus Lite。 按照本节中的步骤，将 Linux 或 Windows 设备设置为您的 AWS IoT Greengrass 核心设备。 ## 设置 Linux 设备（Raspberry Pi） 这些步骤假设您使用搭载 Raspberry Pi 操作系统的 Raspberry Pi。如果您使用其它设备或操作系统，请查阅您设备的相关文档。 **要设置 Raspberry Pi AWS IoT Greengrass V2** 1. 启用 Raspberry Pi 上的 SSH 才能远程连接到它。有关更多信息，请参阅《Raspberry Pi 文档》**中的 [SSH（安全 shell）](https://www.raspberrypi.com/documentation/computers/remote-access.html#ssh)。 1. 找到 Raspberry Pi 的 IP 地址，通过 SSH 与之连接。为此，可以在 Raspberry Pi 上运行以下命令。 ``` hostname -I ``` 1. 通过 SSH 连接到 Raspberry Pi。 在开发计算机上运行以下命令。*username*替换为要登录的用户名，然后*pi-ip-address*替换为在上一步中找到的 IP 地址。 ``` ssh username@pi-ip-address ``` **重要** 如果您的开发计算机使用的是较早版本的 Windows，那么您可能没有 `ssh` 命令，或者可能有 `ssh` 但无法连接到您的 Raspberry Pi。要连接 Raspberry Pi，您可以安装和配置 [PuTTY](https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html)，这是一款免费的开源 SSH 客户端。要连接 Raspberry Pi，请查阅 [Putty 文档](https://tartarus.org/~simon/putty-snapshots/htmldoc/Chapter2.html#gs)。 1. 安装 Java 运行时， AWS IoT Greengrass 核心软件需要运行该运行时。在 Raspberry Pi 上，使用以下命令安装 Java 11。 ``` sudo apt install default-jdk ``` 安装完成后，运行以下命令验证 Java 是否已在 Raspberry Pi 上运行。 ``` java -version ``` 此命令会打印设备上运行的 Java 版本。该输出可能类似于以下示例： ``` 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) ``` **提示：在 Raspberry Pi 上设置内核参数** 如果您的设备是 Raspberry Pi，则可以完成以下步骤来查看和更新其 Linux 内核参数： 打开 `/boot/cmdline.txt` 文件。此文件指定 Raspberry Pi 启动时需要应用的 Linux 内核参数。 例如，在 Linux 系统上，您可以运行以下命令来使用 GNU nano 打开文件。 ``` sudo nano /boot/cmdline.txt ``` 确认 `/boot/cmdline.txt` 文件包含以下内核参数。`systemd.unified_cgroup_hierarchy=0` 参数指定使用 cgroups v1，而非 cgroups v2。 ``` cgroup_enable=memory cgroup_memory=1 systemd.unified_cgroup_hierarchy=0 ``` 如果 `/boot/cmdline.txt` 文件不包含这些参数，或者包含这些参数但参数值不同，请更新该文件以包含这些参数和值。 如果您更新了 `/boot/cmdline.txt` 文件，请重新启动 Raspberry Pi 以应用更改。 ``` sudo reboot ``` ## 设置 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 设备 **要将 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 帐户中。 # 步骤 3：安装 AWS IoT Greengrass 核心软件 **提示** 我们建议你试用 [AWS IoT Greengrass AI Agents Context Pack 来快速设置和试用 IoT Greengras](https://github.com/aws-greengrass/greengrass-agent-context-pack) s。 AWS 代理上下文包将使人工智能代理能够设置 Greengrass Nucleus 和 Nucleus Lite，部署组件并对常见问题进行故障排除。 按照本节中的步骤将 Raspberry Pi 设置为可用于本地开发的 AWS IoT Greengrass 核心设备。在本节中，您将下载并运行安装程序，该安装程序可执行以下操作来为您的设备配置 AWS IoT Greengrass 核心软件： + 安装 Greengrass Nucleus 组件。nucleus 是必备组件，是在设备上运行 AWS IoT Greengrass Core 软件的最低要求。有关更多信息，请参阅 [Greengrass Nucleus 组件](greengrass-nucleus-component.md)。 + 将您的设备注册为 AWS IoT 物体，并下载允许您的设备连接的数字证书 AWS。有关更多信息，请参阅 [设备身份验证和授权 AWS IoT Greengrass](device-auth.md)。 + 将设备 AWS IoT 的事物添加到事物组，即一组或一组 AWS IoT 事物。事物组允许您管理 Greengrass 核心设备实例集。将软件组件部署到设备时，可以选择部署到单个设备或设备组。有关更多信息，请参阅《AWS IoT Core 开发人员指南》**中的 [使用 AWS IoT管理设备](https://docs.aws.amazon.com/iot/latest/developerguide/iot-thing-management.html)。 + 创建 IAM 角色，允许您的 Greengrass 核心设备与 AWS 服务进行交互。默认情况下，此角色允许您的设备与 Amazon Logs 进行交互 AWS IoT 并向 Amazon Logs 发送 CloudWatch 日志。有关更多信息，请参阅 [授权核心设备与 AWS 服务交互](device-service-role.md)。 + 安装 AWS IoT Greengrass 命令行界面 (`greengrass-cli`)，您可以使用它来测试在核心设备上开发的自定义组件。有关更多信息，请参阅 [Greengrass 命令行界面](gg-cli.md)。 # 安装 AWS IoT Greengrass Core 软件（控制台） 1. 登录 [AWS IoT Greengrass 控制台](https://console.aws.amazon.com/greengrass)。 1. 在 **Greengrass 入门**下，选择**设置核心设备**。 1. 在**第 1 步：注册 Greengrass 核心设备**下，为**核心设备名称**输入 Greengrass 核心设备的 AWS IoT 事物的名称。如果该事物不存在，安装程序会进行创建。 1. 在**第 2 步：添加到事物组以应用持续部署**下，对于**事物组**，选择要向其添加核心设备的 AWS IoT 事物组。 + 如果选择**输入新的组名**，则在**事物组名称**中，输入要创建的新组的名称。安装程序会为您创建新组。 + 如果您选择**选择现有群组**，则在**事物组名称**中，选择要使用的现有组。 + 如果您选择**无组**，则安装程序不会将核心设备添加到事物组。 1. 在**第 3 步：安装 Greengrass Core 软件**下，完成以下步骤。 ------ #### [ Nucleus classic ] 1. 选择 **Nucleus Classic** 作为核心设备的软件运行时。 1. 选择您的核心设备的操作系统：**Linux** 或 **Windows**。 1. 向设备提供 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 Core 软件提供凭证。 ------ #### [ 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 Core 软件提供凭证。 ------ #### [ 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 Core 软件提供凭证。 ------ #### [ 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)**。 1. 在**运行安装程序**下，完成以下步骤。 1. 在**下载安装程序**下，选择**复制**，然后在核心设备上运行复制的命令。此命令下载最新版本的 AWS IoT Greengrass Core 软件并将其解压缩到您的设备上。 1. 在**运行安装程序**下，选择**复制**，然后在核心设备上运行复制的命令。此命令使用您之前指定的 AWS IoT 事物和事物组名称来运行 AWS IoT Greengrass Core 软件安装程序并为您的核心设备设置 AWS 资源。 此命令还执行以下操作： + 将 AWS IoT Greengrass Core 软件设置为启动时运行的系统服务。在 Linux 设备上，这需要 [Systemd](https://en.wikipedia.org/wiki/Systemd) 初始化系统。 **重要** 在 Windows 核心设备上，必须将 AWS IoT Greengrass Core 软件设置为系统服务。 + 部署 [AWS IoT GreengrassCLI 组件](gg-cli.md)，这是一种命令行工具，支持您在核心设备上开发自定义 Greengrass 组件。 + 指定使用 `ggc_user` 系统用户在核心设备上运行软件组件。在 Linux 设备上，此命令还指定使用 `ggc_group` 系统组，安装程序会为您创建系统用户和组。 运行该命令后，您将看到以下信息，表明安装程序已成功完成。 ``` Successfully configured Nucleus with provisioned resource details! Configured Nucleus to deploy aws.greengrass.Cli component Successfully set up Nucleus as a system service ``` **注意** 如果您有 Linux 设备但没有 [systemd](https://en.wikipedia.org/wiki/Systemd)，则安装程序不会将该软件设置为系统服务，您也不会看到将 Nucleus 设置为系统服务的成功消息。 ------ #### [ Nucleus lite ] 1. 选择 **Nucleus Lite** 作为核心设备的软件运行时。 1. 选择设备设置方法，将设备配置为 Greengrass 核心设备。 **选项 1：设置一个支持软件包下载（大约 1MB）的设备** 1. 创建 AWS IoT 事物以及 Greengrass 角色。 1. 下载其中包含设备需要连接至 AWS IoT 的 AWS IoT 资源的 zip 文件： + 使用 AWS IoT 的证书颁发机构生成的证书和私钥。 + 用于为设备启动 Greengrass 安装的架构文件。 1. 下载将在 Raspberry Pi 中安装最新 Greengrass Nucleus lite 运行时的软件包。 1. 将设备配置为 AWS IoT Greengrass 核心设备并将其连接至 AWS IoT： 1. a. 使用 U 盘、SCP/FTP 或 SD 卡，将 Greengrass 软件包和连接工具包传输至设备上。 1. b. 将 greengrass-package.zip 文件解压缩至设备上的 /greenGrassInstaller 目录中。 1. c. 将连接工具包 zip 文件解压缩至设备上的 /directory 中。 1. d. 运行设备上提供的命令来安装 AWS IoT Greengrass 1. 然后，选择**查看核心设备**。 **选项 2：设置一台设备，预先配置好整个磁盘的示例映像下载（约100MB）** 1. 创建 AWS IoT 事物以及 Greengrass 角色。 1. 下载其中包含设备需要连接至 AWS IoT 的 AWS IoT 资源的 zip 文件： + 使用 AWS IoT 的证书颁发机构生成的证书和私钥。 + 用于为设备启动 Greengrass 安装的架构文件。 1. 下载预配置的包含 Greengrass 和操作系统的整个磁盘示例映像。 1. 要传输连接工具包并将映像刷入设备，请按照随映像一起下载的自述文件进行操作。 1. 要开始安装 Greengrass，请打开设备并使用刷入的映像启动设备 1. 然后，选择**查看核心设备**。 **选项 3：使用您自己的自定义版本设置设备** 1. 创建 AWS IoT 事物以及 Greengrass 角色。 1. 下载其中包含设备需要连接至 AWS IoT 的 AWS IoT 资源的 zip 文件： + 使用 AWS IoT 的证书颁发机构生成的证书和私钥。 + 用于为设备启动 Greengrass 安装的架构文件。 1. 要使用源代码版 Yocto 自定义和构建自己的镜像，然后使用连接工具包安装 Nucleus Lite，请按照 GitHub 上的说明进行操作。 1. 然后，选择**查看核心设备**。 ------ # 安装 AWS IoT Greengrass Core 软件（CLI） **注意** 这些步骤不适用于 Nucleus Lite。 **安装和配置 AWS IoT Greengrass Core 软件** 1. 在 Greengrass 核心设备上，运行以下命令切换到主目录。 ------ #### [ Linux or Unix ] ``` cd ~ ``` ------ #### [ Windows Command Prompt (CMD) ] ``` cd %USERPROFILE% ``` ------ #### [ PowerShell ] ``` cd ~ ``` ------ 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. 将 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 软件安装程序。此命令执行以下操作： + 创建核心设备运行所需的 AWS 资源。 + 将 AWS IoT Greengrass Core 软件设置为启动时运行的系统服务。在 Linux 设备上，这需要 [Systemd](https://en.wikipedia.org/wiki/Systemd) 初始化系统。 **重要** 在 Windows 核心设备上，必须将 AWS IoT Greengrass Core 软件设置为系统服务。 + 部署 [AWS IoT GreengrassCLI 组件](gg-cli.md)，这是一种命令行工具，支持您在核心设备上开发自定义 Greengrass 组件。 + 指定使用 `ggc_user` 系统用户在核心设备上运行软件组件。在 Linux 设备上，此命令还指定使用 `ggc_group` 系统组，安装程序会为您创建系统用户和组。 如下所示替换命令中的参数值。 1. `/greengrass/v2` 或 *C:\$1greengrass\$1v2*：用于安装 AWS IoT Greengrass Core 软件的根文件夹的路径。 1. *GreengrassInstaller*。您解压缩 AWS IoT Greengrass Core 软件安装程序所用目标文件夹的路径。 1. *region*。用于查找或创建资源的 AWS 区域。 1. *MyGreengrassCore*。您的 Greengrass 核心设备的 AWS IoT 事物的名称。如果该事物不存在，安装程序会进行创建。安装程序会下载证书以作为 AWS IoT 事物进行身份验证。有关更多信息，请参阅 [设备身份验证和授权 AWS IoT Greengrass](device-auth.md)。 **注意** 事物名称不得包含英文冒号 (`:`) 字符。 1. *MyGreengrassCoreGroup*。您的 Greengrass 核心设备的 AWS IoT 事物组的名称。如果该事物组不存在，安装程序会进行创建并向其中添加事物。如果事物组存在且有活动的部署，则核心设备将下载并运行部署指定的软件。 **注意** 事物组名称不得包含英文冒号 (`:`) 字符。 1. *GreengrassV2IoTThingPolicy*。允许 Greengrass 核心设备与 AWS IoT 和 AWS IoT Greengrass 通信的 AWS IoT 策略的名称。如果该 AWS IoT 策略不存在，则安装程序会使用此名称创建宽容的 AWS IoT 策略。您可以根据自己的使用案例限制此策略的权限。有关更多信息，请参阅 [AWS IoT Greengrass V2 核心设备的最低 AWS IoT 政策](device-auth.md#greengrass-core-minimal-iot-policy)。 1. *GreengrassV2TokenExchangeRole*。允许 Greengrass 核心设备获取临时 AWS 凭证的 IAM 角色的名称。如果该角色不存在，则安装程序会创建该角色并附加名为 `GreengrassV2TokenExchangeRoleAccess` 的策略。有关更多信息，请参阅 [授权核心设备与 AWS 服务交互](device-service-role.md)。 1. *GreengrassCoreTokenExchangeRoleAlias*。允许 Greengrass 核心设备稍后获取临时凭证的 IAM 角色的别名。如果该角色别名不存在，则安装程序会自行创建，并将其指向您指定的 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 \ --deploy-dev-tools 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 ^ --deploy-dev-tools 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 ` --deploy-dev-tools true ``` ------ **注意** 如果您在内存有限的设备上运行 AWS IoT Greengrass，则可以控制 AWS IoT Greengrass Core 软件使用的内存量。要控制内存分配，您可以在 Nucleus 组件的 `jvmOptions` 配置参数中设置 JVM 堆大小选项。有关更多信息，请参阅 [使用 JVM 选项控制内存分配](configure-greengrass-core-v2.md#jvm-tuning)。 运行该命令后，您将看到以下信息，表明安装程序已成功完成。 ``` Successfully configured Nucleus with provisioned resource details! Configured Nucleus to deploy aws.greengrass.Cli component Successfully set up Nucleus as a system service ``` **注意** 如果您有 Linux 设备但没有 [systemd](https://en.wikipedia.org/wiki/Systemd)，则安装程序不会将该软件设置为系统服务，您也不会看到将 Nucleus 设置为系统服务的成功消息。 # （可选）运行 Greengrass 软件（Linux） **注意** 这些步骤不适用于 Nucleus Lite。 如果您将软件作为系统服务安装，则安装程序会为您运行软件。否则，您必须运行软件。要查看安装程序是否将软件设置为系统服务，请在安装程序输出中查找以下行。 ``` Successfully set up Nucleus as a system service ``` 如果看不到此消息，请执行以下操作来运行软件： 1. 运行以下命令，来运行软件。 ``` sudo /greengrass/v2/alts/current/distro/bin/loader ``` 如果软件成功启动，则会打印以下消息。 ``` Launched Nucleus successfully. ``` 1. 必须让当前的命令外壳保持打开状态才能保持 AWS IoT Greengrass Core 软件的运行。如果您使用 SSH 连接到核心设备，请在开发计算机上运行以下命令，来打开第二个 SSH 会话，您可以使用该会话在核心设备上运行其它命令。*username*替换为要登录的用户名，*pi-ip-address*替换为设备的 IP 地址。 ``` ssh username@pi-ip-address ``` 有关如何与 Greengrass 系统服务进行交互的更多信息，请参阅[将 Greengrass Nucleus 配置为系统服务](configure-greengrass-core-v2.md#configure-system-service)。 # 验证设备上是否已安装 Greengrass CLI **注意** 这些步骤不适用于 Nucleus Lite。 部署 Greengrass CLI 最多需要一分钟。运行以下命令以检查部署的状态。*MyGreengrassCore*替换为核心设备的名称。 ``` aws greengrassv2 list-effective-deployments --core-device-thing-name MyGreengrassCore ``` `coreDeviceExecutionStatus` 表示核心设备的部署状态。当状态为 `SUCCEEDED` 时，运行以下命令以验证 Greengrass CLI 是否已安装并运行。将 `/greengrass/v2` 替换为根文件夹路径。 ------ #### [ Linux or Unix ] ``` /greengrass/v2/bin/greengrass-cli help ``` ------ #### [ Windows Command Prompt (CMD) ] ``` C:\greengrass\v2\bin\greengrass-cli help ``` ------ #### [ PowerShell ] ``` C:\greengrass\v2\bin\greengrass-cli help ``` ------ 该命令会输出 Greengrass CLI 的帮助信息。如果未找到 `greengrass-cli`，则部署可能无法安装 Greengrass CLI。有关更多信息，请参阅 [故障排除 AWS IoT Greengrass V2](troubleshooting.md)。 您也可以运行以下命令将 AWS IoT Greengrass CLI 手动部署到您的设备。 + *region*替换为您使用 AWS 区域 的。请务必使用与 AWS 区域 在设备 AWS CLI 上配置时使用的相同。 + *account-id*用您的 AWS 账户 身份证替换。 + *MyGreengrassCore*替换为核心设备的名称。 ------ #### [ Linux, macOS, or Unix ] ``` aws greengrassv2 create-deployment \ --target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" \ --components '{ "aws.greengrass.Cli": { "componentVersion": "2.16.1" } }' ``` ------ #### [ Windows Command Prompt (CMD) ] ``` aws greengrassv2 create-deployment ^ --target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" ^ --components "{\"aws.greengrass.Cli\":{\"componentVersion\":\"2.16.1\"}}" ``` ------ #### [ PowerShell ] ``` aws greengrassv2 create-deployment ` --target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" ` --components '{\"aws.greengrass.Cli\":{\"componentVersion\":\"2.16.1\"}}' ``` ------ **提示** 您可以在 `PATH` 环境变量中添加 `/greengrass/v2/bin`（Linux）或 `C:\greengrass\v2\bin`（Windows），以便在没有绝对路径的情况下运行 `greengrass-cli`。 C AWS IoT Greengrass ore 软件和本地开发工具可在您的设备上运行。接下来，你可以在你的设备上开发 Hello World AWS IoT Greengrass 组件。 # 第 4 步：在设备上开发和测试组件 组件是在 AWS IoT Greengrass 核心设备上运行的软件模块。您可以利用这些组件创建和管理复杂的应用程序，并将其作为离散构建基块在不同的 Greengrass 核心设备之间重复使用。每个组件都包含*配方*和*构件*。 + **配方** 每个组件都包含一个用于定义其元数据的配方文件。此配方还指定了组件的配置参数、组件依赖关系、生命周期和平台兼容性。组件生命周期指定了安装、运行和关闭组件时要运行的命令。有关更多信息，请参阅 [AWS IoT Greengrass 组件配方参考](component-recipe-reference.md)。 您可以用 [JSON](https://en.wikipedia.org/wiki/JSON) 或 [YAML](https://en.wikipedia.org/wiki/YAML) 格式定义配方。 + **构件** 组件可以有任意数量的构件，即组件二进制文件。构件可以包括脚本、编译的代码、静态资源以及组件使用的任何其他文件。组件还可以使用组件依赖关系中的构件。 借助 AWS IoT Greengrass，您可以使用 Greengrass CLI 在 Greengrass 核心设备上本地开发和测试组件，而无需与云端交互。 AWS 完成本地组件后，您可以使用组件配方和工件在 AWS 云端的 AWS IoT Greengrass 服务中创建该组件，然后将其部署到所有 Greengrass 核心设备上。有关组件的更多信息，请参阅[开发 AWS IoT Greengrass 组件](develop-greengrass-components.md)。 本节中，您将学习如何在核心设备本地创建和运行 Hello World 基本组件。 **在设备上开发 Hello World 组件** 1. 为您的组件创建一个文件夹，其中包含用于存放配方和构件的子文件夹。在 Greengrass 核心设备上运行以下命令来创建这些文件夹并更改为组件文件夹。将*\$1/greengrassv2*或*%USERPROFILE%\$1greengrassv2*替换为用于本地开发的文件夹的路径。 ------ #### [ Linux or Unix ] ``` mkdir -p ~/greengrassv2/{recipes,artifacts} cd ~/greengrassv2 ``` ------ #### [ Windows Command Prompt (CMD) ] ``` mkdir %USERPROFILE%\greengrassv2\\recipes, %USERPROFILE%\greengrassv2\\artifacts cd %USERPROFILE%\greengrassv2 ``` ------ #### [ PowerShell ] ``` mkdir ~/greengrassv2/recipes, ~/greengrassv2/artifacts cd ~/greengrassv2 ``` ------ 1. 使用文本编辑器创建配方文件，在该配方文件中定义组件的元数据、参数、依赖关系、生命周期和平台功能。在配方文件名中包含组件版本，以便您可以识别哪个配方对应哪个组件版本。您可以为配方选择 YAML 或 JSON 格式。 例如，在基于 Linux 的系统上，您可以运行以下命令来使用 GNU nano 创建该文件。 ------ #### [ JSON ] ``` nano recipes/com.example.HelloWorld-1.0.0.json ``` ------ #### [ YAML ] ``` nano recipes/com.example.HelloWorld-1.0.0.yaml ``` ------ **注意** AWS IoT Greengrass 使用组件的语义版本。语义版本遵循 *major*.*minor*.*patch* 编号系统。例如，版本 `1.0.0` 表示组件的第一个主要版本。有关更多信息，请参阅[语义版本规范](https://semver.org/)。 1. 将以下配方粘贴到文件中。 ------ #### [ JSON ] ``` { "RecipeFormatVersion": "2020-01-25", "ComponentName": "com.example.HelloWorld", "ComponentVersion": "1.0.0", "ComponentDescription": "My first AWS IoT Greengrass component.", "ComponentPublisher": "Amazon", "ComponentConfiguration": { "DefaultConfiguration": { "Message": "world" } }, "Manifests": [ { "Platform": { "os": "linux" }, "Lifecycle": { "run": "python3 -u {artifacts:path}/hello_world.py {configuration:/Message}" } }, { "Platform": { "os": "windows" }, "Lifecycle": { "run": "py -3 -u {artifacts:path}/hello_world.py {configuration:/Message}" } } ] } ``` ------ #### [ YAML ] ``` --- RecipeFormatVersion: '2020-01-25' ComponentName: com.example.HelloWorld ComponentVersion: '1.0.0' ComponentDescription: My first AWS IoT Greengrass component. ComponentPublisher: Amazon ComponentConfiguration: DefaultConfiguration: Message: world Manifests: - Platform: os: linux Lifecycle: run: | python3 -u {artifacts:path}/hello_world.py "{configuration:/Message}" - Platform: os: windows Lifecycle: run: | py -3 -u {artifacts:path}/hello_world.py "{configuration:/Message}" ``` ------ 此配方的 `ComponentConfiguration` 部分定义了一个参数 `Message`，默认值为 `world`。`Manifests` 部分定义了一个*清单*，它是一组适用于平台的生命周期指令和构件。例如，您可以定义多个清单，为不同平台指定不同的安装说明。在清单中，`Lifecycle` 部分指示 Greengrass 核心设备以 `Message` 参数值为参数运行 Hello World 脚本。 1. 运行以下命令，为组件构件创建文件夹。 ------ #### [ Linux or Unix ] ``` mkdir -p artifacts/com.example.HelloWorld/1.0.0 ``` ------ #### [ Windows Command Prompt (CMD) ] ``` mkdir artifacts\com.example.HelloWorld\1.0.0 ``` ------ #### [ PowerShell ] ``` mkdir artifacts\com.example.HelloWorld\1.0.0 ``` ------ **重要** 必须为构件文件夹路径使用以下格式。其中包括您在配方中指定的组件名称和版本。 ``` artifacts/componentName/componentVersion/ ``` 1. 使用文本编辑器为 Hello World 组件创建 Python 脚本构件文件。 例如，在基于 Linux 的系统上，您可以运行以下命令来使用 GNU nano 创建该文件。 ``` nano artifacts/com.example.HelloWorld/1.0.0/hello_world.py ``` 将以下 Python 脚本复制并粘贴到文件中。 ``` import sys message = "Hello, %s!" % sys.argv[1] # Print the message to stdout, which Greengrass saves in a log file. print(message) ``` 1. 使用本地 AWS IoT Greengrass CLI 来管理 Greengrass 核心设备上的组件。 运行以下命令将组件部署到内 AWS IoT Greengrass 核。*C:\$1greengrass\$1v2*用你的 AWS IoT Greengrass V2 根文件夹替`/greengrass/v2`换*\$1/greengrassv2*或，*%USERPROFILE%\$1greengrassv2*用你的组件开发文件夹替换或。 ------ #### [ Linux or Unix ] ``` sudo /greengrass/v2/bin/greengrass-cli deployment create \ --recipeDir ~/greengrassv2/recipes \ --artifactDir ~/greengrassv2/artifacts \ --merge "com.example.HelloWorld=1.0.0" ``` ------ #### [ Windows Command Prompt (CMD) ] ``` C:\greengrass\v2\bin\greengrass-cli deployment create ^ --recipeDir %USERPROFILE%\greengrassv2\recipes ^ --artifactDir %USERPROFILE%\greengrassv2\artifacts ^ --merge "com.example.HelloWorld=1.0.0" ``` ------ #### [ PowerShell ] ``` C:\greengrass\v2\bin\greengrass-cli deployment create ` --recipeDir ~/greengrassv2/recipes ` --artifactDir ~/greengrassv2/artifacts ` --merge "com.example.HelloWorld=1.0.0" ``` ------ 此命令添加了使用 `recipes` 中配方和 `artifacts` 中 Python 脚本的组件。`--merge` 选项添加或更新了您指定的组件和版本。 1. AWS IoT Greengrass Core 软件将组件进程中的 stdout 保存到文件夹中的日志文件中。`logs`运行以下命令，以验证 Hello World 组件是否运行并打印消息。 ------ #### [ Linux or Unix ] ``` sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log ``` ------ #### [ Windows Command Prompt (CMD) ] ``` type C:\greengrass\v2\logs\com.example.HelloWorld.log ``` `type` 命令将文件内容写入终端。多次运行此命令，以观察文件中的更改。 ------ #### [ PowerShell ] ``` gc C:\greengrass\v2\logs\com.example.HelloWorld.log -Tail 10 -Wait ``` ------ 您应该会看到类似于以下示例的消息。 ``` Hello, world! ``` **注意** 如果文件不存在，可能是本地部署尚未完成。如果文件在 15 秒内不存在，则部署可能失败。例如，如果您的配方无效，则可能会发生这种情况。运行以下命令查看 AWS IoT Greengrass 核心日志文件。此文件包含来自 Greengrass 核心设备的部署服务的日志。 ``` sudo tail -f /greengrass/v2/logs/greengrass.log ``` ``` type C:\greengrass\v2\logs\greengrass.log ``` `type` 命令将文件内容写入终端。多次运行此命令，以观察文件中的更改。 ``` gc C:\greengrass\v2\logs\greengrass.log -Tail 10 -Wait ``` 1. 修改本地组件，以迭代和测试您的代码。`hello_world.py`在文本编辑器中打开，然后在第 4 行添加以下代码以编辑 AWS IoT Greengrass 核心记录的消息。 ``` message += " Greetings from your first Greengrass component." ``` `hello_world.py` 脚本现在应包含以下内容。 ``` import sys message = "Hello, %s!" % sys.argv[1] message += " Greetings from your first Greengrass component." # Print the message to stdout, which Greengrass saves in a log file. print(message) ``` 1. 运行以下命令，根据您的更改更新组件。 ------ #### [ Linux or Unix ] ``` sudo /greengrass/v2/bin/greengrass-cli deployment create \ --recipeDir ~/greengrassv2/recipes \ --artifactDir ~/greengrassv2/artifacts \ --merge "com.example.HelloWorld=1.0.0" ``` ------ #### [ Windows Command Prompt (CMD) ] ``` C:\greengrass\v2\bin\greengrass-cli deployment create ^ --recipeDir %USERPROFILE%\greengrassv2\recipes ^ --artifactDir %USERPROFILE%\greengrassv2\artifacts ^ --merge "com.example.HelloWorld=1.0.0" ``` ------ #### [ PowerShell ] ``` C:\greengrass\v2\bin\greengrass-cli deployment create ` --recipeDir ~/greengrassv2/recipes ` --artifactDir ~/greengrassv2/artifacts ` --merge "com.example.HelloWorld=1.0.0" ``` ------ 此命令使用最新的 Hello World 构件更新 `com.example.HelloWorld` 组件。 1. 要重新启动组件，请运行以下命令。重新启动组件时，核心设备将使用最新的更改。 ------ #### [ Linux or Unix ] ``` sudo /greengrass/v2/bin/greengrass-cli component restart \ --names "com.example.HelloWorld" ``` ------ #### [ Windows Command Prompt (CMD) ] ``` C:\greengrass\v2\bin\greengrass-cli component restart ^ --names "com.example.HelloWorld" ``` ------ #### [ PowerShell ] ``` C:\greengrass\v2\bin\greengrass-cli component restart ` --names "com.example.HelloWorld" ``` ------ 1. 再次检查日志，验证 Hello World 组件是否打印了新消息。 ------ #### [ Linux or Unix ] ``` sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log ``` ------ #### [ Windows Command Prompt (CMD) ] ``` type C:\greengrass\v2\logs\com.example.HelloWorld.log ``` `type` 命令将文件内容写入终端。多次运行此命令，以观察文件中的更改。 ------ #### [ PowerShell ] ``` gc C:\greengrass\v2\logs\com.example.HelloWorld.log -Tail 10 -Wait ``` ------ 您应该会看到类似于以下示例的消息。 ``` Hello, world! Greetings from your first Greengrass component. ``` 1. 您可以更新组件的配置参数来测试不同的配置。部署组件时，可以指定*配置更新*，该更新定义了如何在核心设备上修改组件的配置。您可以指定要重置为默认值的配置值以及要合并到核心设备上的新配置值。有关更多信息，请参阅 [更新组件配置](update-component-configurations.md)。 执行以下操作： 1. 使用文本编辑器创建名为 `hello-world-config-update.json` 的文件，其中包含配置更新。 例如，在基于 Linux 的系统上，您可以运行以下命令来使用 GNU nano 创建该文件。 ``` nano hello-world-config-update.json ``` 1. 将以下 JSON 对象复制并粘贴到文件中。此 JSON 对象定义了配置更新，该更新将值 `friend` 合并到 `Message` 参数以更新其值。此配置更新未指定任何要重置的值。您无需重置 `Message` 参数，因为合并更新会替换现有值。 ``` { "com.example.HelloWorld": { "MERGE": { "Message": "friend" } } } ``` 1. 运行以下命令，将配置更新部署到 Hello World 组件。 ------ #### [ Linux or Unix ] ``` sudo /greengrass/v2/bin/greengrass-cli deployment create \ --merge "com.example.HelloWorld=1.0.0" \ --update-config hello-world-config-update.json ``` ------ #### [ Windows Command Prompt (CMD) ] ``` C:\greengrass\v2\bin\greengrass-cli deployment create ^ --merge "com.example.HelloWorld=1.0.0" ^ --update-config hello-world-config-update.json ``` ------ #### [ PowerShell ] ``` C:\greengrass\v2\bin\greengrass-cli deployment create ` --merge "com.example.HelloWorld=1.0.0" ` --update-config hello-world-config-update.json ``` ------ 1. 再次检查日志，验证 Hello World 组件是否输出了新消息。 ------ #### [ Linux or Unix ] ``` sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log ``` ------ #### [ Windows Command Prompt (CMD) ] ``` type C:\greengrass\v2\logs\com.example.HelloWorld.log ``` `type` 命令将文件内容写入终端。多次运行此命令，以观察文件中的更改。 ------ #### [ PowerShell ] ``` gc C:\greengrass\v2\logs\com.example.HelloWorld.log -Tail 10 -Wait ``` ------ 您应该会看到类似于以下示例的消息。 ``` Hello, friend! Greetings from your first Greengrass component. ``` 1. 测试完组件后，将其从核心设备中移除。运行如下命令。 ------ #### [ Linux or Unix ] ``` sudo /greengrass/v2/bin/greengrass-cli deployment create --remove="com.example.HelloWorld" ``` ------ #### [ Windows Command Prompt (CMD) ] ``` C:\greengrass\v2\bin\greengrass-cli deployment create --remove="com.example.HelloWorld" ``` ------ #### [ PowerShell ] ``` C:\greengrass\v2\bin\greengrass-cli deployment create --remove="com.example.HelloWorld" ``` ------ **重要** 将组件上传到 AWS IoT Greengrass后，需要执行此步骤才能将其部署回核心设备。否则，部署会因版本兼容性错误而失败，因为本地部署指定了不同的组件版本。 运行以下命令并确认 `com.example.HelloWorld` 组件未出现在设备上的组件列表中。 ------ #### [ Linux or Unix ] ``` sudo /greengrass/v2/bin/greengrass-cli component list ``` ------ #### [ Windows Command Prompt (CMD) ] ``` C:\greengrass\v2\bin\greengrass-cli component list ``` ------ #### [ PowerShell ] ``` C:\greengrass\v2\bin\greengrass-cli component list ``` ------ 你的 Hello World 组件已完成，你现在可以将其上传到 AWS IoT Greengrass 云服务了。然后，可以将组件部署到 Greengrass 核心设备。 # 步骤 5：在 AWS IoT Greengrass 服务中创建您的组件 在核心设备上开发完组件后，您可以将其上传至 AWS 云中的 AWS IoT Greengrass 服务。您也可以直接在 [AWS IoT Greengrass 控制台](https://console.aws.amazon.com/greengrass)中创建组件。 AWS IoT Greengrass 提供托管组件的组件管理服务，以便您可以将它们部署到单个设备或设备实例集中。要将组件上传到 AWS IoT Greengrass 服务，请完成以下步骤： + 将组件构件上传至 S3 存储桶。 + 将每个构件的 Amazon Simple Storage Service（Amazon S3）URI 添加到组件配方中。 + AWS IoT Greengrass 从组件配方中创建组件。 在本节中，您将在 Greengrass 核心设备上完成这些步骤，将 Hello World 组件上传到该服务。 AWS IoT Greengrass ## 在 AWS IoT Greengrass （控制台）中创建您的组件 1. 在您的 AWS 账户中使用一个 S3 存储桶来托管 AWS IoT Greengrass 组件项目。当您将组件部署到核心设备时，设备会从存储桶中下载该组件的构件。 您可以使用现有的 S3 存储桶，也可以创建新存储桶。 1. 在 [Amazon S3 控制台](https://console.aws.amazon.com/s3)的**存储桶**下，选择**创建存储桶**。 1. 对于**配置**，请输入唯一的存储桶名称。例如，您可以使用 **greengrass-component-artifacts-*region*-*123456789012***。*123456789012*替换为您的 AWS 账户 ID *region* 和您在本教程中 AWS 区域 使用的账户 ID。 1. 对于**AWS 区域**，请选择您用于本教程的 AWS 区域。 1. 选择 **创建存储桶 **。 1. 在**存储桶**下，选择您创建的存储桶，然后将 `hello_world.py` 脚本上传至存储桶中的 `artifacts/com.example.HelloWorld/1.0.0` 文件夹。有关将对象上传至 S3 存储桶的更多信息，请参阅《Amazon Simple Storage Service 用户指南》**中的[上传对象](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html)。 1. 复制 S3 存储桶中 `hello_world.py` 对象的 S3 URI。此 URI 应该类似于以下示例。将 amzn-s3-demo-bucket 替换为 S3 存储桶的名称。 ``` s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py ``` 1. 允许核心设备访问 S3 存储桶中的组件构件。 每台核心设备都有一个[核心设备 IAM 角色](device-service-role.md)，允许其与云进行交互 AWS IoT 并将日志发送到 AWS 云端。默认情况下，此设备角色不允许访问 S3 存储桶，因此您必须创建并附加一个允许核心设备从 S3 存储桶检索组件构件的策略。 如果设备的角色已允许访问 S3 存储桶，则可跳过此步骤。否则，请创建允许访问的 IAM 策略并将其附加到该角色，如下所示： 1. 在 [IAM 控制台](https://console.aws.amazon.com/iam)的导航菜单中，选择**策略**，然后选择**创建策略**。 1. 在 **JSON** 选项卡中，将占位符内容替换为以下策略。将 amzn-s3-demo-bucket 替换为包含供核心设备下载的组件构件的 S3 存储桶名称。 ``` { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "s3:GetObject" ], "Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*" } ] } ``` 1. 选择**下一步**。 1. 在**策略详细信息部分**，对于**名称**，请输入 **MyGreengrassV2ComponentArtifactPolicy**。 1. 选择**创建策略**。 1. 在 [IAM 控制台](https://console.aws.amazon.com/iam)导航菜单中，选择**角色**，然后选择核心设备的角色名称。您在安装 C AWS IoT Greengrass ore 软件时指定了此角色名称。如果您未指定名称，则默认使用 `GreengrassV2TokenExchangeRole`。 1. 在**权限**下，选择**添加权限**，然后选择**附加策略**。 1. 在**添加权限**页面，选中与您创建的策略 `MyGreengrassV2ComponentArtifactPolicy` 对应的复选框，然后选择**添加权限**。 1. 使用组件配方在 [AWS IoT Greengrass 控制台](https://console.aws.amazon.com/greengrass)中创建组件。 1. 在 [AWS IoT Greengrass 控制台](https://console.aws.amazon.com/greengrass)导航菜单中，选择**组件**，然后选择**创建组件**。 1. 在**组件信息**下，选择**以 JSON 格式输入配方**。该占位符配方应该类似于以下示例。 ``` { "RecipeFormatVersion": "2020-01-25", "ComponentName": "com.example.HelloWorld", "ComponentVersion": "1.0.0", "ComponentDescription": "My first AWS IoT Greengrass component.", "ComponentPublisher": "Amazon", "ComponentConfiguration": { "DefaultConfiguration": { "Message": "world" } }, "Manifests": [ { "Platform": { "os": "linux" }, "Lifecycle": { "Run": "python3 -u {artifacts:path}/hello_world.py \"{configuration:/Message}\"" }, "Artifacts": [ { "URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py" } ] }, { "Platform": { "os": "windows" }, "Lifecycle": { "Run": "py -3 -u {artifacts:path}/hello_world.py \"{configuration:/Message}\"" }, "Artifacts": [ { "URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py" } ] } ] } ``` 1. 将每个 `Artifacts` 部分中的占位符 URI 替换为 `hello_world.py` 对象的 S3 URI。 1. 选择**创建组件**。 1. 在 **com.example 上。 HelloWorld**组件页面上，验证组件的**状态**是否为**可部署**。 ## 在 AWS IoT Greengrass (AWS CLI) 中创建你的组件 **上传 Hello World 组件** 1. 使用您的中的 S3 存储桶 AWS 账户 来托管 AWS IoT Greengrass 组件项目。当您将组件部署到核心设备时，设备会从存储桶中下载该组件的构件。 您可以使用现有 S3 存储桶，也可以运行以下命令以创建存储桶。此命令使用您的 AWS 账户 ID 创建一个存储桶 AWS 区域 ，并形成一个唯一的存储桶名称。*123456789012*用你的 AWS 账户 ID 和*region*你在本教程 AWS 区域 中使用的 ID 替换。 ``` aws s3 mb s3://greengrass-component-artifacts-123456789012-region ``` 如果请求成功，命令将输出以下信息。 ``` make_bucket: greengrass-component-artifacts-123456789012-region ``` 1. 允许核心设备访问 S3 存储桶中的组件构件。 每台核心设备都有一个[核心设备 IAM 角色](device-service-role.md)，允许其与核心设备交互 AWS IoT 并向其发送日志 AWS 云。默认情况下，此设备角色不允许访问 S3 存储桶，因此您必须创建并附加一个允许核心设备从 S3 存储桶检索组件构件的策略。 如果核心设备的角色已允许访问 S3 存储桶，则可跳过此步骤。否则，请创建允许访问的 IAM 策略并将其附加到该角色，如下所示： 1. 创建一个名为 `component-artifact-policy.json` 的文件，并将以下 JSON 复制到该文件中。此策略允许访问 S3 存储桶中的所有文件。将 amzn-s3-demo-bucket 替换为 S3 存储桶的名称。 ``` { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "s3:GetObject" ], "Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*" } ] } ``` 1. 运行以下命令，从 `component-artifact-policy.json` 中的策略文档创建策略。 ------ #### [ Linux or Unix ] ``` aws iam create-policy \\ --policy-name MyGreengrassV2ComponentArtifactPolicy \\ --policy-document file://component-artifact-policy.json ``` ------ #### [ Windows Command Prompt (CMD) ] ``` aws iam create-policy ^ --policy-name MyGreengrassV2ComponentArtifactPolicy ^ --policy-document file://component-artifact-policy.json ``` ------ #### [ PowerShell ] ``` aws iam create-policy ` --policy-name MyGreengrassV2ComponentArtifactPolicy ` --policy-document file://component-artifact-policy.json ``` ------ 从输出中的策略元数据复制策略 Amazon 资源名称（ARN）。您将在下一步中使用此 ARN 来将此策略附加到核心设备角色。 1. 运行以下命令以将策略附加到核心设备角色。*GreengrassV2TokenExchangeRole*替换为核心设备的角色名称。您在安装 C AWS IoT Greengrass ore 软件时指定了此角色名称。将策略 ARN 替换为上一步中的 ARN。 ------ #### [ Linux or Unix ] ``` aws iam attach-role-policy \\ --role-name GreengrassV2TokenExchangeRole \\ --policy-arn arn:aws:iam::123456789012:policy/MyGreengrassV2ComponentArtifactPolicy ``` ------ #### [ Windows Command Prompt (CMD) ] ``` aws iam attach-role-policy ^ --role-name GreengrassV2TokenExchangeRole ^ --policy-arn arn:aws:iam::123456789012:policy/MyGreengrassV2ComponentArtifactPolicy ``` ------ #### [ PowerShell ] ``` aws iam attach-role-policy ` --role-name GreengrassV2TokenExchangeRole ` --policy-arn arn:aws:iam::123456789012:policy/MyGreengrassV2ComponentArtifactPolicy ``` ------ 如果命令没有输出，则表示成功。核心设备现在可以访问您上传至 S3 存储桶的构件。 1. 将 Hello World Python 脚本构件上传至 S3 存储桶。 运行以下命令将脚本上传到 AWS IoT Greengrass 核心上存在脚本的存储桶中的相同路径。将 amzn-s3-demo-bucket 替换为 S3 存储桶的名称。 ------ #### [ Linux or Unix ] ``` aws s3 cp \ artifacts/com.example.HelloWorld/1.0.0/hello_world.py \ s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py ``` ------ #### [ Windows Command Prompt (CMD) ] ``` aws s3 cp ^ artifacts/com.example.HelloWorld/1.0.0/hello_world.py ^ s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py ``` ------ #### [ PowerShell ] ``` aws s3 cp ` artifacts/com.example.HelloWorld/1.0.0/hello_world.py ` s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py ``` ------ 如果请求成功，该命令将输出以 `upload:` 开头的行。 1. 将构件的 Amazon S3 URI 添加到组件配方中。 Amazon S3 URI 由存储桶名称和存储桶中构件对象的路径组成。您脚本构件的 Amazon S3 URI 就是您在上一步中上传构件的 URI。此 URI 应该类似于以下示例。将 amzn-s3-demo-bucket 替换为 S3 存储桶的名称。 ``` s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py ``` 要将构件添加到配方中，请添加一个包含 Amazon S3 URI 结构的 `Artifacts` 列表。 ------ #### [ JSON ] ``` "Artifacts": [ { "URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py" } ] ``` 在文本编辑器中打开配方文件。 例如，在基于 Linux 的系统上，您可以运行以下命令来使用 GNU nano 创建该文件。 ``` nano recipes/com.example.HelloWorld-1.0.0.json ``` 将构件添加到配方中。您的配方文件应类似于以下示例。 ``` { "RecipeFormatVersion": "2020-01-25", "ComponentName": "com.example.HelloWorld", "ComponentVersion": "1.0.0", "ComponentDescription": "My first AWS IoT Greengrass component.", "ComponentPublisher": "Amazon", "ComponentConfiguration": { "DefaultConfiguration": { "Message": "world" } }, "Manifests": [ { "Platform": { "os": "linux" }, "Lifecycle": { "Run": "python3 -u {artifacts:path}/hello_world.py \"{configuration:/Message}\"" }, "Artifacts": [ { "URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py" } ] }, { "Platform": { "os": "windows" }, "Lifecycle": { "Run": "py -3 -u {artifacts:path}/hello_world.py \"{configuration:/Message}\"" }, "Artifacts": [ { "URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py" } ] } ] } ``` ------ #### [ YAML ] ``` Artifacts: - URI: s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py ``` 在文本编辑器中打开配方文件。 例如，在基于 Linux 的系统上，您可以运行以下命令来使用 GNU nano 创建该文件。 ``` nano recipes/com.example.HelloWorld-1.0.0.yaml ``` 将构件添加到配方中。您的配方文件应类似于以下示例。 ``` --- RecipeFormatVersion: '2020-01-25' ComponentName: com.example.HelloWorld ComponentVersion: '1.0.0' ComponentDescription: My first AWS IoT Greengrass component. ComponentPublisher: Amazon ComponentConfiguration: DefaultConfiguration: Message: world Manifests: - Platform: os: linux Lifecycle: Run: | python3 -u {artifacts:path}/hello_world.py "{configuration:/Message}" Artifacts: - URI: s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py - Platform: os: windows Lifecycle: Run: | py -3 -u {artifacts:path}/hello_world.py "{configuration:/Message}" Artifacts: - URI: s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py ``` ------ 1. AWS IoT Greengrass 从配方中创建组件资源。运行以下命令以根据以二进制文件形式提供的配方创建组件。 ------ #### [ JSON ] ``` aws greengrassv2 create-component-version --inline-recipe fileb://recipes/com.example.HelloWorld-1.0.0.json ``` ------ #### [ YAML ] ``` aws greengrassv2 create-component-version --inline-recipe fileb://recipes/com.example.HelloWorld-1.0.0.yaml ``` ------ 如果请求成功，响应类似如下示例。 ``` { "arn": "arn:aws:greengrass:region:123456789012:components:com.example.HelloWorld:versions:1.0.0", "componentName": "com.example.HelloWorld", "componentVersion": "1.0.0", "creationTimestamp": "Mon Nov 30 09:04:05 UTC 2020", "status": { "componentState": "REQUESTED", "message": "NONE", "errors": {} } } ``` 从输出中复制 `arn`，以便在下一步中检查组件的状态。 **注意** 您还可以在 [AWS IoT Greengrass 控制台](https://console.aws.amazon.com/greengrass)的**组件**页面上看到 Hello World 组件。 1. 验证组件是否已创建且已准备好部署。创建组件后，其状态为 `REQUESTED`。然后， AWS IoT Greengrass 验证该组件是否可部署。您可以运行以下命令来查询组件状态并验证您的组件是否可部署。将 `arn` 替换为上一步中的 ARN。 ``` aws greengrassv2 describe-component --arn "arn:aws:greengrass:region:123456789012:components:com.example.HelloWorld:versions:1.0.0" ``` 如果组件通过验证，则响应中的组件状态会显示为 `DEPLOYABLE`。 ``` { "arn": "arn:aws:greengrass:region:123456789012:components:com.example.HelloWorld:versions:1.0.0", "componentName": "com.example.HelloWorld", "componentVersion": "1.0.0", "creationTimestamp": "2020-11-30T18:04:05.823Z", "publisher": "Amazon", "description": "My first Greengrass component.", "status": { "componentState": "DEPLOYABLE", "message": "NONE", "errors": {} }, "platforms": [ { "os": "linux", "architecture": "all" } ] } ``` 你的 Hello World 组件现已在中可用 AWS IoT Greengrass。您可以将其部署回此 Greengrass 核心设备或其它核心设备。 # 第 6 步：部署组件 借助 AWS IoT Greengrass，您可以将组件部署到单个设备或设备组。当您部署组件时，AWS IoT Greengrass 会在每台目标设备上安装并运行该组件的软件。您可以指定要部署的组件以及要为每个组件部署的配置更新。您还可以控制部署如何扩展到部署的目标设备。有关更多信息，请参阅 [将 AWS IoT Greengrass 组件部署到设备](manage-deployments.md)。 在本部分中，您将 Hello World 组件部署回 Greengrass 核心设备。 ## 部署组件（控制台） 1. 在 [AWS IoT Greengrass 控制台](https://console.aws.amazon.com/greengrass)导航菜单中，选择**组件**。 1. 在**组件**页面的**我的组件**选项卡上，选择 **com.example.HelloWorld**。 1. 在 **com.example.HelloWorld** 页面上，选择**部署**。 1. 从**添加到部署**中选择**创建新部署**，然后选择**下一步**。 1. 在**指定目标**页面中，执行以下操作： 1. 在**名称**框中，输入 **Deployment for MyGreengrassCore**。 1. 对于**部署目标**，选择**核心设备**，以及核心设备的 AWS IoT 事物的名称。本教程中的默认值是 *MyGreengrassCore*。 1. 选择**下一步**。 1. 在**选择组件**页面的**我的组件**下，确认已选择 **com.example.HelloWorld** 组件，然后选择**下一步**。 1. 在**配置组件**页面上，选择 **com.example.HelloWorld**，然后执行以下操作： 1. 选择**配置组件**。 1. 在**配置更新**下的**要合并的配置**中，输入以下配置。 ``` { "Message": "universe" } ``` 此配置更新将此部署中设备的 Hello World `Message` 参数设置为 `universe`。 1. 选择**确认**。 1. 选择**下一步**。 1. 在**配置高级设置**页面上，保留默认配置设置，然后选择**下一步**。 1. 在 **检查** 页上，选择 **部署**。 1. 验证部署是否成功完成。完成部署可能需要数分钟。查看 Hello World 日志以验证更改。在 Greengrass 核心设备上运行以下命令。 ------ #### [ Linux or Unix ] ``` sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log ``` ------ #### [ Windows Command Prompt (CMD) ] ``` type C:\greengrass\v2\\logs\\com.example.HelloWorld.log ``` ------ #### [ PowerShell ] ``` gc C:\greengrass\v2\\logs\\com.example.HelloWorld.log -Tail 10 -Wait ``` ------ 您应该会看到类似于以下示例的消息。 ``` Hello, universe! Greetings from your first Greengrass component. ``` **注意** 如果日志消息未更改，则表示部署失败或未到达核心设备。如果您的核心设备未连接到互联网或无权从 S3 存储桶中检索构件，则可能会发生这种情况。在核心设备上运行以下命令，以查看 AWS IoT Greengrass Core 软件日志文件。此文件包含来自 Greengrass 核心设备的部署服务的日志。 ``` sudo tail -f /greengrass/v2/logs/greengrass.log ``` ``` type C:\greengrass\v2\\logs\\greengrass.log ``` `type` 命令将文件内容写入终端。多次运行此命令，以观察文件中的更改。 ``` gc C:\greengrass\v2\\logs\\greengrass.log -Tail 10 -Wait ``` 有关更多信息，请参阅 [故障排除 AWS IoT Greengrass V2](troubleshooting.md)。 ## 部署组件（AWS CLI） **部署 Hello World 组件** 1. 在开发计算机上，创建一个名为 `hello-world-deployment.json` 的文件，并将以下 JSON 复制到该文件中。此文件定义了要部署的组件和配置。 ``` { "components": { "com.example.HelloWorld": { "componentVersion": "1.0.0", "configurationUpdate": { "merge": "{\"Message\":\"universe\"}" } } } } ``` 此配置文件指定部署您在之前的过程中开发和发布的 Hello World 组件的版本 `1.0.0`。`configurationUpdate` 指定以 JSON 编码的字符串合并组件配置。此配置更新将此部署中设备的 Hello World `Message` 参数设置为 `universe`。 1. 运行以下命令，将组件部署到 Greengrass 核心设备。您可以部署到事物（即单个设备）或事物组（即设备组）。将 *MyGreengrassCore* 替换为您的核心设备的 AWS IoT 事物的名称。 ------ #### [ Linux or Unix ] ``` aws greengrassv2 create-deployment \ --target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" \ --cli-input-json file://hello-world-deployment.json ``` ------ #### [ Windows Command Prompt (CMD) ] ``` aws greengrassv2 create-deployment ^ --target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" ^ --cli-input-json file://hello-world-deployment.json ``` ------ #### [ PowerShell ] ``` aws greengrassv2 create-deployment ` --target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" ` --cli-input-json file://hello-world-deployment.json ``` ------ 此命令将输出类似于以下示例的输出。 ``` { "deploymentId": "deb69c37-314a-4369-a6a1-3dff9fce73a9", "iotJobId": "b5d92151-6348-4941-8603-bdbfb3e02b75", "iotJobArn": "arn:aws:iot:region:account-id:job/b5d92151-6348-4941-8603-bdbfb3e02b75" } ``` 1. 验证部署是否成功完成。完成部署可能需要数分钟。查看 Hello World 日志以验证更改。在 Greengrass 核心设备上运行以下命令。 ------ #### [ Linux or Unix ] ``` sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log ``` ------ #### [ Windows Command Prompt (CMD) ] ``` type C:\greengrass\v2\\logs\\com.example.HelloWorld.log ``` ------ #### [ PowerShell ] ``` gc C:\greengrass\v2\\logs\\com.example.HelloWorld.log -Tail 10 -Wait ``` ------ 您应该会看到类似于以下示例的消息。 ``` Hello, universe! Greetings from your first Greengrass component. ``` **注意** 如果日志消息未更改，则表示部署失败或未到达核心设备。如果您的核心设备未连接到互联网或无权从 S3 存储桶中检索构件，则可能会发生这种情况。在核心设备上运行以下命令，以查看 AWS IoT Greengrass Core 软件日志文件。此文件包含来自 Greengrass 核心设备的部署服务的日志。 ``` sudo tail -f /greengrass/v2/logs/greengrass.log ``` ``` type C:\greengrass\v2\\logs\\greengrass.log ``` `type` 命令将文件内容写入终端。多次运行此命令，以观察文件中的更改。 ``` gc C:\greengrass\v2\\logs\\greengrass.log -Tail 10 -Wait ``` 有关更多信息，请参阅 [故障排除 AWS IoT Greengrass V2](troubleshooting.md)。 # 后续步骤 您已完成本教程。AWS IoT Greengrass Core 软件和您的 Hello World 组件在您的设备上运行。此外，您的 Hello World 组件在 AWS IoT Greengrass 云服务中可用，可以部署到其他设备。有关本教程探讨的主题的更多信息，请参阅以下内容： + [创建 AWS IoT Greengrass 组件](create-components.md) + [发布组件以部署到您的核心设备](publish-components.md) + [将 AWS IoT Greengrass 组件部署到设备](manage-deployments.md)