先决条件步骤 1：设置Amazon账户步骤 2：设置您的环境步骤 3：安装Amazon IoT Greengrass核心软件第 4 步：在您的设备上开发和测试组件步骤 5：在Amazon IoT Greengrass服务中创建组件步骤 6：部署您的组件后续步骤

教程：Amazon IoT Greengrass V2 入门

您可以完成本入门教程以了解的基本功能Amazon IoT Greengrass V2。在本教程中，您将执行以下操作：

在 Linux 设备（例如 Raspberry Pi 或 Windows 设备）上安装和配置Amazon IoT Greengrass核心软件。该设备是 Greengrass 的核心设备。
在你的 Greengrass 核心设备上开发 Hello World 组件。组件是在 Greengrass 核心设备上运行的软件模块。
将该组件上传到Amazon IoT Greengrass V2Amazon Web Services 云。
将该组件从部署Amazon Web Services 云到你的 Greengrass 核心设备上。

注意

本教程介绍如何设置开发环境并探索的功能Amazon IoT Greengrass。有关如何设置和配置生产设备的更多信息，请参阅以下文档：

您预计需要花费 20 到 30 分钟来完成本教程。

先决条件

要完成本入门教程，您需要以下条件：

一个 Amazon Web Services 账户。如果没有，请参阅步骤 1：设置Amazon账户。
使用Amazon Web Services 区域支持Amazon IoT Greengrass V2. 有关支持的区域列表，请参阅Amazon一般参考中的Amazon IoT Greengrass V2终端节点和配额。
具有管理员权限的Amazon Identity and Access Management (IAM) 用户。
一台具有互联网连接的 Windows、macOS 或 Unix 类开发计算机。
一种设置为 Greengrass 核心设备的设备，例如装有 Raspberry P i 操作系统（以前称为 Raspb ian）的 Raspberry Pi 或 Windows 10 设备。您必须拥有此设备的管理员权限，或者能够获得管理员权限，例如通过sudo。此设备必须有互联网连接。

您也可以选择使用符合要求的其他设备来安装和运行Amazon IoT Greengrass Core 软件。有关更多信息，请参阅支持的平台和要求：

如果您的开发计算机符合这些要求，则可以在本教程中将其设置为 Greengrass 核心设备。
为设备上的所有用户安装了 Python 3.5 或更高版本，并将其添加到PATH环境变量中。在 Windows 上，还必须为所有用户安装适用于 Windows 的 Python Launcher。
重要
在 Windows 中，默认情况下不会为所有用户安装 Python。安装 Python 时，必须自定义安装以将其配置为Amazon IoT Greengrass核心软件运行 Python 脚本。例如，如果您使用图形化 Python 安装程序，请执行以下操作：
1. 选择 “为所有用户安装启动器（推荐）”。
2. 选择 Customize installation。
3. 选择 Next。
4. Select Install for all users.
5. Select Add Python to environment variables.
6. 选择安装。
有关更多信息，请参阅 Python 3 文档中的 “在 Windows 上使用 Python”。
Amazon Command Line Interface(Amazon CLI) 在您的开发计算机和设备上安装并使用凭据进行配置。确保在开发计算机和设备Amazon CLI上使用相同的方法Amazon Web Services 区域来配置。要Amazon IoT Greengrass V2与一起使用Amazon CLI，必须具有以下版本之一或更高版本：
- Amazon CLIV1 最低版本：v1.18.197
- Amazon CLIV2 最低版本：v2.1.11
提示
您可以运行以下命令检查您所拥有的版本。Amazon CLI
```
aws --version
```
有关更多信息，请参阅《Amazon Command Line Interface用户指南》中的 “安装、更新Amazon CLI和卸载”Amazon CLI 和 “配置”。

注意
如果你使用 32 位 ARM 设备，例如装有 32 位操作系统的树莓派，请安装Amazon CLI V1。 Amazon CLIV2 不适用于 32 位 ARM 设备。有关更多信息，请参阅安装、更新和卸载Amazon CLI版本 1。

步骤 1：设置Amazon账户

如果您还没有 Amazon Web Services 账户，请完成以下步骤来创建一个。

注册 Amazon Web Services 账户

打开 https://portal.aws.amazon.com/billing/signup。
按照屏幕上的说明进行操作。

在注册时，您将接到一通电话，要求您使用电话键盘输入一个验证码。

当您注册 Amazon Web Services 账户时，系统将会创建一个 Amazon Web Services 账户根用户。根用户有权访问该账户中的所有 Amazon Web Services和资源。作为安全最佳实践，请为管理用户分配管理访问权限，并且只使用根用户执行需要根用户访问权限的任务。

Amazon注册过程完成后，会向您发送一封确认电子邮件。在任何时候，您都可以通过转至 https://aws.amazon.com/ 并选择 My Account (我的账户) 来查看当前的账户活动并管理您的账户。

保护 IAM 用户

要授予其他用户访问您的 Amazon Web Services 账户资源的权限，请创建 IAM 用户。要保护您的 IAM 用户，请开启 MFA 并仅向 IAM 用户授予执行任务所需的权限。

有关创建和保护 IAM 用户的更多信息，请参阅《IAM 用户指南》中的以下主题：

步骤 2：设置您的环境

按照本节中的步骤设置 Linux 或 Windows 设备用作Amazon IoT Greengrass核心设备。

这些步骤假设你使用带树莓派操作系统的树莓派。如果您使用其他设备或操作系统，请查阅设备的相关文档。

为 Raspberry Pi 设置为Amazon IoT Greengrass V2

在 Raspberry Pi 上启用 SSH 即可远程连接到它。有关更多信息，请参阅 Raspberry Pi 文档中的 SSH（安全外壳）。
找到你的 Raspberry Pi 的 IP 地址，然后通过 SSH 连接到它。为此，可以在Raspberry Pi上运行以下命令。
```
hostname -I
```
使用 SSH Connect 您的树莓派。

在您的开发计算机上，运行以下命令。将用户名替换为要登录的用户名，并pi-ip-address用您在上一步中找到的 IP 地址替换。
```
ssh username@pi-ip-address
```
默认的 Raspberry Pi 用户名pi和raspberry密码分别是和。

重要
如果你的开发计算机使用早期版本的 Windows，你可能没有这个ssh命令，或者你可能有ssh但无法连接到 Raspberry Pi。要连接到 Raspberry Pi，你可以安装和配置 P uTTY，这是一款免费的开源 SSH 客户端。请查阅 PuTTY 文档以连接到您的树莓派。
安装 Java 运行时，Amazon IoT Greengrass核心软件需要使用该运行库。在树莓派上，使用以下命令安装 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)
```

将 Linux 设备设置为Amazon IoT Greengrass V2

安装 Java 运行时，Amazon IoT Greengrass核心软件需要使用该运行库。我们建议你使用亚马逊 Corretto 11 或 OpenJDK 11。以下命令向您展示如何在您的设备上安装 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
```
安装完成后，运行以下命令以验证 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)
```
（可选）创建在设备上运行组件的默认系统用户和组。您也可以选择让Amazon IoT Greengrass核心软件安装程序在安装期间使用安装程序参数创建此用户和组。--component-default-user有关更多信息，请参阅安装程序参数：
```
sudo useradd --system --create-home ggc_user
sudo groupadd --system ggc_group
```
验证运行Amazon IoT Greengrass Core 软件的用户（通常root）是否有权sudo与任何用户和任何组一起运行。
1. 运行以下命令以打开/etc/sudoers文件。
```
sudo visudo
```
2. 确认用户的权限如以下示例所示。
```
root    ALL=(ALL:ALL) ALL
```
（可选）要运行容器化的 Lambda 函数，必须启用 c groups v1，并且必须启用和装载内存和设备 cgroup。如果您不打算运行容器化的 Lambda 函数，则可跳过这一步。

要启用这些 cgroups 选项，请使用以下 Linux 内核参数启动设备。
```
cgroup_enable=memory cgroup_memory=1 systemd.unified_cgroup_hierarchy=0
```
有关查看和设置设备内核参数的信息，请参阅您的操作系统和启动加载器的文档。按照说明永久设置内核参数。
提示：在 Raspberry Pi 上设置内核参数
如果您的设备是 Raspberry Pi，则可以完成以下步骤来查看和更新其 Linux 内核参数：
1. 打开 /boot/cmdline.txt 文件。此文件指定树莓派启动时要应用的 Linux 内核参数。
  
  例如，在基于 Linux 的系统上，您可以运行以下命令使用 GNU nano 打开文件。
  
  sudo nano /boot/cmdline.txt
2. 确认该/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文件不包含这些参数，或者它包含这些具有不同值的参数，请更新文件以包含这些参数和值。
3. 如果您更新了/boot/cmdline.txt文件，请重新启动 Raspberry Pi 以应用更改。
  
  sudo reboot
按照中的要求列表所示，在您的设备上安装所有其他必需的依赖项设备要求。

将 Windows 设备设置为Amazon IoT Greengrass V2

安装 Java 运行时，Amazon IoT Greengrass核心软件需要使用该运行库。我们建议你使用亚马逊 Corretto 11 或 OpenJDK 11。
检查 PATH 系统变量上是否有 Java，如果不可用，则添加它。该 LocalSystem 帐户运行Amazon IoT Greengrass核心软件，因此您必须将 Java 添加到 PATH 系统变量中，而不是用户的 PATH 用户变量。执行以下操作：
1. 按 Windows 键打开开始菜单。
2. environment variables在开始菜单中键入搜索系统选项。
3. 在开始菜单搜索结果中，选择编辑系统环境变量以打开系统属性窗口。
4. 选择环境变量... 打开 “环境变量” 窗口。
5. 在 “系统变量” 下，选择 “路径”，然后选择 “编辑”。在 “编辑环境变量” 窗口中，可以在单独的行上查看每条路径。
6. 检查 Java 安装bin文件夹的路径是否存在。该路径可能类似下例。
```
C:\Program Files\Amazon Corretto\jdk11.0.13_8\bin
```
7. 如果 Path 中缺少 Java 安装bin文件夹，请选择 “新建” 进行添加，然后选择 “确定”。
以管理员身份打开 Windows 命令提示符 (cmd.exe)。
在 Windows 设备上的 LocalSystem 帐户中创建默认用户。用安全密码替换密码。
```
net user /add ggc_user password
```
提示
根据您的 Windows 配置，用户的密码可能会设置为在将future 某个日期过期。为确保您的 Greengrass 应用程序继续运行，请跟踪密码何时过期，并在密码过期之前进行更新。您也可以将用户的密码设置为永不过期。
- 要检查用户及其密码何时过期，请运行以下命令。
  
  net user ggc_user | findstr /C:expires
- 要将用户的密码设置为永不过期，请运行以下命令。
  
  wmic UserAccount where "Name='ggc_user'" set PasswordExpires=False
从微软下载该PsExec实用程序并将其安装在设备上。
使用该 PsExec 实用程序将默认用户的用户名和密码存储在该 LocalSystem 账户的凭据管理器实例中。用您之前设置的用户密码替换密码。
```
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：安装Amazon IoT Greengrass核心软件

按照本节中的步骤将 Raspberry Pi 设置为可用于本地开发的Amazon IoT Greengrass核心设备。在本节中，您将下载并运行安装程序，该安装程序执行以下操作，为您的设备配置Amazon IoT Greengrass Core 软件：

安装 Greengrass 核心组件。nucleus 是必备组件，是在设备上运行Amazon IoT Greengrass Core 软件的最低要求。有关更多信息，请参阅 Greengrass necify grass nu
将您的设备注册为Amazon IoT事物，并下载允许您的设备连接的数字证书Amazon。有关更多信息，请参阅Amazon IoT Greengrass 的设备身份验证和授权：
将设备Amazon IoT的事物添加到事物组，即一组或一组Amazon IoT事物。事物组使您能够管理 Greengrass 核心设备队列。将软件组件部署到设备时，可以选择部署到单个设备或设备组。有关更多信息，请参阅《Amazon IoT Core开发者指南》Amazon IoT中的 “使用管理设备”。
创建 IAM 角色，允许您的 Greengrass 核心设备与Amazon服务进行交互。默认情况下，此角色允许您的设备与 Amazon Logs 进行交互Amazon IoT并将日志发送到 Amazon CloudWatch Logs。有关更多信息，请参阅授权核心设备与Amazon服务：
安装Amazon IoT Greengrass命令行接口 (greengrass-cli)，您可以使用它来测试在核心设备上开发的自定义组件。有关更多信息，请参阅Greengrass Command Line Interface：

登录到 Amazon IoT Greengrass 控制台。
在 “开始使用 Greengras s” 下，选择 “设置一台核心设备”。
在步骤 1：注册 Greengrass 核心设备下，在核心设备名称中输入您Amazon IoT的 Greengrass 核心设备的名称。如果此事不存在，安装程序将创建它。
在步骤 2：添加到事物组以应用持续部署下，对于事物组，选择要向其添加核心设备Amazon IoT的事物组。
- 如果选择 “输入新组名”，则在 “事物组名称” 中输入要创建的新组的名称。安装程序会为您创建新组。
- 如果您选择选择现有组，则在事物组名称中，选择要使用的现有组。
- 如果您选择 “无组”，则安装程序不会将核心设备添加到事物组。
在步骤 3：安装 Greengrass Core 软件下，完成以下步骤。
1. 选择你的核心设备的操作系统：Linux 或 Windows。
2. 向设备提供您的Amazon证书，以便安装程序可以为您的核心设备预置Amazon IoT和 IAM 资源。为了提高安全性，我们建议您获取 IAM 角色的临时证书，该证书仅允许预置所需的最低权限。有关更多信息，请参阅安装程序配置资源的最低 IAM 策略：
  
  注意
  安装程序不保存或存储您的证书。
  
  在您的设备上，执行以下任一操作以检索凭据并将其提供给Amazon IoT Greengrass Core 软件安装程序：
  - 使用 IAM 用户提供的长期凭证：
    1. 为您的 IAM 用户提供访问密钥 ID 和秘密访问密钥。有关如何检索长期凭证的更多信息，请参阅 IAM 用户指南中的管理 IAM 用户的访问密钥部分。
    2. 运行以下命令为Amazon 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"
  - （推荐）使用来自 IAM 角色的临时安全证书：
    1. 提供您代入的 IAM 角色的访问密钥 ID、提供访问密钥和会话令牌。有关如何检索这些证书的更多信息，请参阅 IAM 用户指南中的申请临时安全证书。
    2. 运行以下命令为Amazon 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="
3. 在 Run Insts（运行安装程序）下，完成以下步骤。
  1. 在 “下载安装程序” 下，选择 “复制”，然后在核心设备上运行复制的命令。此命令下载最新版本的Amazon IoT Greengrass Core 软件并将其解压缩到您的设备上。
  2. 在 “运行安装程序” 下，选择 “复制”，然后在核心设备上运行复制的命令。此命令使用您之前指定的事物和事物组名称来运行Amazon IoT Greengrass核心软件安装程序并为核心设备设置Amazon资源。Amazon IoT
    
    此命令还执行以下操作：
    - 将Amazon IoT Greengrass Core 软件设置为在启动时运行的系统服务。在 Linux 设备上，这需要 Systemd 初始化系统。
      
      重要
      在 Windows 核心设备上，必须将Amazon IoT Greengrass核心软件设置为系统服务。
    - 部署 Amazon IoT GreengrassCLI 组件，这是一个命令行工具，可让您在核心设备上开发自定义 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，安装程序不会将软件设置为系统服务，你也不会看到将 nucleus 设置为系统服务的成功消息。

安装和配置Amazon IoT Greengrass核心软件

在 Greengrass 核心设备上，运行以下命令切换到主目录。
Linux or Unix
```
cd ~
```
Windows Command Prompt (CMD)
```
cd %USERPROFILE%
```
PowerShell
```
cd ~
```

在您的核心设备上，将Amazon IoT Greengrass Core 软件下载到名为的文件中greengrass-nucleus-latest.zip。

下载此软件即表示您同意 Greengrass 核心软件许可协议。

将Amazon IoT Greengrass Core 软件解压缩到设备上的文件夹。GreengrassInstaller替换为要使用的文件夹。

运行以下命令以启动Amazon IoT Greengrass Core 软件安装程序。此命令执行以下操作：
- 创建核心设备运行所需的Amazon资源。
- 将Amazon IoT Greengrass Core 软件设置为在启动时运行的系统服务。在 Linux 设备上，这需要 Systemd 初始化系统。
  
  重要
  在 Windows 核心设备上，必须将Amazon IoT Greengrass核心软件设置为系统服务。
- 部署 Amazon IoT GreengrassCLI 组件，这是一个命令行工具，可让您在核心设备上开发自定义 Greengrass 组件。
- 指定使用ggc_user系统用户在核心设备上运行软件组件。在 Linux 设备上，此命令还指定使用ggc_group系统组，安装程序会为您创建系统用户和组。
按如下方式替换命令中的参数值。
1. /greengrass/v2 或 C:\greengrass\v2：用于安装Amazon IoT Greengrass核心软件的根文件夹路径。
2. GreengrassInstaller。解压Amazon IoT Greengrass核心软件安装程序的文件夹路径。
3. 地区。Amazon Web Services 区域在其中查找或创建资源。
4. MyGreengrassCore。您的 Greengrass 核心设备的Amazon IoT事物的名称。如果此事不存在，安装程序将创建它。安装程序下载证书以进行身份验Amazon IoT证。有关更多信息，请参阅Amazon IoT Greengrass 的设备身份验证和授权：
  
  注意
  事物名称不能包含冒号 (:) 字符。
5. MyGreengrassCoreGroup。您的 Greengrass 核心设备Amazon IoT的事物组名称。如果事物组不存在，则安装程序会创建该组并将该事物添加到该组中。如果事物组存在并且正在进行有效的部署，则核心设备会下载并运行部署指定的软件。
  
  注意
  事物组名称不能包含冒号 (:) 字符。
6. Greengrassv2IoTThingPolicy。允许 Greengrass 核心设备与Amazon IoT和通信的Amazon IoT策略的名称Amazon IoT Greengrass。如果Amazon IoT策略不存在，安装程序将使用此名称创建许可Amazon IoT策略。您可以针对您的用例限制此策略的权限。有关更多信息，请参阅Amazon IoT Greengrass V2核心设备的最低Amazon IoT政策：
7. GreenGrassv2TokenExchangeRole。允许 Greengrass 核心设备获取临时Amazon证书的 IAM 角色的名称。如果该角色不存在，则安装程序创建角色，同时创建和附加一个名为的策略GreengrassV2TokenExchangeRoleAccess。有关更多信息，请参阅授权核心设备与Amazon服务：
8. GreengrassCoreTokenExchangeRoleAlias。IAM 角色的别名，允许 Greengrass 核心设备稍后获取临时证书。如果角色别名不存在，安装程序会创建该别名并将其指向您指定的 IAM 角色。有关更多信息，请参阅授权核心设备与Amazon服务：
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
```
注意
如果您在内存有限的设备Amazon IoT Greengrass上运行，则可以控制Amazon IoT Greengrass Core 软件使用的内存量。要控制内存分配，可以在 nucleus 组件的jvmOptions配置参数中设置 JVM 堆大小选项。有关更多信息，请参阅使用 JVM 选项控制内存分配：

运行此命令时，应看到以下消息，表明安装程序已成功。
```
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，安装程序不会将软件设置为系统服务，你也不会看到将 nucleus 设置为系统服务的成功消息。

（可选）运行 Greengrass 软件 (Linux)

如果您将软件作为系统服务安装，则安装程序会为您运行该软件。否则，您必须运行软件。要查看安装程序是否将软件设置为系统服务，请在安装程序输出中查找以下行。


Successfully set up Nucleus as a system service

如果您没有看到此消息，请执行以下操作来运行该软件：

请运行以下命令以运行软件。
```
sudo /greengrass/v2/alts/current/distro/bin/loader
```
如果软件成功启动，则会打印以下消息。
```
Launched Nucleus successfully.
```
必须保持当前命令 shell 处于打开状态才能保持Amazon IoT Greengrass核心软件的运行。如果您使用 SSH 连接到核心设备，请在开发计算机上运行以下命令以打开第二个 SSH 会话，您可以使用该会话在核心设备上运行其他命令。将用户名替换为要登录的用户名，并pi-ip-address替换为设备的 IP 地址。
```
ssh username@pi-ip-address
```

有关如何与 Greengrass 系统服务交互的更多信息，请参阅将 Greengrass 核心配置为系统服务。

验证设备上是否安装了 Greengrass CLI

Greengrass CLI 最多可能需要一分钟才能部署。请运行以下命令检查部署的状态。MyGreengrassCore替换为核心设备的名称。


aws greengrassv2 list-effective-deployments --core-device-thing-name MyGreengrassCore

coreDeviceExecutionStatus表示部署到核心设备的状态。当状态为时SUCCEEDED，运行以下命令验证Greengrass CLI 是否安装并运行。将 /greengrass/v2 替换为根文件夹的路径。

该命令输出 Greengrass CLI 的帮助信息。如果找greengrass-cli不到，则部署可能无法安装 Greengrass CLI。有关更多信息，请参阅排除 Amazon IoT Greengrass V2 的故障：

您还可以运行以下命令将Amazon IoT Greengrass CLI 手动部署到您的设备。

用你Amazon Web Services 区域使用的区域替换区域。确保使用与在设备Amazon CLI上配置时使用的相同Amazon Web Services 区域。
将账户 ID 替换为你的Amazon Web Services 账户 ID。
MyGreengrassCore替换为核心设备的名称。

提示

您可以将/greengrass/v2/bin (Linux) 或C:\greengrass\v2\bin (Windows) 添加到PATH环境变量中，使其在没有绝对路径greengrass-cli的情况下运行。

Amazon IoT GreengrassCore 软件和本地开发工具在您的设备上运行。接下来，你可以在你的设备上开发 Hello WorldAmazon IoT Greengrass 组件。

第 4 步：在您的设备上开发和测试组件

组件是在Amazon IoT Greengrass核心设备上运行的软件模块。组件使您能够将复杂的应用程序作为离散的构造块进行创建和管理，您可以将它们从一台 Greengrass 核心设备重复使用到另一台 Greengrass 核心设备。每个组件都由配方和工件组成。

食谱

每个组件都包含一个定义其元数据的配方文件。该食谱还指定了组件的配置参数、生命周期、生命周期、生命周期、生命周期、生命周期、该食谱和平台兼容性。组件生命周期定义了安装、运行和关闭组件的命令。有关更多信息，请参阅Amazon IoT Greengrass组件配方参考：

你可以用 JSON 或 YAML 格式定义食谱。
文物

组件可以有任意数量的工件，即组件二进制文件。构件可以包括脚本、编译后的代码、静态资源以及组件使用的任何其他文件。组件也可以消耗组件依赖关系中的构件。

借助Amazon IoT Greengrass，您可以使用 Greengrass CLI 在 Greengrass 核心设备上本地开发和测试组件，无需与Amazon云端交互。完成本地组件后，您可以使用组件配方和构件在Amazon云端的Amazon IoT Greengrass服务中创建该组件，然后将其部署到所有 Greengrass 核心设备上。有关组件的更多信息，请参阅开发Amazon IoT Greengrass组件。

在本节中，您将学习如何在核心设备上本地创建和运行基本的 Hello World 组件。

在您的设备上开发 Hello World 组件

为您的组件创建一个文件夹，其中包含用于存放配方和工件的子文件夹。在 Greengrass 核心设备上运行以下命令以创建这些文件夹并更改为组件文件夹。将 ~/greengrassv2 或 %USERPROFILE%\ greengrassv2 替换为用于本地开发的文件夹路径。
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
```
使用文本编辑器创建食谱文件，食谱文件和平台功能和平台功能。在配方文件名中包含组件版本，这样您就可以确定哪个配方反映了哪个组件版本。你可以为你的食谱选择 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
```
注意
Amazon IoT Greengrass对组件使用语义版本。语义版本遵循主要版本。 未成年人。补丁号系统。例如，版本1.0.0代表组件的第一个主要版本。想要了解更多有关信息，请参阅语义版本规范。

将以下配方粘贴到该文件中。

此食谱ComponentConfiguration部分定义了一个参数Message，默认为world。该Manifests部分定义了一个清单，这是一组适用于平台的生命周期指令和构件。例如，您可以定义多个清单，为不同的平台指定不同的安装说明。在清单中，该Lifecycle部分指示 Greengrass 核心设备以Message参数值作为参数运行 Hello World 脚本。

运行以下命令为组件生命周期。
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/
```
使用文本编辑器为您的 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)
```

使用本地Amazon IoT Greengrass CLI 管理 Greengrass 核心设备上的组件。

运行以下命令将组件部署到内Amazon IoT Greengrass核。用你的Amazon IoT Greengrass V2根文件夹替换 /greengrass/v2 或 C:\greengrass\v2，用你的组件开发文件夹替换 ~/greengrassv2 或 %USERPROFILE%\ greengrassv2。

此命令添加了在中使用配方的组件，recipes并在中添加了 Python 脚本artifacts。该--merge选项添加或更新您指定的组件和版本。

Amazon IoT GreengrassCore 软件将组件进程中的 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 秒内不存在，则部署可能失败。例如，如果你的食谱无效，就会发生这种情况。请运行以下命令查看Amazon IoT Greengrass核心日志文件。此文件包含来自 Greengrass 核心设备部署服务的日志。
Linux or Unix

sudo tail -f /greengrass/v2/logs/greengrass.log

Windows Command Prompt (CMD)

type C:\greengrass\v2\logs\greengrass.log

该type命令将文件内容写入终端。多次运行此命令以观察文件中的变化。

PowerShell

gc C:\greengrass\v2\logs\greengrass.log -Tail 10 -Wait

修改本地组件以迭代和测试您的代码。hello_world.py在文本编辑器中打开，在第 4 行添加以下代码以编辑Amazon 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)

运行以下命令以使用您的更改更新组件。

此命令使用最新的 Hello World 构件更新com.example.HelloWorld组件。

请运行以下命令以重新启动组件。重新启动组件时，核心设备使用最新的更改。

再次检查日志，验证 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. 使用文本编辑器创建名为的文件hello-world-config-update.json，以包含配置更新
  
  例如，在基于 Linux 的系统上，您可以运行以下命令来使用 GNU nano 创建文件。
```
nano hello-world-config-update.json
```
2. 复制以下 JSON 对象并将其粘贴到该文件中。此 JSON 对象定义了一个配置更新，该更新friend将值合并到Message参数以更新其值。此配置更新未指定任何要重置的值。您无需重置Message参数，因为合并更新会替换现有值。
```
{
  "com.example.HelloWorld": {
    "MERGE": {
      "Message": "friend"
    }
  }
}
```
3. 运行以下命令将配置更新部署到 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
4. 再次检查日志，验证 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.
```
完成组件测试后，将其从核心设备中移除。运行以下命令。
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"
```
重要
在将组件上传到后，您需要执行此步骤才能将其重新部署到核心设备Amazon 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 组件已完成，您现在可以将其上传到Amazon IoT Greengrass云服务。然后，可以将组件部署到 Greengrass 核心设备。

步骤 5：在Amazon IoT Greengrass服务中创建组件

在核心设备上完成组件的开发后，可以在中将其上传到Amazon IoT Greengrass服务Amazon Web Services 云。您也可以直接在Amazon IoT Greengrass控制台中创建组件。 Amazon IoT Greengrass提供托管组件的组件管理服务，以便您可以将它们部署到单个设备或设备群中。要将组件上传到Amazon IoT Greengrass服务，请完成以下步骤：

将组件构件上传到 S3 存储桶。
将每个生命的Amazon Simple Storage Service (Amazon S3) URI。
Amazon IoT Greengrass从组件配方中创建组件。

在本节中，您将在 Greengrass 核心设备上完成这些步骤，将您的 Hello World 组件上传到该Amazon IoT Greengrass服务。

使用Amazon账户中的 S3 存储段来托管Amazon IoT Greengrass组件构件。当您将组件部署到核心设备时，设备会从存储桶中下载该组件的工件。

您可以使用现有的 S3 存储桶，也可以创建新存储桶。
1. 在 Amazon S3 控制台的存储桶下，选择创建存储桶。
2. 在存储段名称中，输入唯一的存储段名称。例如，您可以使用 greengrass-component-artifacts-123456789012-region。将 123456789012 替换为您的Amazon账户 ID，将Amazon区域替换为您在本教程中使用的区域。
3. 对于Amazon区域，请选择您在本教程中使用的Amazon区域。
4. 选择创建桶。
5. 在 B uckets 下，选择您创建的存储桶，将hello_world.py脚本上传到存储段中的artifacts/com.example.HelloWorld/1.0.0文件夹。有关将对象上传到 S3 存储桶的信息，请参阅 A mazon Simple Storage Service 用户指南中的上传对象。
6. 将hello_world.py对象的 S3 URI 复制到 S3 存储桶。此 URI 应类似于以下示例。将 DOC-EXAMPLE-BU CKET 替换为 S3 存储桶的名称。
```
s3://DOC-EXAMPLE-BUCKET/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
允许核心设备访问 S3 存储桶中的组件构件。

每个核心设备都有一个核心设备 IAM 角色，允许它与云进行交互Amazon IoT并将日志发送到Amazon云端。默认情况下，此设备角色不允许访问 S3 存储桶，因此您必须创建并附加允许核心设备从 S3 存储桶检索组件工件的策略。

如果您的设备的角色已允许访问 S3 存储桶，则可跳过本步骤。否则，创建允许访问的 IAM 策略并将其附加到角色，如下所示：
1. 在 IAM 控制台导航菜单中，选择策略，然后选择创建策略。
2. 在 JSON 选项卡中，将占位符内容替换为以下策略。请将 DOC-EXAMPLE- BUCKET 替换为 S3 存储桶的名称。
```
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "s3:GetObject"
      ],
      "Resource": "arn:aws:s3:::DOC-EXAMPLE-BUCKET/*"
    }
  ]
}
```
3. 依次选择 Next: Tags（下一步：标签）和 Next: Review（下一步：查看）。
4. 对于 Name (名称)，请输入 MyGreengrassV2ComponentArtifactPolicy。
5. 选择 Create policy（创建策略）。
6. 在 IAM 控制台的导航菜单中，选择 Role (角色)，然后选择核心设备的角色名称。您在安装Amazon IoT Greengrass Core 软件时指定了此角色名称。如果您未指定名称，则默认值为GreengrassV2TokenExchangeRole。
7. 在 “权限” 下，选择 “添加权限”，然后选择 “附加策略”。
8. 在 Add permissionMyGreengrassV2ComponentArtifactPolicy sions (添加权限)。

使用组件配方在Amazon IoT Greengrass控制台中创建组件。

在Amazon IoT Greengrass控制台导航菜单中，选择组件，然后选择创建组件。

在 “组件信息” 下，选择 “以 JSON 形式输入配方”。占位符配方应类似于以下示例。


{
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.HelloWorld",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "My first Amazon 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://DOC-EXAMPLE-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://DOC-EXAMPLE-BUCKET/artifacts/com.example.HelloWorld/1.0.0/hello_world.py"
        }
      ]
    }
  ]
}

将每个Artifacts部分中的占位符 URI 替换为hello_world.py对象的 S3 URI。
选择创建组件。
在 com.example 上。 HelloWorld组件页面，验证组件的状态是否为 “可部署”。

上传你的 Hello World 组件

使用您的 S3 存储段Amazon Web Services 账户来托管Amazon IoT Greengrass组件工件。当您将组件部署到核心设备时，设备会从存储桶中下载该组件的工件。

您可以使用现有的 S3 存储桶，或运行以下命令创建存储桶。此命令使用您的Amazon Web Services 账户 ID 创建一个存储桶Amazon Web Services 区域，并形成一个唯一的存储段名称。将 123456789012 替换为你的Amazon Web Services 账户 ID 和区域Amazon Web Services 区域，替换为你在本教程中使用的。
```
aws s3 mb s3://greengrass-component-artifacts-123456789012-region
```
如果请求成功，该命令将输出以下信息。
```
make_bucket: greengrass-component-artifacts-123456789012-region
```
允许核心设备访问 S3 存储桶中的组件生命周期。

每个核心设备都有一个核心设备 IAM 角色，允许它与进行交互Amazon IoT并将日志发送到Amazon Web Services 云。默认情况下，此设备角色不允许访问 S3 存储桶，因此您必须创建并附加允许核心设备从 S3 存储桶检索组件工件的策略。

如果核心设备的角色已经允许访问 S3 存储桶，则可跳过这一步。否则，创建允许访问的 IAM 策略并将其附加到角色，如下所示：
1. 创建一个名为的文件component-artifact-policy.json，并将以下 JSON 复制到该文件中。该策略允许访问 S3 存储桶中的所有文件。将 DOC-EXAMPLE-BU CKET 替换为 S3 存储桶的名称。
```
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "s3:GetObject"
      ],
      "Resource": "arn:aws:s3:::DOC-EXAMPLE-BUCKET/*"
    }
  ]
}
```
2. 运行以下命令，从中的策略文档创建策略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 Resource Name (ARN)。在下一步中，您可以使用此 ARN 将此策略附加到核心设备角色。
3. 运行以下命令将策略附加到核心设备角色。将 GreenGrassv2TokenExchangeRole 替换为核心设备的角色名称。您在安装Amazon IoT Greengrass Core 软件时指定了此角色名称。将策略 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 存储桶的项目。

将 Hello World Python 脚本构件上传到 S3 存储桶。

运行以下命令将脚本上传到存储桶中Amazon IoT Greengrass核心上存在该脚本的相同路径。将 DOC-EXAMPLE-BU CKET 替换为 S3 存储桶的名称。

upload:如果请求成功，该命令会输出一行以开头。

将工件的 Amazon S3 URI 添加到组件配方中。

Amazon S3 URI 由存储桶名称和存储桶中构件对象的路径组成。您的脚本构件的 Amazon S3 URI 是您在上一步中将工件上传到的 URI。此 URI 应类似于以下示例。将 DOC-EXAMPLE-BU CKET 替换为 S3 存储桶的名称。


s3://DOC-EXAMPLE-BUCKET/artifacts/com.example.HelloWorld/1.0.0/hello_world.py

要将工件添加到配方中，请添加Artifacts包含具有 Amazon S3 URI 的结构的列表。

JSON


"Artifacts": [
  {
    "URI": "s3://DOC-EXAMPLE-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 Amazon 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://DOC-EXAMPLE-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://DOC-EXAMPLE-BUCKET/artifacts/com.example.HelloWorld/1.0.0/hello_world.py"
        }
      ]
    }
  ]
}

YAML


Artifacts:
  - URI: s3://DOC-EXAMPLE-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 Amazon 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://DOC-EXAMPLE-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://DOC-EXAMPLE-BUCKET/artifacts/com.example.HelloWorld/1.0.0/hello_world.py

在配方Amazon IoT Greengrass中创建组件资源。运行以下命令，从食谱创建组件，食谱是以二进制文件形式提供的。

如果请求成功，响应类似于以下示例。


{
  "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中的内容以在下一步中检查组件的状态。

注意

您还可以在Amazon IoT Greengrass控制台的组件页面上看到您的 Hello Worl d 组件。

验证组件是否已创建并准备好部署。创建组件时，其状态为REQUESTED。然后，Amazon 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 组件现已上线Amazon IoT Greengrass。你可以将其部署回这个 Greengrass 核心设备或其他核心设备。

步骤 6：部署您的组件

使用Amazon IoT Greengrass，您可以将组件部署到单个设备或设备组。部署组件时，在每台目标设备上Amazon IoT Greengrass安装并运行该组件的软件。您可以指定要部署的组件以及要为每个组件部署的配置更新。您还可以控制部署如何向部署目标设备推出。有关更多信息，请参阅将Amazon IoT Greengrass组件部署到设备：

在本节中，你将你的 Hello World 组件部署回你的 Greengrass 核心设备上。

在Amazon IoT Greengrass控制台导航菜单中，选择组件。
在组件页面的我的组件选项卡上，选择com.example.HelloWorld。
在com.example.HelloWorld页面上，选择部署。
从添加到部署中，选择创建新部署，然后选择下一步。
在 Specify tarts（指定目标）页面中，执行以下操作：
1. 在名称框中，输入 Deployment for MyGreengrassCore。
2. 对于部署目标，选择核心设备，然后Amazon IoT选择核心设备的名称。本教程的默认值是MyGreengrassCore。
3. 选择 Next（下一步）。
在选择组件页面的我的组件下，验证com.example.HelloWorld组件是否已选中，然后选择下一步。
在配置组件页面上 com.example.HelloWorld，选择并执行以下操作：
1. 选择配置组件。
2. 在 “配置更新” 下的 “要合并的配置” 中，输入以下配置。
```
{
  "Message": "universe"
}
```
  此配置更新将此部署中设备的 Hello WorldMessage 参数设置为。universe
3. 选择 Confirm（确认）。
4. 选择 Next（下一步）。
在配置高级设置页面上，保留默认配置设置，然后选择下一步。
在 Review（检查）页上，选择 Deploy（部署）。
验证部署是否成功完成。部署可能需要几分钟的时间才能完成。查看 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 存储桶检索对象，就会发生这种情况。在核心设备上运行以下命令以查看Amazon IoT Greengrass核心软件日志文件。此文件包含来自 Greengrass 核心设备部署服务的日志。
Linux or Unix

sudo tail -f /greengrass/v2/logs/greengrass.log

Windows Command Prompt (CMD)

type C:\greengrass\v2\logs\greengrass.log

该type命令将文件内容写入终端。多次运行此命令以观察文件中的变化。

PowerShell

gc C:\greengrass\v2\logs\greengrass.log -Tail 10 -Wait
有关更多信息，请参阅排除 Amazon IoT Greengrass V2 的故障：

部署你的 Hello World 组件

在您的开发计算机上，创建一个名为的文件，hello-world-deployment.json并将以下 JSON 复制到该文件中。此文件定义了要部署的组件和配置。
```
{
  "components": {
    "com.example.HelloWorld": {
      "componentVersion": "1.0.0",
      "configurationUpdate": {
        "merge": "{\"Message\":\"universe\"}"
      }
    }
  }
}
```
此配置文件指定部署您在之前1.0.0的过程中开发和发布的 Hello World 组件版本。configurationUpdate指定将组件配置合并到 JSON 编码的字符串中。此配置更新将此部署中设备的 Hello WorldMessage 参数设置为。universe

运行以下命令将组件部署到 Greengrass 核心设备。您可以部署到事物（即单个设备）或事物组（即设备组）。MyGreengrassCore替换为Amazon IoT核心设备的名称。

该命令将输出类似于以下示例的响应。


{
  "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"
}

验证部署是否成功完成。部署可能需要几分钟的时间才能完成。查看 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 存储桶检索对象，就会发生这种情况。在核心设备上运行以下命令以查看Amazon IoT Greengrass核心软件日志文件。此文件包含来自 Greengrass 核心设备部署服务的日志。
Linux or Unix

sudo tail -f /greengrass/v2/logs/greengrass.log

Windows Command Prompt (CMD)

type C:\greengrass\v2\logs\greengrass.log

该type命令将文件内容写入终端。多次运行此命令以观察文件中的变化。

PowerShell

gc C:\greengrass\v2\logs\greengrass.log -Tail 10 -Wait
有关更多信息，请参阅排除 Amazon IoT Greengrass V2 的故障：

后续步骤

你已经完成了本教程。Amazon IoT GreengrassCore 软件和你的 Hello World 组件在你的设备上运行。此外，您的 Hello World 组件可在Amazon IoT Greengrass云服务中部署到其他设备。有关本教程所探讨的主题的更多信息，请参阅以下文档：

Javascript 在您的浏览器中被禁用或不可用。

要使用 Amazon Web Services 文档，必须启用 Javascript。请参阅浏览器的帮助页面以了解相关说明。

教程

开发一个延迟组件更新的组件