终止支持通知：2026 年 10 月 7 日， AWS 将停止对的支持。 AWS IoT Greengrass Version 1 2026 年 10 月 7 日之后，您将无法再访问这些 AWS IoT Greengrass V1 资源。如需了解更多信息，请访问[迁移自 AWS IoT Greengrass Version 1](https://docs.aws.amazon.com/greengrass/v2/developerguide/migrate-from-v1.html)。
本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。
# 将数据流导出到 AWS 云 (CLI)
本教程向您展示如何使用配置和部署启用了流管理器的 AWS IoT Greengrass 群组。 AWS CLI 该组包含一个用户定义的 Lambda 函数，该函数可以在流管理器中写入流，然后将其自动导出到 AWS 云中。
流管理器使得摄取、处理和导出大容量数据流更高效也更可靠。在本教程中，您将创建一个使用 IoT 数据的 `TransferStream` Lambda 函数。Lambda 函数使用 AWS IoT Greengrass Core SDK 在流管理器中创建流，然后对其进行读取和写入。然后，流管理器将流导出到 Kinesis Data Streams。下图演示了此工作流程。
![\[流管理工作流图。\]](http://docs.aws.amazon.com/zh_cn/greengrass/v1/developerguide/images/stream-manager-scenario.png)
本教程的重点是展示用户定义的 Lambda 函数如何使用 AWS IoT Greengrass Core SDK 中的`StreamManagerClient`对象与流管理器进行交互。为简单起见，您为本教程创建的 Python Lambda 函数将生成模拟设备数据。
当您使用 AWS IoT Greengrass API（其中包含 Greengrass 命令）创建群组时，直播管理器默认处于 AWS CLI禁用状态。要在核心上启用流管理器，您需要[创建一个函数定义版本](#stream-manager-cli-create-function-definition)，其中包括系统 `GGStreamManager` Lambda 函数和一个引用新的函数定义版本的组版本。然后部署组。
## 先决条件
要完成此教程，需要：
+ Greengrass 组和 Greengrass Core（v1.10 或更高版本）。有关如何创建 Greengrass 组和核心的信息，请参阅 [入门 AWS IoT Greengrass](gg-gs.md)。入门教程还包括安装 AWS IoT Greengrass 核心软件的步骤。
**注意**
OpenWrt 发行版不支持直播管理器。
+ 核心设备上安装的 Java 8 运行时 (JDK 8)。
+ 对于基于 Debian 的发行版（包括 Raspbian）或基于 Ubuntui 的发行版，运行以下命令：
```
sudo apt install openjdk-8-jdk
```
+ 对于基于 Red Hat 的发行版（包括 Amazon Linux），请运行以下命令：
```
sudo yum install java-1.8.0-openjdk
```
有关更多信息，请参阅 OpenJDK 文档中的[如何下载并安装预先构建的 OpenJDK 程序包](https://openjdk.java.net/install/)。
+ AWS IoT Greengrass 适用于 Python 的核心开发工具包 v1.5.0 或更高版本。要在适用于 Python 的 AWS IoT Greengrass Core 软件开发工具包中使用 `StreamManagerClient`，您必须：
+ 在核心设备上安装 Python 3.7 或更高版本。
+ 将开发工具包和其依赖项包含在 Lambda 函数部署程序包中。本教程中提供了说明。
**提示**
可以将 `StreamManagerClient` 与 Java 或 NodeJS 结合使用。有关示例代码，请参阅适用于 [Java 的AWS IoT Greengrass Core SDK](https://github.com/aws/aws-greengrass-core-sdk-java/blob/master/samples/StreamManagerKinesis/src/main/java/com/amazonaws/greengrass/examples/StreamManagerKinesis.java) 和[适用于 Node.js 的AWS IoT Greengrass 酷睿 SDK](https://github.com/aws/aws-greengrass-core-sdk-js/blob/master/greengrassExamples/StreamManagerKinesis/index.js) GitHub。
+ 在 Amazon Kinesis Data Streams 中**MyKinesisStream**创建的目标流，名称与你的 Greengrass 群组 AWS 区域 相同。有关更多信息，请参阅 *Amazon Kinesis 开发人员指南*中的[创建流](https://docs.aws.amazon.com/streams/latest/dev/fundamental-stream.html#create-stream)。
**注意**
在本教程中，流管理器将数据导出到 Kinesis Data Streams，这将向您的 AWS 账户账户收取费用。有关定价的信息，请参阅 [Kinesis Data Streams 定价](https://aws.amazon.com/kinesis/data-streams/pricing/)。
为避免产生费用，您可以在不创建 Kinesis 数据流的情况下运行本教程。在这种情况下，您检查日志以查看流管理器试图将流导出到 Kinesis Data Streams。
+ 一个添加到了 `kinesis:PutRecords` 的 IAM policy，该策略允许对目标数据流执行 [Greengrass 组角色](group-role.md) 操作，如以下示例所示：
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"kinesis:PutRecords"
],
"Resource": [
"arn:aws:kinesis:us-east-1:123456789012:stream/MyKinesisStream"
]
}
]
}
```
------
+ AWS CLI 已在您的计算机上安装和配置。有关更多信息，请参阅 *AWS Command Line Interface 用户指南*中的[安装 AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) 和[配置 AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) 。
本教程中的示例命令是针对 Linux 及其他基于 Unix 的系统编写的。如果你使用的是 Windows，有关语法差异[的更多信息，请参阅为 AWS 命令行界面指定参数值](https://docs.aws.amazon.com/cli/latest/userguide/cli-using-param.html)。
如果命令包含 JSON 字符串，本教程提供了在单行包含 JSON 的示例。在某些系统上，使用此格式可能会更高效地编辑和运行命令。
本教程包含以下概括步骤：
1. [创建 Lambda 函数部署程序包](#stream-manager-cli-create-deployment-package)
1. [创建 Lambda 函数](#stream-manager-cli-create-function)
1. [创建函数定义和版本](#stream-manager-cli-create-function-definition)
1. [创建记录器定义和版本](#stream-manager-cli-create-logger-definition)
1. [获取核心定义版本的 ARN](#stream-manager-cli-get-core-definition-version-arn)
1. [创建组版本](#stream-manager-cli-create-group-version)
1. [创建 部署。](#stream-manager-cli-create-deployment)
1. [测试应用程序](#stream-manager-cli-test-application)
完成本教程大约需要 30 分钟。
## 步骤 1：创建 Lambda 函数部署程序包
在此步骤中，您创建包含 Python 函数代码和依赖项的 Lambda 函数部署包。您稍后在 AWS Lambda中创建 Lambda 函数时上传此程序包。Lambda 函数使用 AWS IoT Greengrass 核心软件开发工具包来创建本地流并与之交互。
**注意**
用户定义的 Lambda 函数必须使用 [AWS IoT Greengrass 核心开发工具包](lambda-functions.md#lambda-sdks-core)与流管理器交互。有关 Greengrass 流管理器的要求的更多信息，请参阅 [Greengrass 流管理器要求](stream-manager.md#stream-manager-requirements)。
1. 下载[适用于 Python 的AWS IoT Greengrass Core 开发工具包](lambda-functions.md#lambda-sdks-core) v1.5.0 或更高版本。
1. 解压缩下载的程序包以获取软件开发工具包。软件开发工具包是 `greengrasssdk` 文件夹。
1. 安装程序包依赖项以将其包含在 Lambda 函数部署程序包的开发工具包中。
1. 导航到包含该 `requirements.txt` 文件的开发工具包目录。此文件列出了依赖项。
1. 安装开发工具包依赖项。例如，运行以下 `pip` 命令将它们安装在当前目录中：
```
pip install --target . -r requirements.txt
```
1. 将以下 Python 代码函数保存在名为 `transfer_stream.py` 的本地文件中。
**提示**
有关使用 Java 和 NodeJS 的示例代码，请参阅AWS IoT Greengrass 适用于 J [ava 的 Core SDK AWS IoT Greengrass 和适用于 Node.js](https://github.com/aws/aws-greengrass-core-sdk-java/blob/master/samples/StreamManagerKinesis/src/main/java/com/amazonaws/greengrass/examples/StreamManagerKinesis.java) [的酷睿 SDK](https://github.com/aws/aws-greengrass-core-sdk-js/blob/master/greengrassExamples/StreamManagerKinesis/index.js)。 GitHub
```
import asyncio
import logging
import random
import time
from greengrasssdk.stream_manager import (
ExportDefinition,
KinesisConfig,
MessageStreamDefinition,
ReadMessagesOptions,
ResourceNotFoundException,
StrategyOnFull,
StreamManagerClient,
)
# This example creates a local stream named "SomeStream".
# It starts writing data into that stream and then stream manager automatically exports
# the data to a customer-created Kinesis data stream named "MyKinesisStream".
# This example runs forever until the program is stopped.
# The size of the local stream on disk will not exceed the default (which is 256 MB).
# Any data appended after the stream reaches the size limit continues to be appended, and
# stream manager deletes the oldest data until the total stream size is back under 256 MB.
# The Kinesis data stream in the cloud has no such bound, so all the data from this script is
# uploaded to Kinesis and you will be charged for that usage.
def main(logger):
try:
stream_name = "SomeStream"
kinesis_stream_name = "MyKinesisStream"
# Create a client for the StreamManager
client = StreamManagerClient()
# Try deleting the stream (if it exists) so that we have a fresh start
try:
client.delete_message_stream(stream_name=stream_name)
except ResourceNotFoundException:
pass
exports = ExportDefinition(
kinesis=[KinesisConfig(identifier="KinesisExport" + stream_name, kinesis_stream_name=kinesis_stream_name)]
)
client.create_message_stream(
MessageStreamDefinition(
name=stream_name, strategy_on_full=StrategyOnFull.OverwriteOldestData, export_definition=exports
)
)
# Append two messages and print their sequence numbers
logger.info(
"Successfully appended message to stream with sequence number %d",
client.append_message(stream_name, "ABCDEFGHIJKLMNO".encode("utf-8")),
)
logger.info(
"Successfully appended message to stream with sequence number %d",
client.append_message(stream_name, "PQRSTUVWXYZ".encode("utf-8")),
)
# Try reading the two messages we just appended and print them out
logger.info(
"Successfully read 2 messages: %s",
client.read_messages(stream_name, ReadMessagesOptions(min_message_count=2, read_timeout_millis=1000)),
)
logger.info("Now going to start writing random integers between 0 and 1000 to the stream")
# Now start putting in random data between 0 and 1000 to emulate device sensor input
while True:
logger.debug("Appending new random integer to stream")
client.append_message(stream_name, random.randint(0, 1000).to_bytes(length=4, signed=True, byteorder="big"))
time.sleep(1)
except asyncio.TimeoutError:
logger.exception("Timed out while executing")
except Exception:
logger.exception("Exception while running")
def function_handler(event, context):
return
logging.basicConfig(level=logging.INFO)
# Start up this sample code
main(logger=logging.getLogger())
```
1. 将以下项目压缩到名为 `transfer_stream_python.zip` 的文件中。此即 Lambda 函数部署程序包。
+ **transfer\$1stream.py**。应用程序逻辑。
+ **greengrasssdk**。发布 MQTT 消息的 Python Greengrass Lambda 函数所需的库。
适用于 Python 的 AWS IoT Greengrass 核心 SDK 版本 1.5.0 或更高版本中提供了@@ [流管理器操作](work-with-streams.md)。
+ 你为适用于 Python 的 AWS IoT Greengrass 核心开发工具包安装的依赖项（例如，`cbor2`目录）。
创建 `zip` 文件时，仅包含这些项目，而不是包含文件夹。
## 第 2 步：创建 Lambda 函数
1. 创建 IAM 角色，以便您可以在创建该函数时传入角色 ARN。
------
#### [ JSON Expanded ]
```
aws iam create-role --role-name Lambda_empty --assume-role-policy '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}'
```
------
#### [ JSON Single-line ]
```
aws iam create-role --role-name Lambda_empty --assume-role-policy '{"Version": "2012-10-17", "Statement": [{"Effect": "Allow", "Principal": {"Service": "lambda.amazonaws.com"},"Action": "sts:AssumeRole"}]}'
```
------
**注意**
AWS IoT Greengrass 不使用这个角色，因为你的 Greengrass Lambda 函数的权限是在 Greengrass 群组角色中指定的。对于本教程，您将创建一个空角色。
1. 从输出中复制 `Arn`。
1. 使用 AWS Lambda API 创建`TransferStream`函数。以下命令假定该 zip 文件位于当前目录中。
+ 将 *role-arn* 替换为复制的 `Arn`。
```
aws lambda create-function \
--function-name TransferStream \
--zip-file fileb://transfer_stream_python.zip \
--role role-arn \
--handler transfer_stream.function_handler \
--runtime python3.7
```
1. 发布该函数的版本。
```
aws lambda publish-version --function-name TransferStream --description 'First version'
```
1. 为发布的版本创建别名。
Greengrass 组可以按别名（推荐）或版本引用 Lambda 函数。使用别名，您可以更轻松地管理代码更新，因为您在更新函数代码时，不必更改订阅表或组定义。相反，您只需将别名指向新的函数版本。
```
aws lambda create-alias --function-name TransferStream --name GG_TransferStream --function-version 1
```
**注意**
AWS IoT Greengrass **不支持 \$1LATEST 版本的 Lambda 别名。**
1. 从输出中复制 `AliasArn`。在为配置函数时，您可以使用此值 AWS IoT Greengrass。
现在，您可以为配置该函数了 AWS IoT Greengrass。
## 步骤 3：创建函数定义和版本
此步骤将创建引用系统 `GGStreamManager` Lambda 函数和用户定义的 `TransferStream` Lambda 函数的函数定义版本。要在使用 AWS IoT Greengrass API 时启用流管理器，您的函数定义版本必须包含该`GGStreamManager`函数。
1. 创建一个包含初始版本的函数定义，该初始版本包含系统和用户定义的 Lambda 函数。
以下定义版本启用了具有默认[参数设置](configure-stream-manager.md)的流管理器。要配置自定义设置，您必须为相应的流管理器参数定义环境变量。有关示例，请参阅[启用、禁用或配置流管理器 (CLI)](configure-stream-manager.md#enable-stream-manager-cli)。 AWS IoT Greengrass 对省略的参数使用默认设置。 `MemorySize`至少应该是`128000`。 `Pinned`必须设置为`true`。
**注意**
*长寿命*（或*固定*）的 Lambda 函数在启动后自动启动，并在 AWS IoT Greengrass 自己的容器中继续运行。这与*按需* Lambda 函数相反，后者在调用时启动，并在没有要运行的任务时停止。有关更多信息，请参阅 [Greengrass Lambda 函数的生命周期配置](lambda-functions.md#lambda-lifecycle)。
+ *arbitrary-function-id*替换为函数的名称，例如**stream-manager**。
+ *alias-arn*替换为`AliasArn`您在创建 `TransferStream` Lambda 函数别名时复制的。
------
#### [ JSON expanded ]
```
aws greengrass create-function-definition --name MyGreengrassFunctions --initial-version '{
"Functions": [
{
"Id": "arbitrary-function-id",
"FunctionArn": "arn:aws:lambda:::function:GGStreamManager:1",
"FunctionConfiguration": {
"MemorySize": 128000,
"Pinned": true,
"Timeout": 3
}
},
{
"Id": "TransferStreamFunction",
"FunctionArn": "alias-arn",
"FunctionConfiguration": {
"Executable": "transfer_stream.function_handler",
"MemorySize": 16000,
"Pinned": true,
"Timeout": 5
}
}
]
}'
```
------
#### [ JSON single ]
```
aws greengrass create-function-definition \
--name MyGreengrassFunctions \
--initial-version '{"Functions": [{"Id": "arbitrary-function-id","FunctionArn": "arn:aws:lambda:::function:GGStreamManager:1", "FunctionConfiguration": {"Environment": {"Variables":{"STREAM_MANAGER_STORE_ROOT_DIR": "/data","STREAM_MANAGER_SERVER_PORT": "1234","STREAM_MANAGER_EXPORTER_MAX_BANDWIDTH": "20000"}},"MemorySize": 128000,"Pinned": true,"Timeout": 3}},{"Id": "TransferStreamFunction", "FunctionArn": "alias-arn", "FunctionConfiguration": {"Executable": "transfer_stream.function_handler", "MemorySize": 16000,"Pinned": true,"Timeout": 5}}]}'
```
------
**注意**
`Timeout` 是函数定义版本所需的，但 `GGStreamManager` 不使用它。有关 `Timeout` 和其他组级别设置的更多信息，请参阅 [使用组特定的配置控制 Greengrass Lambda 函数的执行](lambda-group-config.md)。
1. 从输出中复制 `LatestVersionArn`。您将使用此值向部署到核心的组版本添加函数定义版本。
## 步骤 4：创建记录器定义和版本
配置组的日志记录设置。在本教程中，您将配置 AWS IoT Greengrass 系统组件、用户定义的 Lambda 函数和连接器，以将日志写入核心设备的文件系统。您可以使用日志对可能遇到的任何问题进行故障排除。有关更多信息，请参阅 [使用 AWS IoT Greengrass 日志进行监控](greengrass-logs-overview.md)。
1. 创建一个包含初始版本的记录器定义。
------
#### [ JSON Expanded ]
```
aws greengrass create-logger-definition --name "LoggingConfigs" --initial-version '{
"Loggers": [
{
"Id": "1",
"Component": "GreengrassSystem",
"Level": "INFO",
"Space": 10240,
"Type": "FileSystem"
},
{
"Id": "2",
"Component": "Lambda",
"Level": "INFO",
"Space": 10240,
"Type": "FileSystem"
}
]
}'
```
------
#### [ JSON Single-line ]
```
aws greengrass create-logger-definition \
--name "LoggingConfigs" \
--initial-version '{"Loggers":[{"Id":"1","Component":"GreengrassSystem","Level":"INFO","Space":10240,"Type":"FileSystem"},{"Id":"2","Component":"Lambda","Level":"INFO","Space":10240,"Type":"FileSystem"}]}'
```
------
1. 从输出中复制记录器定义的 `LatestVersionArn`。您将使用此值向部署到核心的组版本添加记录器定义版本。
## 步骤 5：获取核心定义版本的 ARN
获取要添加到新组版本的核心定义版本的 ARN。要部署组版本，该组版本必须引用包含确切一个核心的核心定义版本。
1. 获取目标 Greengrass 群 IDs 组和群组版本。此过程假定这是最新的组和组版本。以下查询将返回最近创建的组。
```
aws greengrass list-groups --query "reverse(sort_by(Groups, &CreationTimestamp))[0]"
```
或者，您也可以按名称查询。系统不要求组名称是唯一的，所以可能会返回多个组。
```
aws greengrass list-groups --query "Groups[?Name=='MyGroup']"
```
**注意**
您也可以在 AWS IoT 控制台中找到这些值。组 ID 显示在组的**设置**页面上。群组版本显示 IDs 在群组的 “**部署**” 选项卡上。
1. 从输出中复制目标组的 `Id`。您将使用此值获取核心定义版本及部署组的时间。
1. 从输出中复制 `LatestVersion`，这是添加到组的最后一个版本的 ID。您将使用此值获取核心定义版本。
1. 获取核心定义版本的 ARN：
1. 获取组版本。
+ *group-id*替换为你为`Id`该群组复制的。
+ *group-version-id*替换为你为`LatestVersion`该群组复制的。
```
aws greengrass get-group-version \
--group-id group-id \
--group-version-id group-version-id
```
1. 从输出中复制 `CoreDefinitionVersionArn`。您将使用此值向部署到核心的组版本添加核心定义版本。
## 步骤 6：创建组版本
现在，您已准备就绪，可以创建一个包含您要部署的实体的组版本。要实现此目的，需要创建一个引用每种组件类型的目标版本的组版本。在本教程中，您将包括核心定义版本、函数定义版本和记录器定义版本。
1. 创建组版本。
+ *group-id*替换为你为`Id`该群组复制的。
+ *core-definition-version-arn*替换`CoreDefinitionVersionArn`为你为核心定义版本复制的。
+ *function-definition-version-arn*替换为你`LatestVersionArn`为新函数定义版本复制的函数。
+ *logger-definition-version-arn*替换为你为新`LatestVersionArn`的 Logger 定义版本复制的。
```
aws greengrass create-group-version \
--group-id group-id \
--core-definition-version-arn core-definition-version-arn \
--function-definition-version-arn function-definition-version-arn \
--logger-definition-version-arn logger-definition-version-arn
```
1. 从输出中复制 `Version`。这是新组版本的 ID。
## 步骤 7：创建部署
将组部署到核心设备。
1. 确保 AWS IoT Greengrass 内核正在运行。根据需要在您的 Raspberry Pi 终端中运行以下命令。
1. 要检查进程守护程序是否正在运行，请执行以下操作：
```
ps aux | grep -E 'greengrass.*daemon'
```
如果输出包含 `root` 的 `/greengrass/ggc/packages/ggc-version/bin/daemon` 条目，则表示进程守护程序正在运行。
**注意**
路径中的版本取决于 AWS IoT Greengrass 核心设备上安装的 Core 软件版本。
1. 启动进程守护程序：
```
cd /greengrass/ggc/core/
sudo ./greengrassd start
```
1. 创建 部署。
+ *group-id*替换为你为`Id`该群组复制的。
+ *group-version-id*替换为你`Version`为新群组版本复制的版本。
```
aws greengrass create-deployment \
--deployment-type NewDeployment \
--group-id group-id \
--group-version-id group-version-id
```
1. 从输出中复制 `DeploymentId`。
1. 获取部署状态。
+ *group-id*替换为你为`Id`该群组复制的。
+ *deployment-id*替换为您`DeploymentId`为部署复制的。
```
aws greengrass get-deployment-status \
--group-id group-id \
--deployment-id deployment-id
```
如果状态为 `Success`，则部署成功。有关问题排查帮助，请参阅[故障排除 AWS IoT Greengrass](gg-troubleshooting.md)。
## 步骤 8：测试应用程序
`TransferStream` Lambda 函数生成模拟的设备数据。它将数据写入流管理器导出到目标 Kinesis 数据流的流。
1. 在 Amazon Kinesis 控制台的 Kinesi **s 数据流**下，选择。**MyKinesisStream**
**注意**
如果您在运行教程时没有目标 Kinesis 数据流， [请检查流管理器的日志文件](#stream-manager-cli-logs) (`GGStreamManager`)。如果它在错误消息中包含 `export stream MyKinesisStream doesn't exist`，则测试成功。此错误意味着服务试图导出到流，但流不存在。
1. 在**MyKinesisStream**页面上，选择**监控**。如果测试成功，您应在 **Put Records (放置记录)** 图表中看到数据。根据您的连接，显示数据可能需要一分钟时间。
**重要**
测试完成后，删除 Kinesis 数据流以避免产生更多费用。
运行以下命令以停止 Greengrass 守护程序。这样可以防止核心发送消息，直到您准备好继续测试。
```
cd /greengrass/ggc/core/
sudo ./greengrassd stop
```
1. 从核心中移除 **TransferStream**Lambda 函数。
1. 按照[步骤 6：创建组版本](#stream-manager-cli-create-group-version)创建新的组版本，但删除 `create-group-version` 命令中的 `--function-definition-version-arn` 选项。或者，创建一个不包含 **TransferStream**Lambda 函数的函数定义版本。
**注意**
通过省略部署的组版本中的系统 `GGStreamManager` Lambda 函数，可以禁用核心上的流管理。
1. 按照[步骤 7：创建部署](#stream-manager-cli-create-deployment)以部署新的组版本。
要查看日志记录信息或解决流的问题，请检查日志中的 `TransferStream` 和 `GGStreamManager` 函数。您必须具有读取文件系统 AWS IoT Greengrass 日志的`root`权限。
+ `TransferStream` 将日志条目写入 `greengrass-root/ggc/var/log/user/region/account-id/TransferStream.log`。
+ `GGStreamManager` 将日志条目写入 `greengrass-root/ggc/var/log/system/GGStreamManager.log`。
如果需要更多疑难解答信息，可以将 `Lambda` 日志记录级别设置为 `DEBUG`，然后创建并部署新的组版本。
## 另请参阅
+ [管理 AWS IoT Greengrass 核心上的数据流](stream-manager.md)
+ [StreamManagerClient 用于处理直播](work-with-streams.md)
+ [导出支持的 AWS 云 目标的配置](stream-export-configurations.md)
+ [配置 AWS IoT Greengrass 直播管理器](configure-stream-manager.md)
+ [将数据流导出到 AWS 云 （控制台）](stream-manager-console.md)
+ AWS Identity and Access Management 命令*参考@@ [中的 (IAM)AWS CLI 命令](https://docs.aws.amazon.com/cli/latest/reference/iam)*
+ [AWS Lambda 命令](https://docs.aws.amazon.com/cli/latest/reference/lambda)*参考中的AWS CLI 命令*
+ [AWS IoT Greengrass 命令](https://docs.aws.amazon.com/cli/latest/reference/greengrass/index.html)*参考中的AWS CLI 命令*