使用 AWS IoT Greengrass 2.0 和 Docker 部署和管理 ROS 机器人

Original URL：https://aws.amazon.com/blogs/robotics/deploy-and-manage-ros-robots-with-aws-iot-greengrass-2-0-and-docker/

为一组自主机器人部署和管理软件是一项复杂、耗时且容易出错的任务。机器人制造商面临着防止软件部署期间出现中断的挑战。挑战包括建立与机器人的安全通信层、监控部署状态以及实施故障弹性逻辑。此外，机器人制造商通常还会投入时间和资金，对部署其设备软件所需的技术进行集成，这就延缓了上市时间并减少了利润。一旦部署，软件需要大量的开发工作才能收集可靠的数据、监控机队和构建控制面板，以便操作员能够与机器人互动、排除问题并应对现场情况。机器人机队的管理存在限制，这会导致由硬件或软件故障引起的运营中断。这些中断可能导致运营停顿，使机器人运营商每年损失数百万美元。

在本博客中，我们介绍了一种使用 AWS IoT Greengrass 2.0 在生产机队上大规模部署和管理机器人软件的新方法。当与机器人操作系统 2（ROS2）的行业级工具、库和功能相结合时，开发人员可以将新的云增强型机器人功能推向市场，并减少构建故障弹性基础设施所需的时间和精力。

AWS IoT Greengrass 2.0 简介

AWS IoT Greengrass 2.0 是一项开源边缘运行时和云服务，可降低在机器人上部署和管理应用程序时的复杂性。借助 AWS IoT Greengrass 2.0，开发人员可以为其机器人机队添加本地计算、消息收发和数据管理功能。这有助于开发人员可靠地部署更新、远程管理软件以及将机器人安全地连接到云服务。您可以使用 AWS IoT Greengrass 2.0 来：

远程管理机器人上的应用程序生命周期（安装、运行和关闭）
通过无线方式将软件更新部署到机器人机队
将机器人安全地连接到面向操作员的控制面板和监控工具
部署机器学习（ML）模型并在边缘运行 ML 推理，以执行对象检测和图像分类等任务
将大量原始遥测、传感器数据和日志提取到基于云的流处理服务（如 Amazon Kinesis）

在下文中，我们将通过使用与云连接的 ROS2 Foxy 示例应用程序的详细分步教程，向您展示如何实施安全、可靠且可自定义的应用程序管理工作流。

使用 AWS IoT Greengrass 2.0 部署 ROS 应用程序

AWS IoT Greengrass 2.0 通过称为组件的模块化独立单元管理在机器人上运行的代码。组件可以代表应用程序、运行时安装程序、库或任何代码，包括 ROS 应用程序和/或容器。它们是使用基于 YAML 或 JSON 的方案定义的，开发人员可以在其中设置配置参数、依赖项和生命周期操作，以安装、运行、启动、关闭和恢复组件。 AWS IoT Greengrass 2.0 还管理组件访问云中 AWS 资源的权限。这使机器人上运行的应用程序能够连接到用于云对象存储的 Amazon S3 或用于实时数据流传输和摄取的 Amazon Kinesis 等服务。最后，AWS IoT Greengrass 2.0 提供了各种预构建的公共组件。这些组件加速了通用功能的开发，如集中式日志捕获，以及对机器人的远程安全隧道会话管理，而无需任何额外的开发工作。

为了大规模管理组件并将其部署到机器人机队，AWS IoT Greengrass 2.0 使用了 AWS IoT Device Management 提供的设备注册表功能。开发人员可以将机器人类型、硬件配置和软件版本等可搜索元数据应用于单个机器人或机器人组，然后根据此配置运行部署操作。

在 AWS IoT 中注册的机器人可以有一个或多个基于 JSON 的状态对象，称为设备影子。设备影子在机器人和云之间同步，使分离的应用程序即使在断开连接的情况下也能与机器人状态进行交互。可以使用 AWS IoT Device Management 为设备影子编制索引。然后，机器人操作员和工程师能够对成千上万甚至数百万台机器人机队中的局部条件进行筛选、监控和预警。检索的结果包括电池状况、任务状态、位置或惯性测量单元（IMU）数据。机器人元数据和设备影子可通过 AWS IoT API/SDK 获得，并可与自定义机队管理和面向操作员的应用程序集成。您可以使用设备影子和公共组件库来构建丰富的云增强型机器人应用程序。

教程：使用 AWS IoT Greengrass 2.0 构建、打包、部署和运行连接云的 ROS 应用程序

在本分步演练中，您将学习如何使用 Docker 和 AWS IoT Greengrass 2.0 构建和运行连接云的 ROS 2 Foxy 应用程序。我们将向您展示如何使用 AWS IoT Greengrass 2.0 部署和运行应用程序。最后，我们将展示如何通过 MQTT 将机器人连接到分离的应用程序，如在云中运行的面向操作员的控制面板。以下架构图显示了您在本教程中构建的内容：

基于 Docker 和 AWS Greengrass 2.0 的 ROS2 示例应用程序架构

该应用程序使用 Docker Compose 文件运行三个容器。其中两个容器（talker 和 listener）使用本地 ROS 消息收发通过 ROS 主题 /chatter 发送和接收“Hello World”消息。第三个容器使用 AWS IoT Greengrass 开发工具包将通过 ROS 主题 /chatter 发布的消息与 AWS IoT Greengrass 使用的本地套接字桥接起来，用于组件之间的进程间通信。然后，AWS IoT Greengrass 通过一个名为 chatter 的 MQTT 主题在云中收发消息。

本教程包含以下步骤：

背景：使用 Docker 构建和运行 ROS 应用程序
步骤 1：准备基于 Docker 的 ROS 2 示例应用程序进行部署
步骤 2：安装和预置 AWS IoT Greengrass 2.0
步骤 3：在 AWS IoT Greengrass 2.0 中创建示例应用程序组件
步骤 4：使用 AWS IoT Greengrass 2.0 部署示例应用程序组件

先决条件：本教程使用 AWS RoboMaker 集成式开发环境（IDE）进行开发。您也可以在自己的基于 Linux 的计算机上进行本地开发。如果您在本地计算机上开发，请确保安装 AWS CLI 并按照这些说明配置具有管理权限的 AWS 配置文件。

背景：使用 Docker 构建和运行 ROS 应用程序

使用 Docker 构建和运行 ROS 应用程序可以在机器人代码的设计、开发和操作方面提供多种好处。使用 Docker 容器，开发人员可以将其 ROS 堆栈作为一组微服务运行，并将应用程序组件与底层主机的配置分离。这确保了各种类型的机器人、软件版本和硬件堆栈在运行时的一致性。例如，团队可以运行 ROS 的多个发行版，并在 ROS 1 和 ROS 2 之间无缝桥接。在容器中运行 ROS 微服务还使开发人员能够在容器和底层主机之间建立资源隔离边界。这可以防止应用程序故障或失控进程影响其他容器和/或主机，使开发人员能够构建和编排弹性应用程序优先级和恢复逻辑。

Docker 还在无线更新软件时提供优化。Docker 映像是用于创建容器的只读模板，以层形式存储在本地文件系统上。通用层在容器映像之间共享，只能下载和存储文件一次。因此，当通过无线方式部署新更新时，仅部署更新的层。优化 Docker 映像层后，开发人员可以减少带宽消耗并缩短更新操作的持续时间。要了解有关 Docker 基元和设计模式的更多信息，请单击此处。ROS 社区还有专门的工具，用于使用 Docker 构建 ROS 应用程序。要了解有关这些工具的更多信息，请单击此处。

在本教程中，我们将使用 Docker 构建、打包和运行 ROS2 Foxy 示例应用程序。

步骤 1：准备基于 Docker 的 ROS 2 示例应用程序进行部署

打开 AWS 管理控制台并搜索 AWS RoboMaker。在 AWS RoboMaker 控制台主页面上，单击 Development Environments（开发环境），然后按 Create development environment（创建开发环境）。
在配置页面中，为 IDE 命名，然后选择 ROS 2 Foxy（Latest）[ROS 2 Foxy（最新）] 作为预安装的 ROS 发行版。在联网部分中，保留 VPC 和子网作为默认值。

现在，您的浏览器中应该正在运行一个新的 AWS RoboMaker 开发环境。接下来，通过在 IDE 终端窗口中运行以下命令来克隆示例应用程序代码：
```
git clone https://github.com/aws-samples/greengrass-v2-docker-ros-demo.git
```

接下来，查看两个分别名为 Dockerfile 和 docker-compose.yaml 的配置文件。在 Dockerfile 中，您将看到每个构建阶段的说明，以及我们将部署的最终运行时映像。Docker Compose 文件将在运行时编排容器的实施。

深入了解：Docker 资产

Dockerfile 是用于构建 Docker 映像的指令集。此示例将多阶段构建和集成缓存与 Docker BuildKit 结合使用。多阶段构建允许工作流采用单独的构建步骤，防止将额外的源文件或构建文件复制到最终的运行时 Docker 映像中。缓存操作通过存储以前构建的文件可以加快未来的构建速度。要了解有关 Docker BuildKit 的更多信息，请单击此处。

标题：ROS2 示例应用程序的 Dockerfile：

# 设置主参数。
ARG ROS_DISTRO=foxy
ARG LOCAL_WS_DIR=workspace

# ==== ROS 构建阶段 ====
# ==== 基础 ROS 构建映像 ====
FROM ros:${ROS_DISTRO}-ros-base AS build-base
LABEL component="com.example.ros2.demo"
LABEL build_step="ROSDemoNodes_Build"

RUN apt-key adv --keyserver keyserver.ubuntu.com --recv-keys F42ED6FBAB17C654
RUN apt-get update && apt-get install python3-pip -y
RUN apt-get update && apt-get install ros-$ROS_DISTRO-example-interfaces
RUN python3 -m pip install awsiotsdk

# ==== 软件包 1：ROS Demos Talker/Listener ====
FROM build-base AS ros-demos-package
LABEL component="com.example.ros2.demo"
LABEL build_step="DemoNodesROSPackage_Build"

# 从 ROS Demos monorepo 内克隆 demos_ros_cpp 软件包。
RUN mkdir -p /ws/src
WORKDIR /ws
RUN git clone https://github.com/ros2/demos.git \
    -b $ROS_DISTRO \
    --no-checkout \
    --depth 1 \
    --filter=blob:none \
    src/demos

RUN cd src/demos && \
    git sparse-checkout set demo_nodes_cpp

RUN . /opt/ros/$ROS_DISTRO/setup.sh && \
    colcon build --build-base workspace/build --install-base /opt/ros_demos

# ==== 程序包 2：Greengrass Bridge Node ====
FROM build-base AS greengrass-bridge-package
LABEL component="com.example.ros2.demo"
LABEL build_step="GreengrassBridgeROSPackage_Build"

ARG LOCAL_WS_DIR
COPY ${LOCAL_WS_DIR}/src /ws/src
WORKDIR /ws

# 缓存 colcon 构建目录。
RUN --mount=type=cache,target=${LOCAL_WS_DIR}/build:/ws/build \
    . /opt/ros/$ROS_DISTRO/setup.sh && \
    colcon build \
     --install-base /opt/greengrass_bridge

# ==== ROS 运行时映像（包含两个程序包） ====
FROM build-base AS runtime-image
LABEL component="com.example.ros2.demo"
COPY --from=ros-demos-package /opt/ros_demos /opt/ros_demos
COPY --from=greengrass-bridge-package /opt/greengrass_bridge /opt/greengrass_bridge

# 将应用程序源文件添加到入口点。
WORKDIR /
COPY app_entrypoint.sh /app_entrypoint.sh
RUN chmod +x /app_entrypoint.sh
ENTRYPOINT ["/app_entrypoint.sh"]

Docker Compose 是一种用于定义和运行多容器 Docker 应用程序的工具。今天，我们将使用 Docker Compose 构建 Docker 映像，然后在机器人上运行三个示例应用程序容器（talker、listener 和 AWS IoT Greengrass bridge）。要了解有关 Docker Compose 的更多信息，请单击此处。

在 Docker Compose 文件中，记下 greengrass_bridge 服务定义中定义的环境变量和卷。这些变量从 AWS IoT Greengrass 传递，指定用于进程间通信的套接字的位置以及所需的凭证。我们使用 AWS IoT Greengrass 进程间通信，通过 MQTT 将消息重新发布到云端。有关使用 AWS IoT Greengrass 2.0 配置 Docker 容器的更多信息，请单击此处。

标题：ROS2 示例应用程序的 Docker Compose 文件。

version: "3"
services:
greengrass_demo_image:

build:
  context: ./
  image: ros-foxy-greengrass-demo:latest

talker:
  image: ros-foxy-greengrass-demo:latest
  command: ros2 run demo_nodes_cpp talker
  
listener:
  image: ros-foxy-greengrass-demo:latest
  command: ros2 run demo_nodes_cpp listener

greengrass_bridge:
  image: ros-foxy-greengrass-demo:latest
  command: ros2 launch greengrass_bridge greengrass_bridge.launch.py ros_topics:="['chatter']" iot_topics:="['cloud_chatter']"
  environment:
    - AWS_REGION
    - SVCUID
    - AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT
    - AWS_CONTAINER_AUTHORIZATION_TOKEN
    - AWS_CONTAINER_CREDENTIALS_FULL_URI
  volumes:
    - "/greengrass/v2/ipc.socket:/greengrass/v2/ipc.socket"

现在，在终端中运行以下命令来安装 Docker Compose 并运行构建操作。

# 安装 Docker Compose
sudo curl -L "https://github.com/docker/compose/releases/download/1.29.1/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

# 构建映像
cd ~/environment/greengrass-v2-docker-ros-demo
DOCKER_BUILDKIT=1 docker-compose build

构建完成后，在终端中运行 docker images 命令，确认已成功构建该映像。您应该会看到一个名为“ros-foxy-greengrass-demo”。标题：docker images 命令结果 的内置容器映像

使用 AWS 管理控制台打开一个新选项卡或窗口。在这个新窗口中，打开 Amazon Elastic Container Registry（Amazon ECR）。我们将把前面步骤中创建的两个映像推送到 Amazon ECR 中。接下来，按 Create Repository（创建存储库）。

在向导中，将容器映像的名称设置为 ros-foxy-greengrass-demo，然后按 Create repository（创建存储库）。

完成后，Amazon ECR 中的存储库列表应显示为这样：

单击新存储库旁边的单选图标，然后按 View push commands（查看推送命令）按钮。

这将打开一个弹出窗口，其中包含一组要在 AWS RoboMaker IDE 终端中运行的推送命令。保持此窗口处于打开状态，返回 AWS RoboMaker IDE，然后运行弹出窗口中显示的推送命令。由于我们已经构建了 Docker 映像，请跳过推送命令列表中的第 2 个命令（“docker build -t ros-foxy-greengrass-demo”）。要在终端（弹出窗口中）运行的一组命令应类似于以下示例，只不过示例中包含您的 AWS 账户 ID 和区域。
```
aws ecr get-login-password —region <REGION> | docker login —username AWS —password-stdin <ACCOUNT_ID>.dkr.ecr.<REGION>.amazonaws.com

docker tag ros-foxy-greengrass-demo:latest <ACCOUNT_ID>.dkr.ecr.<REGION>.amazonaws.com/ ros-foxy-greengrass-demo:latest

docker push <ACCOUNT_ID>.dkr.ecr.<REGION>.amazonaws.com/ros-foxy-greengrass-demo:latest
```

祝贺您！ 基于 Docker 的 ROS 应用程序现已构建，并上传到 Amazon ECR，随时可以部署。

步骤 2：安装和预置 AWS IoT Greengrass 2.0

接下来，我们将安装和预置 AWS IoT Greengrass 2.0。今天，我们将使用 AWS RoboMaker IDE 实例来替代真实机器人。您也可以在预置真实机器人时使用相同的流程，并对其进行自定义以满足所需的配置和安全要求。

为了创建将机器人连接到 AWS IoT Greengrass 2.0 所需的基于云的资源，需要提高预置过程的 AWS 权限。我们已经在 AWS CloudFormation 模板中打包了部署所需的权限和必备的 AWS 资源。您可在以下位置查看模板：greengrass/greengrass_bootstramp.template.yaml。

运行以下 AWS CloudFormation create stack 命令：
```
cd ~/environment
aws cloudformation create-stack --stack-name GG-Provisioning --template-body file://greengrass-v2-docker-ros-demo/greengrass/greengrass_bootstrap.template.yaml --capabilities CAPABILITY_NAMED_IAM
```
深入了解：CloudFormation 模板

该模板将创建以下资源：
- 一个用于暂存部署构件的 S3 存储桶。
- 一个 IAM Greengrass 预置用户，具有预置新机器人所需的最低 IAM 访问权限。
- 一个基本 IAM 角色，为机器人提供访问特定 AWS 资源的权限。

使用以下命令检查 CloudFormation 堆栈的状态。等待一两分钟，让它创建资源。完成后，响应将类似于以下内容：
```
aws cloudformation describe-stacks --stack-name GG-Provisioning
```

在新浏览器窗口或选项卡中，打开 IAM 控制台。单击 Users（用户）以查看前面步骤中创建的新用户。用户名遵循以下格式：GG-Provisioning-GreengrassProvisioningUser-N12345678。单击此用户并打开 securty credentials（安全凭证）选项卡。

接下来，滚动到 Access keys（访问密钥）部分，并按 Create access key（创建访问密钥）。此时将打开一个带有新访问密钥的弹出窗口。将这些凭证下载或复制/粘贴到安全位置。

1. 在 IDE 中按打开的终端旁边的绿色 (+) 符号，创建一个 New Terminal（新建终端）选项卡。
1. 在新的 AWS RoboMaker IDE 终端选项卡中运行以下安装命令，将 <INSERT_YOUR_AWS_ACCESS_KEY_ID_HERE> 和 <INSERT_YOUR_AWS_SECRET_KEY> 替换为之前创建的凭证：
```
# 安装依赖项（Java JRE）
sudo apt-get update
sudo apt-get install default-jre -y

# 安装和预置 AWS IoT Greengrass 2.0
export AWS_ACCESS_KEY_ID=<INSERT_YOUR_AWS_ACCESS_KEY_ID_HERE>
export AWS_SECRET_ACCESS_KEY=<INSERT_YOUR_AWS_SECRET_KEY>

curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip && unzip greengrass-nucleus-latest.zip -d GreengrassCore
```
1. 运行 AWS IoT Greengrass 2.0 预置命令：
```
sudo -E java -Droot="/greengrass/v2" -Dlog.store=FILE -jar ./GreengrassCore/lib/Greengrass.jar \
--thing-name ROS2_IDE_1 \
--thing-group-name ROS2_IDE_Machines \
--component-default-user ggc_user:ggc_group \
--provision true \
--setup-system-service true \
--deploy-dev-tools true

sudo usermod -aG docker ggc_user
```
  深入了解：AWS IoT Greengrass 2.0 设备预置
  
  上述命令将预置 Greengrass 运行所需的本地资源和云资源。以下是对所定义的每个标记的描述：
  - –thing-name:：定义要为该机器人创建和/或使用的 IoT 事物。
  - –thing-group-name：定义要为该机器人创建和/或使用的 IoT 事物组。
  - –component-default-user：定义运行 Greengrass 组件的默认 Linux 用户。
  - –provision：运行预置过程以创建上述标记中定义的资源，并在设备上设置 Greengrass。如果将其设置为 false，Greengrass 将假设这些资源已经存在。
  - –setup-system-service：这会将 Greengrass 设置为本地系统服务，并在启动时运行该软件。
  - –deploy-dev-tools：此标记将使用 Greengrass CLI 组件创建初始部署，用于开发和调试。在生产中，可能不需要此标记。
  在最后一个命令中，我们授予 ggc_user 系统用户运行 Docker 容器的权限。
  
  有关 AWS IoT Greengrass 服务调用的更多详细信息，请单击此处。
1. 完成后，按终端选项卡右上角的“x”关闭其他终端。
步骤 3：在 Greengrass 2.0 中创建示例应用程序组件

在下一部分中，您将创建一个名为 com.example.ros2.demos 的软件组件，该组件将定义和运行基于 Docker 的 ROS 2 示例应用程序，然后使用 AWS IoT Greengrass 进行部署。该组件下载并运行来自 Amazon S3 的 Docker Compose 文件，以及存储在 Amazon ECR 中的私有 Docker 映像。Token Exchange Service 和 Docker Application Manager 这两个预构建公共组件也作为依赖项进行部署。这两个公共组件允许 AWS IoT Greengrass 2.0 在机器人上运行 Docker 容器。

深入了解：公共组件

Token Exchange Service 用于向 AWS 提供对正在运行的组件的访问权限，例如从 Amazon S3 下载软件构件、从 Amazon ECR 提取 Docker 映像或上传日志和遥测数据等权限。本地 AWS 令牌交换服务将生成临时的短期凭证，供机器人应用程序访问 AWS 资源。默认情况下，Token Exchange Service 将使用预置过程（GreengrassV2TokenExchangeRole）创建的 IAM 角色和关联权限。greengrass/robot.policy.json 的示例应用程序中提供了用于此角色的 IAM 策略示例。

Docker Application Manager 公共组件将管理 Docker 权限，并从云中的私有存储库中提取 Docker 映像。我们将把这些公共组件作为依赖项，与我们的 ROS2 组件一起部署。

现在，我们来创建和部署第一个 AWS IoT Greengrass 组件。
1. 在 AWS RoboMaker IDE 中，打开 IDE 的 greengrass > com.example.ros2.demo > 1.0.0 > recipes > recipe.yaml 目录中的文件。该文件是基于 YAML 的基本组件方案，除了三个部署构件、Amazon ECR 中的 Docker 映像以及存储在 Amazon S3 中的 Docker Compose 文件外，它还定义了运行时逻辑。
1. 在 AWS RoboMaker IDE 终端中，运行以下命令来检索 CloudFormation 模板创建的 S3 存储桶名称。如果在此阶段出现“AccessDenied”（访问被拒绝）错误，可能是因为您仍在使用带有前述预置凭证的终端。关闭此终端并打开一个新的终端。
```
aws cloudformation describe-stacks --stack-name GG-Provisioning
```
1. 将 <YOUR_PRIVATE_ECR_IMAGE_ID_ROS_GREENGRASS_DEMO> 字段替换为您创建的相应 Amazon ECR 映像 ID，以修改方案文件。这些值应类似于这样：<ACCOUNT_ID>.dkr.ecr.<REGION>.amazonaws.com/ros-foxy-greengrass-demo:latest。然后，使用上一步中的 S3 存储桶名称更新 <YOUR_S3_BUCKET> 并保存方案文件。
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.ros2.demo
ComponentVersion: '1.0.0'
ComponentDescription: 'A basic component that runs a simple pub/sub ROS2 application'
ComponentPublisher: Amazon
ComponentDependencies:
  aws.greengrass.DockerApplicationManager:
    VersionRequirement: ~2.0.0
  aws.greengrass.TokenExchangeService:
    VersionRequirement: ~2.0.0
ComponentConfiguration:
  DefaultConfiguration:
    accessControl:
      aws.greengrass.ipc.mqttproxy:
        com.example.PubSubPublisher:pubsub:1:
          policyDescription: "Allows access to publish and subscribe to MQTT topics."
          operations:
          - "aws.greengrass#PublishToIoTCore"
          - "aws.greengrass#SubscribeToIoTCore"
          resources:
          - "chatter"
          - "cloud_chatter"
Manifests:
  - Platform:
      os: all
    Lifecycle:
        Install: |
           docker tag  ros-foxy-greengrass-demo:latest
        Startup: |
           docker-compose -f {artifacts:path}/docker-compose.yaml up -d
        Shutdown: |
           docker-compose -f {artifacts:path}/docker-compose.yaml down
    构件：
      - URI: "docker:"
      - URI: "s3:///com.example.ros2.demo/1.0.0/artifacts/docker-compose.yaml"
```
1. 将 Docker Compose 文件上传到使用方案中定义的对象键的 Amazon S3 存储桶：
```
cd ~/environment/greengrass-v2-docker-ros-demo
aws s3 cp ./docker-compose.yaml s3://<MY_BUCKET_NAME>/com.example.ros2.demo/1.0.0/artifacts/docker-compose.yaml
```
1. 在新浏览器选项卡中，打开 AWS IoT Greengrass 2.0 控制台。在左侧菜单中，单击 Components（组件）。然后，按 Create Component（创建组件）。
2. 单击 Enter recipe as YAML（将方案输入为 YAML），然后将前述方案复制/粘贴到编辑器窗口中。
1. 按 Create component（创建组件）。
祝贺您！ 已在 Greengrass 2.0 中成功创建基于 Docker 的 ROS 2 示例应用程序组件。

步骤 4：使用 Greengrass 2.0 部署示例应用程序组件

使用 AWS IoT Greengrass 2.0，可以将软件组件和配置部署到单个机器人或机器人机队。前述预置过程创建了一个名为 ROS2_IDE_Machines 的 IoT 事物组 以用作部署目标，并执行了初始部署以下载和安装本地开发人员工具。添加到 ROS2_IDE_Machines 组的所有机器人都将收到此部署中定义的组件。为确保一致性，AWS IoT Greengrass 2.0 在向已有部署的目标部署新组件时会覆盖之前的部署。因此，在下一部分中，我们将修订初始部署，以添加我们在上面创建的新 ROS 2 示例应用程序组件。完成后，ROS 2 示例应用程序将部署并运行在 IDE 主机上。要了解有关 AWS IoT Greengrass 2.0 部署的更多信息，请单击此处。
1. 打开 AWS IoT Greengrass 控制台，然后单击 Deployments（部署）。在这里，您将看到在预置机器人时创建的初始部署。
2. 单击 Deployment for ROS2_IDE_Machines（ROS2_IDE_Machines 的部署）对应的复选框，然后按右上角的 Revise（修订）。
1. 在向导中，第一步指定部署名称和部署目标（Greengrass 核心设备或 IoT 事物组）。修订部署时，部署目标必须保持不变。但是，如果新的组件集不再符合定义的命名方案，可以更改名称。我们将保留这些详细信息作为默认值。按 Next（下一步）。
1. 在向导的下一步中，在 My components（我的组件）下，找到新的示例应用程序组件（com.example.ros2.demo）。然后，单击其旁边的复选框以将新组件包含在修订后的部署中。注意：不需要直接指定依赖组件 aws.greengrass.DockerApplicationManager 和 aws.greengrass.TokenExchangeService，因为组件方案中定义的所有依赖项都将自动使用此组件进行部署。
1. 在向导的第三步中，您可以自定义部署中组件的配置（环境变量、组件版本、系统用户等）。在本教程中，我们将使用默认设置。单击 Next（下一步）。
1. 在最后一步中，您可以选择配置高级部署设置。我们暂时将这些选项保留为默认值。按 Next（下一步），然后按 Deploy（部署）以开始部署。您可以配置以下高级部署设置：
  - Rollout configuration（部署配置）是部署到大量设备的速率。这可以定义为恒定速率或指数速率，并且您可以设置每分钟部署软件的最大设备数。
  - Timeout configuration（超时配置）是指在超时之前等待设备应用部署的时间。这里的最大值为 7 天。
  - Cancel configuration（取消配置）可用于对已定义的最小部署设备数设置故障阈值。例如，对于由 1000 个机器人组成的机队，如果在最初的 50 次部署后，故障率为 20% 或更高，则取消对剩余 950 个机器人的部署。
  - Deployment policies（部署策略）可用于定义高级部署工作流。每个组件都可以在组件方案中定义自定义更新逻辑。启用组件通知后，将在更新组件之前执行每个组件定义的逻辑。您可以在组件方案中定义自定义条件逻辑（例如延迟更新，直到机器人到达充电座或连接到 Wi-Fi）。您还可以将组件设置为在部署失败时自动回滚到以前的部署。
1. 一两分钟后，使用 Greengrass CLI 在 AWS RoboMaker IDE 中运行以下命令，以查看 ROS 容器是否正在运行。
```
cd /greengrass/v2/bin/
sudo ./greengrass-cli component list
```
1. 使用已部署的 Docker Compose 文件来跟踪日志，并查看节点之间的 pub/sub 通信。
```
export ARTIFACT_DIR=/greengrass/v2/packages/artifacts/com.example.ros2.demo/1.0.0/
sudo docker-compose -f $ARTIFACT_DIR/docker-compose.yaml logs –follow
```
您应该会看到应用程序正在运行，并显示 Hello World 消息！
1. （可选步骤）要停止和/或重新启动 ROS 容器，请运行以下命令。要了解有关 Greengrass CLI 用途的更多信息，请单击此处。
```
# 停止
sudo ./greengrass-cli component stop -n com.example.ros2.demo

# 检查状态（应标记为“FINISHED”）：
sudo ./greengrass-cli component list

# 重新启动
sudo ./greengrass-cli component restart -n com.example.ros2.demo
```
1. 最后，打开左侧菜单上的 AWS IoT，单击 Test（测试），然后打开 MQTT Test Client（MQTT 测试客户端）。我们今天应用的一部分是设置一个 ROS 主题桥，该桥通过 Greengrass 进程间通信将消息重新发布到 AWS 中运行的 MQTT 主题。订阅主题“chatter”。AWS IoT 中开始显示“Hello World”消息。
祝贺您！ 您已使用 AWS IoT Greengrass 2.0 成功将基于 Docker 的 ROS 2 应用程序部署到机器人上，并将 ROS 主题与云中的 MQTT 主题联系起来！

清理

完成演练后，您可以按照以下三个步骤移除创建的资源：
1. 按照这些说明删除 CloudFormation 堆栈。
2. 按照这些说明删除 AWS RoboMaker IDE 实例。
3. 依次单击 Greengrass > Core devices（Core 设备）> ROS2_IDE_1，在 AWS IoT 控制台中删除 Greengrass Core 设备。然后，单击屏幕右上角的 Delete（删除）。
4. 依次单击 Manage（管理）> Thing Groups（事物组）> ROS2_IDE_Machines，在 AWS IoT 控制台中删除事物组。然后单击右上角的 Actions（操作）下拉菜单，按 Delete（删除）。
结论

在这篇博客中，我们演练了关于使用 Docker 和 AWS IoT Greengrass 2.0 构建和部署 ROS 2 应用程序的分步指南。这些步骤包括：
- 如何在云中设置 ROS 开发环境。
- 如何在 Docker 容器中运行基本 ROS 应用程序。
- 如何将 ROS 主题与 MQTT 主题联系起来，并将机器人连接到云端。
- 如何使用 AWS IoT Greengrass 2.0 在机器人机队上部署和管理 ROS 2 Docker 容器
在下一篇博客中，我们将使用相同的方法将一个功能正常的机器人应用程序部署到基于 NVidia L4T 的 JetBot 上。JetBot 机器人开发套件利用 NVidia Jetson Nano，具有许多有趣的传感器，例如激光雷达、摄像头、麦克风、扬声器和 OLED 显示屏。我们还将介绍使用 Docker 的常见交叉编译工作流，并向您展示如何在边缘运行推理。

要了解更多信息，请访问 AWS RoboMaker、AWS IoT Greengrass，或联系 AWS 以了解更多信息。

祝大家构建顺利！