サポート終了通知: 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/ja_jp/greengrass/v1/developerguide/images/stream-manager-scenario.png)
このチュートリアルでは、ユーザー定義の Lambda 関数が AWS IoT Greengrass Core SDK の `StreamManagerClient` オブジェクトを使用してストリームマネージャーとやり取りする方法を示します。簡単にするために、このチュートリアルで作成する Python Lambda 関数は、シミュレートされたデバイスデータを生成します。
に Greengrass コマンドを含む AWS IoT Greengrass API を使用してグループ AWS CLIを作成すると、ストリームマネージャーはデフォルトで無効になります。コアでストリームマネージャーを有効にするには、システム `GGStreamManager` Lambda 関数に加え、新しい関数定義バージョンを参照するグループバージョンを含む[関数定義バージョンを作成](#stream-manager-cli-create-function-definition)します。次に、フローをデプロイします。
## 前提条件
このチュートリアルを完了するには、以下が必要です。
+ Greengrass グループと Greengrass コア (v1.10 以降)。Greengrass のグループまたはコアを作成する方法については、「[の開始方法 AWS IoT Greengrass](gg-gs.md)」を参照してください。入門チュートリアルには、 AWS IoT Greengrass Core ソフトウェアをインストールする手順も含まれています。
**注記**
ストリームマネージャーは 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 ドキュメントの「[How to download and install prebuilt OpenJDK packages](https://openjdk.java.net/install/)」を参照してください。
+ AWS IoT Greengrass Core SDK for Python v1.5.0 以降。 AWS IoT Greengrass Core SDK for Python で `StreamManagerClient` を使用するには、以下を行う必要があります。
+ Python 3.7 以降をコアデバイスにインストールします。
+ SDK とその依存関係を Lambda 関数デプロイパッケージに含めます。このチュートリアルでは、手順を説明しています。
**ヒント**
`StreamManagerClient` を Java または NodeJS で使用できます。コードの例については、GitHub の 「[AWS IoT Greengrass Core SDK for Java](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 Core SDK for Node.js](https://github.com/aws/aws-greengrass-core-sdk-js/blob/master/greengrassExamples/StreamManagerKinesis/index.js)」を参照してください。
+ Greengrass グループ AWS リージョン と同じ の Amazon Kinesis Data Streams で**MyKinesisStream**作成された という名前の送信先ストリーム。詳細については、「Amazon Kinesis デベロッパーガイド」の「[ストリームを作成する](https://docs.aws.amazon.com/streams/latest/dev/fundamental-stream.html#create-stream)」を参照してください。
**注記**
このチュートリアルでは、ストリームマネージャーが Kinesis Data Streams にデータをエクスポートするため、 AWS アカウントに課金されます。料金の詳細については、「[Amazon Kinesis Data Streams の料金](https://aws.amazon.com/kinesis/data-streams/pricing/)」を参照してください。
料金が発生しないようにするには、Kinesis データストリームを作成せずにこのチュートリアルを実行します。この場合、ログを確認して、ストリームマネージャーがストリームを Kinesis Data Streams にエクスポートしようとしたことを確認します。
+ 次の例に示すように、ターゲットデータストリームで `kinesis:PutRecords` アクションを許可する [Greengrass グループのロール](group-role.md) に IAM ポリシーが追加されている。
------
#### [ 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 文字列が含まれている場合、このチュートリアルでは、1 行形式の 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 Core SDK を使用してローカルストリームを作成して操作します。
**注記**
ユーザー定義の Lambda 関数は、[AWS IoT Greengrass Core SDK](lambda-functions.md#lambda-sdks-core) を使用してストリームマネージャーと対話する必要があります。Greengrass ストリームマネージャーの要件の詳細については、「[Greengrass ストリームマネージャーの要件](stream-manager.md#stream-manager-requirements)」を参照してください。
1. v1.5.0 以降の [AWS IoT Greengrass Core SDK for Python](lambda-functions.md#lambda-sdks-core) をダウンロードします。
1. ダウンロードしたパッケージを解凍し、SDK を取得します。SDK は `greengrasssdk` フォルダです。
1. パッケージ依存関係をインストールして、Lambda 関数デプロイパッケージに SDK を含めます。
1. `requirements.txt` ファイルのある SDK ディレクトリに移動します。このファイルには依存関係の一覧が記載されています。
1. SDK の依存関係をインストールします。例えば、次の `pip` コマンドを実行して、現在のディレクトリにインストールします。
```
pip install --target . -r requirements.txt
```
1. 以下の Python コード関数を `transfer_stream.py` というローカルファイルに保存します。
**ヒント**
Java と NodeJS を使用するコードの例については、GitHub の「[AWS IoT Greengrass Core SDK for Java](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 Core SDK for Node.js](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 関数で必須のライブラリ。
[ストリームマネージャーオペレーション](work-with-streams.md)は、 AWS IoT Greengrass Core SDK for Python のバージョン 1.5.0 以降で使用できます。
+ AWS IoT Greengrass Core SDK for Python にインストールした依存関係 (`cbor2`ディレクトリなど）。
`zip` ファイルを作成するときは、これらの項目のみを含み、それらが含まれているフォルダは含みません。
## ステップ 2: Lambda 関数を作成する
1. 関数の作成時に ARN を渡せるように、IAM ロールを作成します。
------
#### [ 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)で有効になります。カスタム設定を構成するには、対応するストリームマネージャーのパラメータの環境変数を定義する必要があります。例については、「. AWS IoT Greengrass uses default settings for parameters that are omitted」を参照してください[ストリームマネージャー (CLI) を有効化、無効化、設定するには](configure-stream-manager.md#enable-stream-manager-cli)。 `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` をコピーします。この値を使用して、Core にデプロイするグループバージョンに、関数定義バージョンを追加します。
## ステップ 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 つのコアが含まれているコア定義バージョンを参照する必要があります。
1. ターゲットの Greengrass グループとグループバージョンの ID を取得します。この手順では、これが最新のグループおよびグループのバージョンであると仮定します。次のクエリは、最後に作成されたグループを返します。
```
aws greengrass list-groups --query "reverse(sort_by(Groups, &CreationTimestamp))[0]"
```
または、名前でクエリを実行することもできます。グループ名は一意である必要はないため、複数のグループが返されることがあります。
```
aws greengrass list-groups --query "Groups[?Name=='MyGroup']"
```
**注記**
これらの値は AWS IoT コンソールでも確認できます。グループ ID は、グループの [**設定**] ページに表示されます。グループバージョン ID は、グループの **[Deployments]** (デプロイ) タブに表示されます。
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` に置き換えます。
```
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: デプロイを作成する
Core デバイスにグループをデプロイします。
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 コンソールの **[Kinesis data streams]** (Kinesis データストリーム) で、**[MyKinesisStream]** を選択します。
**注記**
ターゲットの Kinesis データストリームを使用せずにチュートリアルを実行した場合は、ストリームマネージャーの[ログファイルを確認します](#stream-manager-cli-logs) (`GGStreamManager`)。エラーメッセージに `export stream MyKinesisStream doesn't exist` が含まれている場合、テストは成功します。このエラーは、サービスがストリームにエクスポートしようとしましたが、ストリームが存在しないことを意味します。
1. [**MyKinesisStream**] ページで、[**Monitoring (モニタリング)**] を選択します。テストが成功すると、**Put Records (レコードの配置)** グラフにデータが表示されます。接続によっては、データが表示されるまでに 1 分かかることがあります。
**重要**
テストが終了したら、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 *