AWS AWS IoT Greengrass V2 入门 - AWS IoT Greengrass
AWS 文档中描述的 AWS 服务或功能可能因区域而异。要查看适用于中国区域的差异,请参阅中国的 AWS 服务入门

本文属于机器翻译版本。若本译文内容与英语原文存在差异,则一律以英文原文为准。

AWS AWS IoT Greengrass V2 入门

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

  • 在 Linux 设备(如 Raspberry Pi)上安装和配置 AWS AWS IoT Greengrass 核心软件。此设备是一个 AWS AWS IoT Greengrass 核心设备。

  • 在 Greengrass 核心设备上开发 Hello World 组件。组件是在 Greengrass 核心设备上运行的软件模块。

  • 将该组件上传到 AWS 云中的 AWS AWS IoT Greengrass V2。

  • 将该组件从 AWS 云部署到 Greengrass 核心设备。

注意

本教程介绍如何设置开发环境和探索 AWS AWS IoT Greengrass 的功能。有关如何设置和配置生产设备的更多信息,请参阅设置 AWS AWS IoT Greengrass 核心设备

在本教程中,您可以预计花费 20-30 分钟。

Prerequisites

要完成本入门教程,您需要以下条件:

  • AWS 账户。如果没有,请参阅设置 AWS 账户

  • 具有管理员权限的 AWS AWS Identity and Access Management (IAM) 用户。

  • 具有 Internet 连接的 Windows、Mac 或类 Unix 的开发计算机。

  • 一台设备,具有 Linux 操作系统和与开发计算机相同的 Internet 连接。我们建议您将 Raspberry Pi 与 Raspberry Pi OS (以前称为 Raspbian) 结合使用。

  • 设备上安装了 Python 3.5 或更高版本。

  • AWS 命令行界面 (AWS CLI) 在您的开发计算机上和设备上安装并配置了凭证。有关更多信息,请参阅安装 AWS CLI配置 AWS CLI。

    • 最低 AWS CLI V1 版本v1

    • 最低 AWS CLI V2 版本v2

    注意

    如果您使用 Raspberry Pi 或其他 32-bit 设备,请安装 AWS CLI V1。AWS CLI V2 不适用于 32-bit ARM 设备。有关更多信息,请参阅安装、更新和卸载 AWS CLI 版本 1。

设置 环境

按照此部分中的步骤设置 Linux 设备以用作 AWS AWS IoT Greengrass 核心设备。这些步骤假定您将 Raspberry Pi 与 Raspberry Pi OS 结合使用。如果您使用不同的设备或操作系统,请参阅设备的相关文档。

为 AWS AWS IoT Greengrass V2 设置 Raspberry Pi

  1. 在 Raspberry Pi 上启用 SSH 以远程连接到它。有关更多信息,请参阅 Raspberry Pi 文档中的 SSH (安全外壳)。

  2. 查找 Raspberry Pi 的 IP 地址以使用 SSH 连接到它。为此,您可以在 Raspberry Pi 上运行以下命令。

    hostname -I
  3. 使用 SSH 连接到 Raspberry Pi。在您的开发计算机上,运行以下命令。Replace username 替换为要登录的用户的名称,并替换 pi-ip-address 替换为您在上一步中找到的 IP 地址。

    ssh username@pi-ip-address

    默认 Raspberry Pi 用户名和密码分别为 piraspberry

    重要

    如果您的开发计算机使用早期版本的 Windows,您可能没有 ssh 命令,或者您可能具有 ssh 但无法连接到 Raspberry Pi。要连接到您的 Raspberry Pi,您可以安装和配置 PuTTY这是一个免费的开源 SSH 客户端。请参阅 PuTTY 文档以连接到您的 Raspberry Pi。

  4. 安装 AWS AWS IoT Greengrass Core 软件运行所需的 Java 运行时。在 Raspberry Pi 上,运行以下命令以安装 Java 8。

    sudo apt install openjdk-8-jdk

    安装完成后,运行以下命令以验证 Java 是否在您的 Raspberry Pi 上运行。

    java -version

    命令将输出在设备上运行的 Java 版本。输出可能与以下示例类似。

    openjdk version "1.8.0_242" OpenJDK Runtime Environment (build 1.8.0_242-b08) OpenJDK 64-Bit Server VM (build 25.242-b08, mixed mode)

安装 AWS AWS IoT Greengrass 核心软件

按照此部分中的步骤将 Raspberry Pi 设置为可用于本地开发的 AWS AWS IoT Greengrass 核心设备。在本节中,您将下载并运行一个安装程序,该安装程序执行以下操作来为您的设备配置 AWS AWS IoT Greengrass 核心软件:

  • 安装 Greengrass 核心组件,这是唯一的必需组件,也是在设备上运行 AWS AWS IoT Greengrass Core 软件的最低要求。有关更多信息,请参阅 Greengrass 核心组件

  • 将设备注册为 AWS IoT IoT 事物并下载数字证书,以允许设备连接到 AWS。有关更多信息,请参阅AWS AWS IoT Greengrass 的设备身份验证和授权

  • 将设备的 AWS IoT IoT 事物添加到事物组,这是一组或一组 AWS IoT IoT 事物。事物组使您能够管理 Greengrass 核心设备的队列。当您将软件组件部署到您的设备时,您可以选择部署到单个设备或一组设备。有关更多信息,请参阅 AWS IoT IoT Core 开发人员指南》中的“使用 AWS AWS IoT 管理设备”。

  • 创建允许 Greengrass 核心设备与 AWS 服务交互的 IAM 角色。默认情况下,此角色允许您的设备与 AWS IoT IoT 交互并将日志发送到 Amazon CloudWatch Logs。有关更多信息,请参阅授权核心设备与 AWS 服务交互

  • 安装 AWS AWS IoT Greengrass 命令行界面 (greengrass-cli),您可以使用该界面来测试您在核心设备上开发的自定义组件。有关更多信息,请参阅Greengrass 命令行界面

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

  1. 在您的 AWS AWS IoT Greengrass 核心设备(Raspberry Pi)上,运行以下命令以切换到主目录。

    cd ~
  2. 运行以下命令以下载 AWS AWS IoT Greengrass 核心软件。

    curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip

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

  3. 运行以下命令以解压缩软件并删除 ZIP 文件。Replace GreengrassCore 替换为目标文件夹的名称。

    unzip greengrass-nucleus-latest.zip -d GreengrassCore && rm greengrass-nucleus-latest.zip
  4. 提供您的 AWS 凭证,以便安装程序可以为您的核心设备预置 AWS AWS IoT 和 IAM 资源。为了提高安全性,您可以获取 IAM 角色的凭证,该角色仅允许预置所需的最低权限。有关更多信息,请参阅安装程序预配置资源所需的最小 IAM 策略

    执行以下操作之一来检索凭证并将凭证提供给 AWS AWS IoT Greengrass 核心软件:

    • 使用 IAM 用户的长期凭证:

      1. 为您的 IAM 用户提供访问密钥 ID 和秘密访问密钥。有关如何检索长期凭证的更多信息,请参阅 IAM 用户指南中的管理 IAM 用户的访问密钥。

      2. 运行以下命令以向 AWS AWS IoT Greengrass 核心软件提供凭证。

        export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
    • (推荐)使用来自 IAM 角色的临时安全凭证:

      1. 提供您担任的 IAM 角色的访问密钥 ID、秘密访问密钥和会话令牌。有关如何检索这些凭证的更多信息,请参阅 IAM 用户指南 中的将临时安全凭证与 AWS CLI 结合使用。

      2. 运行以下命令以向 AWS AWS IoT Greengrass 核心软件提供凭证。

        export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY export AWS_SESSION_TOKEN=AQoDYXdzEJr1K...o5OytwEXAMPLE=

    AWS AWS IoT Greengrass 核心软件不会保存或存储您的凭证。

  5. 运行以下命令以启动 AWS AWS IoT Greengrass 核心软件安装程序。如果您的核心设备具有 systemd,则此命令会将软件作为在启动时运行的系统服务进行安装。此命令还指定 使用ggc_user系统用户和ggc_group系统组在核心设备上运行软件组件。安装程序将为您创建此默认用户和组。替换命令中的参数值,如下所示。

    1. /greengrass/v2:将 替换为用于安装 AWS AWS IoT Greengrass 核心软件的根文件夹的路径。

    2. GreengrassCore:如果您将安装程序解压缩到其他文件夹,请将此值替换为要使用的文件夹。

    3. region:将 替换为要在其中查找或创建资源的 AWS 区域。

    4. MyGreengrassCore:将 替换为 Greengrass 核心设备的 AWS AWS IoT 事物的名称。如果事物不存在,安装程序将创建它。安装程序下载证书以作为 AWS IoT IoT 事物进行身份验证。

    5. MyGreengrassCoreGroup:将 替换为 Greengrass 核心设备的 AWS AWS IoT 事物组的名称。如果事物组不存在,安装程序将创建它并将事物添加到它。如果事物组存在并且具有活动部署,核心设备将下载并运行该部署指定的软件。

    6. MyGreengrassV2TokenExchangeRole:将 替换为允许 Greengrass 核心设备获取临时 AWS 凭证的 IAM 角色的名称。如果该角色不存在,安装程序将创建它并创建和附加名为 的策略MyGreengrassV2TokenExchangeRoleAccess。有关更多信息,请参阅授权核心设备与 AWS 服务交互

    7. MyGreengrassCoreTokenExchangeRoleAlias:将 替换为允许 Greengrass 核心设备稍后获取临时凭证的 IAM 角色的别名。如果角色别名不存在,安装程序将创建别名并将其指向您指定的 IAM 角色。有关更多信息,请参阅授权核心设备与 AWS 服务交互

    sudo -E java -Droot="/greengrass/v2" -Dlog.store=FILE \ -jar ./GreengrassCore/lib/Greengrass.jar \ --aws-region region \ --thing-name MyGreengrassCore \ --thing-group-name MyGreengrassCoreGroup \ --tes-role-name MyGreengrassV2TokenExchangeRole \ --tes-role-alias-name MyGreengrassCoreTokenExchangeRoleAlias \ --component-default-user ggc_user:ggc_group \ --provision true \ --setup-system-service true \ --deploy-dev-tools true
    注意

    如果您在内存有限的设备上运行 AWS AWS IoT Greengrass,则可以控制 AWS IoT IoT Greengrass Core 软件使用的内存量。要控制内存分配,您可以在 Ambda 组件的 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
    注意

    如果您的系统没有 systemd,则安装程序不会将软件设置为系统服务,并且您不会看到该成功消息。

  6. 部署本地开发工具可能需要一分钟的时间。您可以运行以下命令来检查部署的状态。Replace MyGreengrassCore 替换为核心设备的名称。

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

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

    /greengrass/v2/bin/greengrass-cli help

    命令输出 Greengrass CLI 的帮助信息。如果greengrass-cli未找到 ,则部署可能无法安装 Greengrass CLI。有关更多信息,请参阅Troubleshooting

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

    • Replace region 替换为您使用的区域。

    • Replace account-id 替换为您的 AWS 账户 ID。

    • Replace 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.0.3" } }'
    Windows (CMD)
    aws greengrassv2 create-deployment ^ --target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" ^ --components "{\"aws.greengrass.Cli\":{\"componentVersion\":\"2.0.3\"}}"
    Windows (PowerShell)
    aws greengrassv2 create-deployment ` --target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" ` --components '{\"aws.greengrass.Cli\":{\"componentVersion\":\"2.0.3\"}}'
    提示

    您可以将 /greengrass/v2/bin 添加到要运行PATH的环境变量greengrass-cli,而无需其绝对路径。

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

    Successfully set up Nucleus as a system service

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

    1. 运行以下命令以运行 软件。

      sudo /greengrass/v2/alts/current/distro/bin/loader

      如果成功启动,软件将输出以下消息。

      Launched Nucleus successfully.
    2. 您必须保持当前终端会话打开,以使 AWS IoT IoT Greengrass 核心软件保持运行状态。在您的开发计算机上,运行以下命令以打开第二个 SSH 会话,您可以使用它在核心设备上运行其他命令。Replace username 替换为要登录的用户的名称,并替换 pi-ip-address 替换为设备的 IP 地址。

      ssh username@pi-ip-address

    有关如何与 Greengrass 系统服务交互的更多信息,请参阅将 AWS AWS IoT Greengrass 配置为系统服务

AWS AWS IoT Greengrass 核心软件和本地开发工具在您的设备上运行。接下来,您可以在设备上开发 Hello World AWS AWS IoT Greengrass 组件。

创建您的第一个组件

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

  • 诀窍

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

    您可以定义 JSONYAML 格式的配方。

  • Artifacts

    组件可以具有任意数量的构件,即组件二进制文件。构件可以包括脚本、编译代码、静态资源以及组件使用的任何其他文件。组件还可以使用组件依赖项中的构件。

借助 AWS AWS IoT Greengrass,您可以在 Greengrass 核心设备上开发和测试组件,而无需与 AWS 云交互。完成组件后,您可以将其上传到 AWS IoT IoT Greengrass 以将其部署到其他设备。有关更多信息,请参阅管理 AWS IoT IoT Greengrass 组件

在本节中,您将了解如何创建和运行基本 Hello World 组件。

创建 Hello World 组件

  1. 在您的 Greengrass 核心设备上,运行以下命令以更改为 AWS AWS IoT Greengrass 安装文件夹以用于本地开发。Replace ~/GreengrassCore 替换为安装文件夹的路径。

    cd ~/GreengrassCore
  2. AWS AWS IoT Greengrass 期望组件配方和构件位于单独的文件夹中。

    运行以下命令为组件配方创建文件夹。

    mkdir recipes
  3. 运行以下命令以创建配方文件并在文本编辑器中打开该文件。

    JSON
    nano recipes/com.example.HelloWorld-1.0.0.json
    YAML
    nano recipes/com.example.HelloWorld-1.0.0.yaml

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

    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}'" } } ] }
    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}'

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

  4. 运行以下命令为组件构件创建文件夹。

    mkdir -p artifacts/com.example.HelloWorld/1.0.0
    重要

    构件文件夹路径必须使用以下格式。包括您在配方中指定的组件名称和版本。

    artifacts/componentName/componentVersion/
  5. 运行以下命令以创建 Python 脚本构件文件并在文本编辑器中打开该文件。

    nano artifacts/com.example.HelloWorld/1.0.0/hello_world.py

    将以下 Python 脚本粘贴到 文件中。

    import sys import datetime message = f"Hello, {sys.argv[1]}! Current time: {str(datetime.datetime.now())}." # Print the message to stdout. print(message) # Append the message to the log file. with open('/tmp/Greengrass_HelloWorld.log', 'a') as f: print(message, file=f)

    此 Python 脚本将 hello 消息和当前时间记录到 /tmp/Greengrass_HelloWorld.log

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

    运行以下命令以将 组件部署到 AWS AWS IoT Greengrass 核心。Replace /greengrass/v2 替换为您的 AWS AWS IoT Greengrass V2 根文件夹,并替换 ~/GreengrassCore 替换为您的 AWS AWS IoT Greengrass V2 安装文件夹。

    sudo /greengrass/v2/bin/greengrass-cli deployment create \ --recipeDir ~/GreengrassCore/recipes \ --artifactDir ~/GreengrassCore/artifacts \ --merge "com.example.HelloWorld=1.0.0"

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

  7. 运行以下命令以验证 Hello World 组件是否运行并记录消息。

    tail -f /tmp/Greengrass_HelloWorld.log

    您应看到类似于以下示例的消息。

    Hello, world! Current time: 2020-11-30 17:48:59.153933.
    注意

    如果 tail 命令告诉您该文件不存在,则可能尚未完成本地部署。如果文件在 15 秒内不存在,则部署可能会失败。例如,如果您的配方无效,则可能会发生这种情况。运行以下命令以查看 AWS IoT IoT Greengrass 核心日志文件。此文件包括 Greengrass 核心设备的部署服务的日志。

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

    您还可以查看 Hello World 组件的日志文件。

    sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log

    有关更多信息,请参阅Troubleshooting

  8. 修改本地组件以迭代和测试代码。

    运行以下命令编辑 hello_world.py

    nano artifacts/com.example.HelloWorld/1.0.0/hello_world.py
  9. 在第 5 行添加以下代码,以编辑 AWS AWS IoT Greengrass 核心日志的消息。

    message += " Greetings from your first Greengrass component."

    hello_world.py 脚本现在应具有以下内容。

    import sys import datetime message = f"Hello, {sys.argv[1]}! Current time: {str(datetime.datetime.now())}." message += " Greetings from your first Greengrass component." # Print the message to stdout. print(message) # Append the message to the log file. with open('/tmp/Greengrass_HelloWorld.log', 'a') as f: print(message, file=f)
  10. 运行以下命令以使用您的更改更新组件。

    sudo /greengrass/v2/bin/greengrass-cli deployment create \ --recipeDir ~/GreengrassCore/recipes \ --artifactDir ~/GreengrassCore/artifacts \ --merge "com.example.HelloWorld=1.0.0"

    此命令将最新的 Hello World 构件应用于 AWS AWS IoT Greengrass 核心运行时。

  11. 运行以下命令以重新启动 组件。当您重新启动组件时,核心设备将使用最新的更改。

    sudo /greengrass/v2/bin/greengrass-cli component restart \ --names "com.example.HelloWorld"
  12. 再次检查日志,验证 Hello World 组件是否输出了新消息。

    tail -f /tmp/Greengrass_HelloWorld.log

    您应看到类似于以下示例的消息。

    Hello, world! Current time: 2020-11-30 17:48:59.153933. Greetings from your first Greengrass component.
  13. 您可以更新组件的配置参数以测试不同的配置。部署组件时,您可以指定配置更新,这定义了如何在核心设备上修改组件的配置。您可以指定要重置为默认值的配置值以及要合并到核心设备上的新配置值。有关更多信息,请参阅更新组件配置

    执行以下操作:

    1. 创建一个名为 的文件hello-world-config-update.json以包含配置更新。

      nano hello-world-config-update.json
    2. 将以下 JSON 对象复制到 文件中。此 JSON 对象定义将值合并friendMessage 参数以更新其值的配置更新。此配置更新不指定要重置的任何值。您不需要重置 Message 参数,因为合并更新将替换现有值。

      { "com.example.HelloWorld": { "MERGE": { "Message": "friend" } } }
    3. 运行以下命令以将配置更新部署到 Hello World 组件。

      sudo /greengrass/v2/bin/greengrass-cli deployment create \ --merge "com.example.HelloWorld=1.0.0" \ --update-config hello-world-config-update.json
    4. 再次检查日志,验证 Hello World 组件是否输出了新消息。

      tail -f /tmp/Greengrass_HelloWorld.log

      您应看到类似于以下示例的消息。

      Hello, friend! Current time: 2020-11-30 17:48:59.153933. Greetings from your first Greengrass component.
  14. 完成组件测试后,请从核心设备中删除组件。在将组件上传到 AWS AWS IoT Greengrass 后,您需要执行此操作以将其部署回核心设备。否则,部署将失败并出现版本兼容性错误,因为本地部署指定了组件的不同版本。运行以下命令。

    sudo /greengrass/v2/bin/greengrass-cli deployment create --remove="com.example.HelloWorld"

Hello World 组件已完成,您现在可以将其上传到 AWS AWS IoT Greengrass 服务。然后,您可以将该组件部署到 AWS IoT IoT Greengrass 核心设备。

上传组件

完成组件后,您可以将其上传到 AWS 云中的 AWS AWS IoT Greengrass 服务。AWS AWS IoT Greengrass 提供组件管理服务来托管您的组件,以便您可以将这些组件部署到单独的设备或设备队列。要将组件上传到 AWS AWS IoT Greengrass,请完成以下步骤:

  • 将组件构件上传到 S3 存储桶。

  • 将每个构件的 sAmazon Simple Storage Service ( Amazon S3 URI 添加到组件配方。

  • 从组件配方在 AWS AWS IoT Greengrass 中创建组件。

在本节中,您将在 AWS IoT IoT Greengrass 核心设备上完成以下步骤,以将 Hello World 组件上传到 AWS AWS IoT Greengrass。

上传 Hello World 组件

  1. 使用您的 AWS 账户中的 S3 存储桶托管 AWS AWS IoT Greengrass 组件构件。当您将组件部署到核心设备时,设备将从 存储桶下载组件的构件。

    您可以使用现有的 S3 存储桶,或运行以下命令来创建存储桶。此命令使用您的 AWS 账户 ID 和 AWS 区域创建存储桶,以形成唯一的存储桶名称。Replace 123456789012 使用您的 AWS 账户 ID 和 region 与您在本教程中使用的 AWS 区域。

    aws s3 mb s3://greengrass-component-artifacts-123456789012-region

    如果请求成功,此命令将输出以下信息。

    make_bucket: greengrass-component-artifacts-123456789012-region
  2. 允许核心设备访问 S3 存储桶中的组件构件。每个核心设备都有一个核心设备 IAM 角色,允许它与 AWS IoT IoT 交互并将日志发送到 AWS 云。默认情况下,此设备角色不允许访问 S3 存储桶,因此您必须创建并附加一个策略,该策略允许核心设备从 S3 存储桶检索组件构件。

    如果您的设备的角色已允许访问 S3 存储桶,则可以跳过此步骤。否则,请创建一个允许访问的 IAM 策略并将其附加到角色,如下所示:

    1. 创建一个名为 的文件component-artifact-policy.json,并将以下 JSON 复制到该文件中。此策略允许访问您在上一步中创建的 S3 存储桶中的所有文件。Replace DOC-EXAMPLE-BUCKET 替换为要使用的 存储桶的名称。

      { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "s3:GetObject" ], "Resource": "arn:aws:s3:::DOC-EXAMPLE-BUCKET/*" } ] }
    2. 运行以下命令以从 中的策略文档创建策略component-artifact-policy.json

      aws iam create-policy \ --policy-name MyGreengrassV2ComponentArtifactPolicy \ --policy-document file://component-artifact-policy.json

      从输出中的策略元数据复制策略 Amazon 资源名称 (ARN)。在下一步中,您将使用此 ARN 将此策略附加到核心设备角色。

    3. 运行以下命令,将 策略附加到核心设备角色。Replace MyGreengrassV2TokenExchangeRole 替换为您在运行 AWS AWS IoT Greengrass 核心软件时指定的角色的名称。将策略 ARN 替换为上一步中的 ARN。

      aws iam attach-role-policy \ --role-name MyGreengrassV2TokenExchangeRole \ --policy-arn arn:aws:iam::123456789012:policy/MyGreengrassV2ComponentArtifactPolicy

      如果命令没有输出,则成功,并且您的核心设备可以访问您上传到此 S3 存储桶的构件。

  3. 将 Hello World Python 脚本构件上传到 S3 存储桶。运行以下命令以将脚本上传到 AWS AWS IoT Greengrass 核心上存在脚本的 存储桶中的相同路径。Replace DOC-EXAMPLE-BUCKET 替换为 S3 存储桶的名称。

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

    如果请求成功, 命令将输出以 upload: 开头的行。

  4. 将构件的 Amazon S3 URI 添加到组件配方。Amazon S3 URI 由存储桶名称和存储桶中构件对象的路径组成。脚本构件的 Amazon S3 URI 是在上一步中将构件上传到 的 URI。此 URI 应类似于以下示例。Replace DOC-EXAMPLE-BUCKET 替换为 S3 存储桶的名称。

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

    要将构件添加到配方,请添加包含结构以及 Amazon S3 URI Artifacts 的 的列表。

    JSON
    "Artifacts": [ { "URI": "s3://DOC-EXAMPLE-BUCKET/artifacts/com.example.HelloWorld/1.0.0/hello_world.py" } ]

    运行以下命令以打开配方文件。

    nano recipes/com.example.HelloWorld-1.0.0.json

    将构件添加到配方。您的配方文件应类似于以下示例。

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

    运行以下命令以打开配方文件。

    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://DOC-EXAMPLE-BUCKET/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
  5. 在 AWS 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 AWS IoT Greengrass 控制台的 Components (组件) 页面上查看 Hello World 组件

  6. 验证组件是否创建并准备好进行部署。创建组件时,其状态为 REQUESTED。然后 AWS IoT 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 AWS IoT Greengrass 中可用。您可以将它部署回此 Greengrass 核心设备或其他核心设备。

部署组件

借助 AWS AWS IoT Greengrass,您可以将组件部署到单个设备或一组设备。当您部署组件时 AWS IoT IoT Greengrass 会在每个目标设备上安装并运行该组件的软件。您可以指定要部署的组件以及要为每个组件部署的配置更新。您还可以控制部署如何推广到部署目标的设备。有关更多信息,请参阅将 AWS AWS IoT Greengrass 组件部署到设备

在本节中,您将 Hello World 组件部署回 AWS AWS IoT Greengrass 核心设备。

部署 Hello World 组件

  1. 在您的开发计算机上,创建一个名为 的文件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 World Message 参数设置为 universe

  2. 运行以下命令以将 组件部署到 Greengrass 核心设备。您可以将 部署到事物(即单个设备)或事物组(即设备组)。Replace MyGreengrassCore 替换为核心设备的 AWS IoT IoT 事物的名称。

    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" }
  3. 验证部署是否成功完成。完成部署可能需要几分钟时间。检查 Hello World 日志以验证更改。在 Greengrass 核心设备上运行以下命令。

    tail -f /tmp/Greengrass_HelloWorld.log

    您应看到类似于以下示例的消息。

    Hello, universe! Current time: 2020-11-30 18:18:59.153933. Greetings from your first Greengrass component.
    注意

    如果日志消息未更改,则部署失败或没有到达核心设备。如果核心设备未连接到 Internet 或没有权限从 S3 存储桶检索构件,则可能会发生这种情况。在核心设备上运行以下命令以查看 AWS IoT IoT Greengrass 核心软件日志文件。此文件包括 Greengrass 核心设备的部署服务的日志。

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

    有关更多信息,请参阅Troubleshooting

您已完成本教程。AWS AWS IoT Greengrass 核心软件和 Hello World 组件在您的设备上运行。此外,您的 Hello World 组件可在 AWS AWS IoT Greengrass 部署到其他设备。有关本教程探索的主题的更多信息,请参阅以下内容: