支援終止通知：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 CLI 來設定和部署已啟用串流管理員的 AWS IoT Greengrass 群組。群組包含使用者定義的 Lambda 函數，可寫入串流管理員中的串流，然後自動匯出至 AWS 雲端。
串流管理員可讓擷取、處理和匯出大量資料串流更有效率且更可靠。在本教學課程中，您會建立使用 IoT 資料的 `TransferStream` Lambda 函數。Lambda 函數使用 AWS IoT Greengrass Core SDK 在串流管理員中建立串流，然後讀取和寫入。串流管理員接著會將串流匯出至 Kinesis Data Streams。下圖顯示此工作流程。
![\[串流管理工作流程圖\]](http://docs.aws.amazon.com/zh_tw/greengrass/v1/developerguide/images/stream-manager-scenario.png)
本教學課程的重點是展示使用者定義的 Lambda 函數如何使用 AWS IoT Greengrass Core SDK 中的 `StreamManagerClient` 物件與串流管理員互動。為了簡化，您為此教學課程建立的 Python Lambda 函數會產生模擬的裝置資料。
當您使用包含 中 Greengrass 命令的 AWS IoT Greengrass API AWS CLI來建立群組時，預設會停用串流管理員。若要在核心上啟用串流管理員，您可以[建立包含系統 Lambda 函數的函數定義版本](#stream-manager-cli-create-function-definition)，以及參考新函數定義版本的群組版本。 `GGStreamManager`然後您將部署群組。
## 先決條件
為完成此教學課程您需要：
+ Greengrass 群組和 Greengrass 核心 (v1.10 或更新版本）。如需如何建立 Greengrass 群組和核心的詳細資訊，請參閱 [入門 AWS IoT Greengrass](gg-gs.md)。入門教學課程也包含安裝 AWS IoT Greengrass 核心軟體的步驟。
**注意**
OpenWrt 發行版本不支援串流管理員。
+ 在核心裝置上安裝 Java 8 執行時間 (JDK 8)。
+ 針對以 Debian 為基礎的發行版本 (包括 Raspbian) 或以 Ubuntu 為基礎的發行版本，請執行下列命令：
```
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 1.5.0 版或更新版本的核心 SDK。若要在適用於 Python 的 AWS IoT Greengrass 核心 SDK `StreamManagerClient`中使用 ，您必須：
+ 在核心裝置上安裝 Python 3.7 或更新版本。
+ 在 Lambda 函數部署套件中包含 SDK 及其相依性。本教學課程提供相關指示。
**提示**
您可以搭配使用 `StreamManagerClient` 與 Java 或 NodeJS。如需範例程式碼，請參閱 GitHub 上的[AWS IoT Greengrass 適用於 Java](https://github.com/aws/aws-greengrass-core-sdk-java/blob/master/samples/StreamManagerKinesis/src/main/java/com/amazonaws/greengrass/examples/StreamManagerKinesis.java) 的 Core SDK 和[AWS IoT Greengrass 適用於 Node.js 的 Core SDK](https://github.com/aws/aws-greengrass-core-sdk-js/blob/master/greengrassExamples/StreamManagerKinesis/index.js)。
+ 在與 Greengrass 群組相同的 Amazon Kinesis Data Streams 中**MyKinesisStream**建立名為 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。
+ 新增至 的 IAM 政策[Greengrass 群組角色](group-role.md)，允許對目標資料串流執行 `kinesis:PutRecords`動作，如下列範例所示：
------
#### [ 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 函數部署套件。您稍後在其中建立 Lambda 函數時上傳此套件 AWS Lambda。Lambda 函數使用 AWS IoT Greengrass 核心 SDK 來建立本機串流並與之互動。
**注意**
使用者定義的 Lambda 函數必須使用 [AWS IoT Greengrass 核心 SDK](lambda-functions.md#lambda-sdks-core) 與串流管理員互動。如需有關 Greengrass 串流管理員需求的詳細資訊，請參閱 [Greengrass 串流管理員需求](stream-manager.md#stream-manager-requirements)。
1. 下載[AWS IoT Greengrass 適用於 Python 的 核心 SDK](lambda-functions.md#lambda-sdks-core) 1.5.0 版或更新版本。
1. 解壓縮下載的封裝，以取得軟體開發套件。SDK 為 `greengrasssdk` 資料夾。
1. 安裝套件相依性，以在 Lambda 函數部署套件中包含 開發套件。
1. 前往包含 `requirements.txt` 檔案的軟體開發套件目錄。這個檔案會列出相依性。
1. 安裝軟體開發套件相依性。例如，執行下列 `pip` 命令，將它們安裝在目前的目錄中：
```
pip install --target . -r requirements.txt
```
1. 將以下 Python 程式碼函數儲存在名為 `transfer_stream.py` 的本機檔案中。
**提示**
如需使用 Java 和 NodeJS 的範例程式碼，請參閱 GitHub 上的[AWS IoT Greengrass 適用於 Java 的 Core SDK](https://github.com/aws/aws-greengrass-core-sdk-java/blob/master/samples/StreamManagerKinesis/src/main/java/com/amazonaws/greengrass/examples/StreamManagerKinesis.java) 和[AWS IoT Greengrass 適用於 Node.js 的 Core SDK](https://github.com/aws/aws-greengrass-core-sdk-js/blob/master/greengrassExamples/StreamManagerKinesis/index.js)。
```
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 Core SDK 1.5.0 版或更新版本提供[串流管理員操作](work-with-streams.md)。
+ 您為適用於 Python AWS IoT Greengrass 的核心 SDK 安裝的相依性 （例如， `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* 取代為您為 `TransferStream` Lambda 函數建立別名時`AliasArn`複製的 。
------
#### [ 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 群組 ID 和目標群組版本 ID。此程序假設這是最新的群組和群組版本。下列查詢會傳回最近建立的群組。
```
aws greengrass list-groups --query "reverse(sort_by(Groups, &CreationTimestamp))[0]"
```
或者，您可以依名稱查詢。群組名稱不需要是唯一名稱，因此可能會傳回多個群組。
```
aws greengrass list-groups --query "Groups[?Name=='MyGroup']"
```
**注意**
您也可以在 AWS IoT 主控台中找到這些值。群組 ID 會顯示在群組的 **Settings (設定)** 頁面上。群組版本 IDs會顯示在群組的**部署**索引標籤上。
1. 從輸出複製目標群組的 `Id`。部署群組時，您可以使用此 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`為您為新記錄器定義版本複製的 。
```
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 軟體版本。
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 主控台的 **Kinesis 資料串流**下，選擇 **MyKinesisStream**。
**注意**
如果您在沒有目標 Kinesis 資料串流的情況下執行教學課程，[請檢查串流管理員的日誌檔案](#stream-manager-cli-logs) (`GGStreamManager`)。如果日誌檔案包含錯誤消息中的 `export stream MyKinesisStream doesn't exist`，則測試成功。此錯誤表示服務嘗試匯出至串流，但串流不存在。
1. 在 **MyKinesisStream** 頁面上，選擇 **Monitoring (監控)**。如果測試成功，您應該會看到 **Put Records (Put 記錄)** 圖表中的資料。視您的連線而定，可能需要一分鐘才會顯示資料。
**重要**
完成測試後，請刪除 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)](https://docs.aws.amazon.com/cli/latest/reference/iam) *AWS CLI 命令*
+ [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 參考中的 命令*