サポート終了通知: 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 IoT Greengrass コアで Lambda 関数を実行する
AWS IoT Greengrass は、作成したユーザー定義コード用のコンテナ化された Lambda ランタイム環境を提供します AWS Lambda。 AWS IoT Greengrass コアにデプロイされた Lambda 関数は、コアのローカル Lambda ランタイムで実行されます。ローカル Lambda 関数は、ローカルイベント、クラウドからのメッセージやその他のリソースによってトリガーされ、クライアントデバイスにローカルコンピューティングの機能性をもたらします。例えば、データをクラウドに送信する前にデバイスデータをフィルタリングするために、Greengrass Lambda 関数を使用できます。
Lambda 関数をコアにデプロイするには、この関数を Greengrass グループに追加し (既存の Lambda 関数を参照して行います)、この関数に対してグループ固有の設定を行い、グループをデプロイします。関数が AWS サービスにアクセスする場合は、[Greengrass グループロール](group-role.md)に必要なアクセス許可も追加する必要があります。
Lambda 関数の実行方法 (アクセス許可、分離、メモリ制限など) を指定するパラメータを設定できます。詳細については、「[グループ固有の設定による Greengrass Lambda 関数の実行の制御](lambda-group-config.md)」を参照してください。
**注記**
これらの設定により、Docker コンテナ AWS IoT Greengrass で を実行することもできます。詳細については、「[Docker コンテナ AWS IoT Greengrass での実行](run-gg-in-docker-container.md)」を参照してください。
次の表に[AWS Lambda 、サポートされているランタイム](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html)と、それらが実行できる AWS IoT Greengrass Core ソフトウェアのバージョンを示します。
****
| 言語あるいはプラットフォーム | GGC のバージョン |
| --- | --- |
| Python 3.8 | 1.11 |
| Python 3.7 | 1.9 以降 |
| Python 2.7 \$1 | 1.0 以降 |
| Java 8 | 1.1 以降 |
| Node.js 12.x \$1 | 1.10 以降 |
| Node.js 8.10 \$1 | 1.9 以降 |
| Node.js 6.10 \$1 | 1.1 以降 |
| C、C\$1\$1 | 1.6 以降 |
\$1 これらのランタイムを使用する Lambda 関数は、サポートされているバージョンの で実行できますが AWS IoT Greengrass、作成することはできません AWS Lambda。デバイスのランタイムがその関数のために指定された AWS Lambda ランタイムと異なる場合、`FunctionDefintionVersion` の `FunctionRuntimeOverride` を使用して独自のランタイムを選択できます。詳細については、「[CreateFunctionDefinition](https://docs.aws.amazon.com/greengrass/v1/apireference/createfunctiondefinition-post.html)」を参照してください。サポートされているランタイムの詳細については、「AWS Lambda デベロッパーガイド」 の「[Runtime support policy](https://docs.aws.amazon.com/lambda/latest/dg/runtime-support-policy.html)」(ランタイムのサポートポリシー) を参照してください。
## Greengrass Lambda 関数の SDK
AWS には、 AWS IoT Greengrass コアで実行されている Greengrass Lambda 関数で使用できる 3 SDKs が用意されています。これらの SDK は別々のパッケージに含まれているため、関数で同時に使用できます。Greengrass Lambda 関数で SDK を使用するには、 AWS Lambdaにアップロードする Lambda 関数デプロイパッケージに SDK を含めます。
**AWS IoT Greengrass コア SDK**
コアを操作するローカル Lambda 関数を有効にします。
+ MQTT メッセージを と交換します AWS IoT Core。
+ Greengrass グループのコネクタ、クライアントデバイス、その他の Lambda 関数で MQTT メッセージを交換します。
+ ローカルシャドウサービスとやり取りを行います。
+ その他のローカル Lambda 関数を呼び出します。
+ [シークレットリソース](secrets.md)にアクセスします。
+ [ストリームマネージャー](stream-manager.md)とやり取りを行います。
AWS IoT Greengrass は、GitHub で以下の言語とプラットフォームで AWS IoT Greengrass Core SDK を提供します。
+ [AWS IoT Greengrass Core SDK for Java](https://github.com/aws/aws-greengrass-core-sdk-java/)
+ [AWS IoT Greengrass Node.js 用 Core SDK](https://github.com/aws/aws-greengrass-core-sdk-js/)
+ [AWS IoT Greengrass Core SDK for Python](https://github.com/aws/aws-greengrass-core-sdk-python/)
+ [AWS IoT Greengrass Core SDK for C](https://github.com/aws/aws-greengrass-core-sdk-c/)
Lambda 関数デプロイパッケージに AWS IoT Greengrass Core SDK 依存関係を含めるには:
1. Lambda 関数のランタイムに一致する AWS IoT Greengrass Core SDK パッケージの言語またはプラットフォームをダウンロードします。
1. ダウンロードしたパッケージを解凍し、SDK を取得します。SDK は `greengrasssdk` フォルダです。
1. 関数コードを含む Lambda 関数デプロイパッケージに `greengrasssdk` を含めます。これは、Lambda 関数の作成 AWS Lambda 時に にアップロードするパッケージです。
**StreamManagerClient**
[ストリームマネージャー](stream-manager.md)オペレーションには、次の AWS IoT Greengrass Core SDKs のみを使用できます。
+ Java SDK (v1.4.0 以降)
+ Python SDK (v1.5.0 以降)
+ Node.js SDK (v1.6.0 以降)
AWS IoT Greengrass Core SDK for Python を使用してストリームマネージャーを操作するには、Python 3.7 以降をインストールする必要があります。また、Python Lambda 関数のデプロイパッケージに含める依存関係もインストールする必要があります。
1. `requirements.txt` ファイルのある SDK ディレクトリに移動します。このファイルには依存関係の一覧が記載されています。
1. SDK の依存関係をインストールします。例えば、次の `pip` コマンドを実行して、現在のディレクトリにインストールします。
```
pip install --target . -r requirements.txt
```
** AWS IoT Greengrass Core SDK for Python をコアデバイスにインストールする**
Python Lambda 関数を実行している場合は、 [https://pypi.org/project/pip/](https://pypi.org/project/pip/)を使用して AWS IoT Greengrass Core SDK for Python をコアデバイスにインストールすることもできます。そうすれば、Lambda 関数デプロイパッケージに SDK を含めずに関数をデプロイできます。詳細については、「[greengrasssdk](https://pypi.org/project/greengrasssdk/)」を参照してください。
このサポートは、サイズ制限のあるコアを対象としています。可能な場合は、Lambda 関数デプロイパッケージに SDK を含めることをお勧めします。
**AWS IoT Greengrass Machine Learning SDK**
ローカル Lambda 関数は Greengrass コアに機械学習 (ML) リソースとしてデプロイされる ML モデルを使用できます。Lambda 関数は、この SDK を使用してコネクタとしてコアにデプロイされているローカル推論サービスを呼び出し、このサービスと対話できます。Lambda 関数と ML コネクタも、この SDK を使用してデータを ML フィードバックコネクタへ送信し、アップロードおよび発行を行うことができます。SDK を使用するコード例などの詳細については、「[ML イメージ分類コネクタ](image-classification-connector.md)」、「[ML オブジェクト検出コネクタ](obj-detection-connector.md)」、および「[ML フィードバックコネクタ](ml-feedback-connector.md)」を参照してください。
次の表に、 SDK バージョンでサポートされている言語またはプラットフォームと、それらが実行できる AWS IoT Greengrass Core ソフトウェアのバージョンを示します。
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/greengrass/v1/developerguide/lambda-functions.html)
ダウンロード情報については、「[AWS IoT Greengrass ML SDK ソフトウェア](what-is-gg.md#gg-ml-sdk-download)」を参照してください。
**AWS SDK**
ローカル Lambda 関数が Amazon S3、DynamoDB、 AWS IoTなどの AWS サービスに直接呼び出しできるようにします AWS IoT Greengrass。 AWS SDK を Greengrass Lambda 関数で使用するには、デプロイパッケージに含める必要があります。 AWS IoT Greengrass Core AWS SDK と同じパッケージで SDK を使用する場合は、Lambda 関数が正しい名前空間を使用していることを確認してください。Greengrass Lambda 関数は、このコアがオフラインの場合にクラウドサービスと通信できません。
[ 入門リソースセンター](https://aws.amazon.com/getting-started/tools-sdks/)から AWS SDKs をダウンロードします。
デプロイパッケージの作成の詳細については、入門チュートリアルの「[Lambda 関数の作成とパッケージ化](create-lambda.md)」あるいは「AWS Lambda デベロッパーガイド」の「[デプロイパッケージの作成](https://docs.aws.amazon.com/lambda/latest/dg/deployment-package-v2.html)」を参照してください。
### クラウドベースの Lambda 関数への移行
AWS IoT Greengrass Core SDK は AWS SDK プログラミングモデルに従います。これにより、クラウド用に開発された Lambda 関数を、 AWS IoT Greengrass コアで実行される Lambda 関数に簡単に移植できます。
たとえば、次の Python Lambda 関数は、 AWS SDK for Python (Boto3) を使用してクラウド`some/topic`内のトピックにメッセージを発行します。
```
import boto3
iot_client = boto3.client("iot-data")
response = iot_client.publish(
topic="some/topic", qos=0, payload="Some payload".encode()
)
```
AWS IoT Greengrass コアの 関数を移植するには、次の例`greengrasssdk`に示すように、 `import`ステートメントと`client`初期化で`boto3`モジュール名を に変更します。
```
import greengrasssdk
iot_client = greengrasssdk.client("iot-data")
iot_client.publish(topic="some/topic", qos=0, payload="Some payload".encode())
```
**注記**
AWS IoT Greengrass Core SDK は、QoS = 0 の MQTT メッセージの送信のみをサポートします。詳細については、「[サービスのメッセージの品質](gg-core.md#message-quality-of-service)」を参照してください。
プログラミングモデル間の類似性により、クラウドで Lambda 関数を開発し、最小限の労力 AWS IoT Greengrass で に移行することもできます。[Lambda 実行可能ファイルは](#lambda-executables)クラウドでは実行されないため、デプロイ前に AWS SDK を使用してクラウドで開発することはできません。
## エイリアスまたはバージョンによる Lambda 関数のリファレンス
Greengrass グループは、Lambda 関数をエイリアス別 (推奨) またはバージョン別に参照できます。エイリアスを使用すると、関数コードを更新する時にサブスクリプションテーブルやグループ定義を変更する必要がないため、コード更新を簡単に管理できます。その代わりに、新しい関数バージョンにエイリアスを指定するだけで済みます。エイリアスは、グループデプロイ中にバージョン番号を解決します。エイリアスを使用すると、解決されたバージョンはデプロイ時にエイリアスが示すバージョンに更新されます。
AWS IoT Greengrass は、**\$1LATEST** バージョンの Lambda エイリアスをサポートしていません。**\$1LATEST** バージョンは、イミュータブルで発行された関数バージョンにバインドされず、いつでも変更できます。これは、 AWS IoT Greengrass のバージョン普遍性の原則とは異なります。
Greengrass Lambda 関数がコード変更によって常に更新されるようにするための一般的な方法は、Greengrass グループとサブスクリプションで **PRODUCTION** という名前のエイリアスを使用することです。Lambda 関数の新しいバージョンを本稼働環境に移行すると、エイリアスが最新の安定バージョンを示し、グループを再デプロイします。また、このメソッドを使用して以前のバージョンにロールバックすることもできます。
# グループ固有の設定による Greengrass Lambda 関数の実行の制御
AWS IoT Greengrass は、Greengrass Lambda 関数のクラウドベースの管理を提供します。Lambda 関数のコードと依存関係は を使用して管理されますが AWS Lambda、Lambda 関数が Greengrass グループで実行された場合の動作を設定できます。
## グループ固有構成設定
AWS IoT Greengrass には、Greengrass Lambda 関数の以下のグループ固有の設定が用意されています。
**[System user and group]** (システムユーザーとグループ)
各 Lambda 関数を実行するために使用されるアクセス ID。デフォルトでは、Lambda 関数はグループの[デフォルトのアクセス ID](#lambda-access-identity-groupsettings) として実行されます。通常の場合、これはスタンダードの AWS IoT Greengrass システムアカウント (ggc\$1user および ggc\$1group) です。デフォルト設定を変更し、Lambda 関数を実行するために必要なアクセス許可を持つユーザー ID とグループ ID を選択できます。UID と GID の両方をオーバーライドするか、他方のフィールドを空のままにして一方だけをオーバーライドすることもできます。この設定により、デバイスリソースへのアクセスをより詳細に制御できます。Greengrass ハードウェアの設定では、適切なリソース制限、適切なファイルへのアクセス許可、および Lambda 関数を実行するために使用されるアクセス許可を持つユーザーとグループの適切なディスククォータを使用することをお勧めします。
この機能は AWS IoT Greengrass Core v1.7 以降で使用できます。
やむを得ない場合を除き、Lambda 関数を root として実行することは避けてください。root として実行すると、次のリスクが増加します。
+ 重要なファイルを誤って削除するなど、意図しない変更が行われるリスク。
+ 悪意のあるユーザーがデータやデバイスにアクセスするリスク。
+ Docker コンテナが `--net=host` や `UID=EUID=0` で実行されると、コンテナがエスケープするリスク。
root として を実行する必要がある場合は、 AWS IoT Greengrass 設定を更新して有効にする必要があります。詳細については、「[root としての Lambda 関数の実行](#lambda-running-as-root)」を参照してください。
**[System user ID (number)]** (システムユーザー ID (数値))
Lambda 関数を実行するために必要なアクセス許可を持つユーザーのユーザー ID。この設定を利用できるのは、**[Another user ID/group ID]** (別のユーザー ID/グループ ID) として実行した場合に限ります。 AWS IoT Greengrass コアデバイスで **getent passwd** コマンドを使用して、Lambda 関数の実行に使用するユーザー ID を検索できます。
同じ UID を使用してプロセスと Lambda 関数を Greengrass コアデバイスで実行する場合、Greengrass グループロールはプロセスに一時的な認証情報を付与することができます。プロセスは Greengrass コアデプロイメント全体で一時的な認証情報を使用できます。
**[System group ID (number)]** (システムグループ ID (番号))
Lambda 関数を実行するために必要なアクセス許可を持つグループのグループ ID。この設定を利用できるのは、**[Another user ID/group ID]** (別のユーザー ID/グループ ID) として実行した場合に限ります。 AWS IoT Greengrass コアデバイスで **getent group** コマンドを使用して、Lambda 関数の実行に使用するグループ ID を検索できます。
**[Lambda function containerization]** (Lambda 関数のコンテナ化)
Lambda 関数を実行する際に、グループのデフォルトのコンテナ化を使用するかどうかを選択します。または、この Lambda 関数で常に使用するコンテナ化を指定します。
Lambda 関数のコンテナ化モードは、その分離レベルを決定します。
+ コンテナ化された Lambda 関数は、**Greengrass コンテナ**モードで実行されます。Lambda 関数は、 AWS IoT Greengrass コンテナ内の分離されたランタイム環境 (または名前空間) で実行されます。
+ コンテナ化されていない Lambda 関数は、**コンテナなし**モードで実行されます。この Lambda 関数は、分離することなく、通常の Linux プロセスとして実行されます。
この機能は AWS IoT Greengrass Core v1.7 以降で使用できます。
コンテナ化を使用せずに Lambda 関数を実行する必要があるユースケースを除き、Greengrass コンテナで関数を実行することをお勧めします。Lambda 関数を Greengrass コンテナで実行する場合、アタッチされたローカルおよびデバイスリソースを使用することで、分離の利点とセキュリティの向上を得られます。コンテナ化を変更する場合は、事前に「[Lambda 関数のコンテナ化を選択する場合の考慮事項](#lambda-containerization-considerations)」を参照してください。
デバイスのカーネル名前空間および cgroup を有効化せずに実行するには、コンテナ化を使用しないですべての Lambda 関数を実行する必要があります。これを簡単に行うには、グループのデフォルトのコンテナ化を設定できます。詳細については、「[グループ内の Lambda 関数のコンテナ化のデフォルト設定](#lambda-containerization-groupsettings)」を参照してください。
**メモリ制限**
関数のメモリ割り当て。デフォルトでは 16 MB です。
コンテナ化を使用しないで実行するように Lambda 関数を変更すると、メモリ制限の設定は使用できなくなります。コンテナ化を使用せずに実行される Lambda 関数には、メモリ制限を設定することができません。コンテナ化を使用しないで実行するように Lambda 関数またはグループのデフォルトのコンテナ化設定を変更すると、メモリ制限の設定は破棄されます。
**タイムアウト**
関数あるいはリクエストが終了するまでの時間数。デフォルト値は 3 秒です。
**[Pinned]** (固定)
Lambda 関数のライフサイクルは、オンデマンドあるいは長い存続期間とすることができます。デフォルトはオンデマンドです。
オンデマンド Lambda 関数は、呼び出されたときに新規または再利用されるコンテナで開始します。関数に対するリクエストは、任意の利用可能なコンテナで処理される可能性があります。存続期間の長い、または*固定された* Lambda 関数は、 AWS IoT Greengrass が起動した後に自動的に開始され、独自のコンテナ (またはサンドボックス) で実行され続けます。関数へのすべてのリクエストは、同じコンテナで処理されます。詳細については、「[Greengrass Lambda 関数のライフサイクル設定](lambda-functions.md#lambda-lifecycle)」を参照してください。
**/sys ディレクトリへの読み込みアクセス**
関数がホストの /sys フォルダにアクセスできるかどうかを設定します。関数が /sys からデバイス情報を読み取る必要があるときに使用します。デフォルトは False です。
この設定は、コンテナ化を使用しないで Lambda 関数を実行する場合は使用できません。コンテナ化を使用しないで実行するように Lambda 関数を変更すると、この設定の値は破棄されます。
**[Encoding type]** (エンコードタイプ)
関数の入力ペイロードの予期されるエンコードタイプ (JSON あるいは バイナリ)。デフォルトは JSON です。
バイナリエンコーディングタイプのサポートは、 AWS IoT Greengrass Core Software v1.5.0 および AWS IoT Greengrass Core SDK v1.1.0 以降で利用できます。デバイスのハードウェア機能が制限されていているため、JSON データ型を構築することが難しいかできないことが多いので、バイナリ入力データを受け入れることは、関数がデバイスデータとやり取りするために便利です。
[Lambda 実行可能ファイル](lambda-functions.md#lambda-executables) は、バイナリエンコードタイプのみ (JSON ではなく) をサポートします。
**[Process arguments]** (プロセスの引数)
コマンドライン引数は、Lambda 関数の実行時に渡されます。
**環境変数**
関数コードとライブラリに設定を動的に渡すことができるキー値ペア。ローカル環境変数は [AWS Lambda 関数環境変数](https://docs.aws.amazon.com/lambda/latest/dg/env_variables.html)と同様に動作しますが、Core 環境で利用可能です。
[**リソースアクセスポリシー**]
Lambda 関数がアクセスを許可される、最大で 10 個までの[ローカルリソース](access-local-resources.md)、[シークレットリソース](secrets.md)、および[機械学習リソース](ml-inference.md)と、対応する `read-only` または `read-write` アクセス許可のリスト。コンソールで、これらのアフィリエイトリソースは、**[Resources]** (リソース) タブのグループ設定ページに掲載されています。
[コンテナ化モード](#lambda-function-containerization)は、Lambda 関数がローカルデバイスとボリュームリソース、機械学習リソースにアクセスする方法に影響します。
+ コンテナ化されていない Lambda 関数は、コアデバイス上のファイルシステムを介してローカルデバイスおよびボリュームリソースに直接アクセスする必要があります。
+ コンテナ化されていない Lambda 関数が Greengrass グループ内の機械学習リソースにアクセスできるようにするには、機械学習リソースでリソースの所有者とアクセス権限のプロパティを設定する必要があります。詳細については、「[Lambda 関数から機械学習リソースにアクセスする](access-ml-resources.md)」を参照してください。
AWS IoT Greengrass API を使用してユーザー定義の Lambda 関数のグループ固有の設定を行う方法については、*AWS IoT Greengrass Version 1 「 API リファレンス*」の[CreateFunctionDefinition](https://docs.aws.amazon.com/greengrass/v1/apireference/createfunctiondefinition-post.html)」または*AWS CLI 「 コマンドリファレンス*」の[create-function-definition](https://docs.aws.amazon.com/cli/latest/reference/greengrass/create-function-definition.html)」を参照してください。Greengrass コアに Lambda 関数をデプロイするには、関数を含む関数定義バージョンを作成し、関数定義バージョンと他のグループコンポーネントを参照するグループバージョンを作成してから、[グループをデプロイ](deployments.md)します。
## root としての Lambda 関数の実行
この機能は AWS IoT Greengrass Core v1.7 以降で使用できます。
1 つ以上の Lambda 関数をルートとして実行する前に、まず AWS IoT Greengrass 設定を更新してサポートを有効にする必要があります。デフォルトでは、root として Lambda 関数を実行するためのサポートはオフになっています。Lambda 関数をデプロイしてルート (UID と GID 0) として実行しようとし、 AWS IoT Greengrass 設定を更新していない場合、デプロイは失敗します。ランタイムログ (*greengrass\$1root*/ggc/var/log/system/runtime.log) に以下のようなエラーが表示されます。
```
lambda(s)
[list of function arns] are configured to run as root while Greengrass is not configured to run lambdas with root permissions
```
**重要**
やむを得ない場合を除き、Lambda 関数を root として実行することは避けてください。root として実行すると、次のリスクが増加します。
重要なファイルを誤って削除するなど、意図しない変更が行われるリスク。
悪意のあるユーザーがデータやデバイスにアクセスするリスク。
Docker コンテナが `--net=host` や `UID=EUID=0` で実行されると、コンテナがエスケープするリスク。
**root として実行することを Lambda 関数に許可するには**
1. AWS IoT Greengrass デバイスで、*greengrass-root*/config フォルダに移動します。
**注記**
デフォルトでは、*greengrass-root* は /greengrass ディレクトリです。
1. config.json ファイルを編集し、`"allowFunctionsToRunAsRoot" : "yes"` を `runtime` フィールドに追加します。例えば、次のようになります。
```
{
"coreThing" : {
...
},
"runtime" : {
...
"allowFunctionsToRunAsRoot" : "yes"
},
...
}
```
1. 再起動するには、次のコマンドを使用します AWS IoT Greengrass。
```
cd /greengrass/ggc/core
sudo ./greengrassd restart
```
これで Lambda 関数のユーザー ID とグループ ID (UID/GID) を 0 に設定し、root として Lambda 関数を実行できます。
Lambda 関数をルートとして実行することを許可 AWS IoT Greengrass しない場合は、 の値を に変更`"allowFunctionsToRunAsRoot"``"no"`して再起動できます。
## Lambda 関数のコンテナ化を選択する場合の考慮事項
この機能は AWS IoT Greengrass Core v1.7 以降で使用できます。
デフォルトでは、Lambda 関数は AWS IoT Greengrass コンテナ内で実行されます。このコンテナにより、関数とホストが分離され、ホストとコンテナ内の関数の両方でセキュリティが向上します。
コンテナ化を使用せずに Lambda 関数を実行する必要があるユースケースを除き、Greengrass コンテナで関数を実行することをお勧めします。Greengrass コンテナで Lambda 関数を実行することで、リソースへのアクセスを制限する方法をより細かく制御できます。
コンテナ化を使用しないで実行するユースケースの例:
+ コンテナモードをサポートしていない AWS IoT Greengrass デバイスで を実行する場合 (特別な Linux ディストリビューションを使用しているか、カーネルバージョンが古すぎるなど）。
+ 独自の OverlayFS がある別のコンテナ環境の Lambda 関数を、Greengrass コンテナで実行すると、OverlayFS の競合が発生する場合。
+ アクセス先のローカルリソースのパスがデプロイ時に決定できないか、デプロイ後に変わることがある場合 (プラガブルデバイスなど)。
+ プロセスとして記述されたレガシーアプリケーションがあり、これをコンテナ化された Lambda 関数として実行するときに問題が発生する場合。
**コンテナ化の相違点**
| コンテナ化 | 注意事項 |
| --- | --- |
| Greengrass コンテナ | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/greengrass/v1/developerguide/lambda-group-config.html) |
| コンテナなし | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/greengrass/v1/developerguide/lambda-group-config.html) |
**注記**
Greengrass グループの既定のコンテナ化設定は、[コネクタ](connectors.md)には適用されません。
Lambda 関数のコンテナ化を変更すると、デプロイ時に問題が発生する場合があります。ローカルリソースを割り当てた Lambda 関数が新しいコンテナ化の設定で使用できなくなった場合、デプロイは失敗します。
+ Greengrass コンテナでの実行からコンテナ化を使用しない実行へと Lambda 関数を変更すると、関数のメモリ制限は破棄されます。アタッチ済みのローカルリソースを使用する代わりに、ファイルシステムに直接アクセスする必要があります。デプロイする前に、すべてのアタッチ済みリソースを削除する必要があります。
+ コンテナ化を使用しない実行からコンテナでの実行へと Lambda 関数を変更すると、Lambda 関数はファイルシステムに直接アクセスできなくなります。関数ごとにメモリ制限を定義するか、デフォルトの 16 MB を受け入れる必要があります。これらの設定は、デプロイ前に Lambda 関数ごとに構成できます。
**Lambda 関数のコンテナ化の設定を変更するには**
1. AWS IoT コンソールナビゲーションペインの**「管理**」で **Greengrass デバイス**を展開し、**「グループ (V1)**」を選択します。
1. 設定を変更する Lambda 関数が含まれているグループを選択します。
1. **[Lambda functions]** (Lambda 関数) タブを選択します。
1. 変更する Lambda 関数で、省略記号 (**…**) を選択し、次に **[Edit configuration]** (設定の編集) を選択します。
1. コンテナ化の設定を変更します。Greengrass コンテナで実行するように Lambda 関数を設定する場合は、**[Memory limit]** (メモリ制限) と **[Read access to /sys directory]** (/sys ディレクトリへの読み込みアクセス) も設定する必要があります。
1. **[Save]** (保存) を選択してから **[Confirm]** (確認) を選択して Lambda 関数への変更を保存します。
変更は、グループのデプロイ時に反映されます。
また、「AWS IoT Greengrass API リファレンス」の「[CreateFunctionDefinition](https://docs.aws.amazon.com/greengrass/v1/apireference/createfunctiondefinition-post.html)」および「[CreateFunctionDefinitionVersion](https://docs.aws.amazon.com/greengrass/v1/apireference/createfunctiondefinitionversion-post.html)」を使用することもできます。コンテナ化の設定を変更する場合は、他のパラメータも必ず更新してください。例えば、Lambda 関数を Greengrass コンテナでの実行からコンテナ化を使用しない実行へと変更する場合は、`MemorySize` パラメータを必ずクリアします。
### Greengrass デバイスでサポートされている分離モードの確認
AWS IoT Greengrass 依存関係チェッカーを使用して、Greengrass デバイスでサポートされている分離モード (Greengrass コンテナ/コンテナなし) を判断できます。
**AWS IoT Greengrass 依存関係チェッカーを実行するには**
1. [GitHub リポジトリ](https://github.com/aws-samples/aws-greengrass-samples)から AWS IoT Greengrass 依存関係チェッカーをダウンロードして実行します。
```
wget https://github.com/aws-samples/aws-greengrass-samples/raw/master/greengrass-dependency-checker-GGCv1.11.x.zip
unzip greengrass-dependency-checker-GGCv1.11.x.zip
cd greengrass-dependency-checker-GGCv1.11.x
sudo modprobe configs
sudo ./check_ggc_dependencies | more
```
1. 「`more`」と表示された場合は、Spacebar キーを押して別のページのテキストを表示します。
**modprobe** コマンドの詳細については、ターミナルで **man modprobe** を実行してください。
## グループ内の Lambda 関数に対するデフォルトのアクセス ID の設定
この機能は Core AWS IoT Greengrass v1.8 以降で使用できます。
デバイスリソースへのアクセスをより細かく制御するために、グループ内で Lambda 関数を実行するために使用されるデフォルトのアクセス ID を設定できます。この設定は、Lambda 関数がコアデバイスで実行されたときに付与されるデフォルトのアクセス許可を決定します。グループ内の個々の関数の設定を上書きするには、その関数の [**Run as (として実行)**] プロパティを使用できます。詳細については、「[Run as](#lambda-access-identity)」を参照してください。
このグループレベルの設定は、基盤となる AWS IoT Greengrass Core ソフトウェアの実行にも使用されます。これは、メッセージルーティング、ローカルシャドウ同期、および自動 IP アドレス検出などのオペレーションを管理するシステム Lambda 関数で構成されます。
デフォルトのアクセスアイデンティティは、標準 AWS IoT Greengrass システムアカウント (ggc\$1user および ggc\$1group) として実行するか、別のユーザーまたはグループのアクセス許可を使用するように設定できます。Greengrass ハードウェアの設定では、適切なリソース制限、適切なファイルへのアクセス許可、およびユーザー定義またはシステム Lambda 関数を実行するために使用されるアクセス許可を持つユーザーとグループの適切なディスククォータを使用することをお勧めします。
**AWS IoT Greengrass グループのデフォルトのアクセスアイデンティティを変更するには**
1. AWS IoT コンソールナビゲーションペインの**「管理**」で **Greengrass デバイス**を展開し、**「グループ (V1)**」を選択します。
1. 設定を変更するグループを選択します。
1. **[Lambda functions]** (Lambda 関数) タブを選択し、**[Default Lambda function runtime environment]** (デフォルトの Lambda 関数ランタイム環境)セクションで **[Edit]** (編集) を選択します。
1. **[Edit default Lambda function runtime environment]** (デフォルトの Lambda 関数ランタイム環境の編集) ページの **[Default system user and group] (デフォルトシステムユーザーおよびグループ)** で、**[Another user ID/group ID]** (別のユーザー ID とグループ ID) を選択します。
このオプションを選択すると、**[System user ID (number)]** (システムユーザー ID (数値)) および **[System group ID (number)]** (システムグループ ID (数値)) フィールドが表示されます。
1. ユーザー ID、グループ ID、またはその両方を入力します。フィールドを空白のままにすると、それぞれの Greengrass システムアカウント (ggc\$1user または ggc\$1group) が使用されます。
+ **[System user ID (number)]** (システムユーザー ID (数値)) で、グループ内で Lambda 関数を実行するためにデフォルトで使用するアクセス許可を持つユーザーのユーザー ID を入力します。 AWS IoT Greengrass デバイスで **getent passwd** コマンドを使用して、ユーザー ID を検索できます。
+ **[System group ID (number)]** (システムグループ ID (数値)) で、グループ内で Lambda 関数を実行するためにデフォルトで使用するアクセス許可を持つグループのグループ ID を入力します。 AWS IoT Greengrass デバイスで **getent group** コマンドを使用して、グループ ID を検索できます。
**重要**
root ユーザーとして実行すると、データとデバイスに対するリスクが増大します。ビジネスケースで要求されている場合を除き、root (UID/GID=0) として実行しないでください。詳細については、「[root としての Lambda 関数の実行](#lambda-running-as-root)」を参照してください。
変更は、グループのデプロイ時に反映されます。
## グループ内の Lambda 関数のコンテナ化のデフォルト設定
この機能は AWS IoT Greengrass Core v1.7 以降で使用できます。
Greengrass グループのコンテナ化設定によって、グループ内の Lambda 関数のデフォルトのコンテナ化が決定されます。
+ **Greengrass コンテナ**モードでは、Lambda 関数はデフォルトで AWS IoT Greengrass コンテナ内の分離されたランタイム環境で実行されます。
+ **コンテナなし**モードでは、Lambda 関数はデフォルトで通常の Linux プロセスとして実行されます。
グループ設定を変更して、グループ内の Lambda 関数のデフォルトのコンテナ化を指定できます。グループのデフォルトとは異なるコンテナ化を使用して Lambda 関数を実行する場合は、グループ内の 1 つ以上の Lambda 関数について、この設定を上書きできます。コンテナ化の設定を変更する場合は、事前に「[Lambda 関数のコンテナ化を選択する場合の考慮事項](#lambda-containerization-considerations)」を参照してください。
**重要**
グループのデフォルトのコンテナ化を変更する際に、一部の関数で別のコンテナ化を使用するという場合は、グループの設定を変更する前に Lambda 関数の設定を変更します。グループのコンテナ化の設定を最初に変更すると、[**メモリ制限**] と [**/sys ディレクトリへの読み込みアクセス**] に設定した値は破棄されます。
**AWS IoT Greengrass グループのコンテナ化設定を変更するには**
1. AWS IoT コンソールナビゲーションペインの**「管理**」で **Greengrass デバイス**を展開し、**「グループ (V1)**」を選択します。
1. 設定を変更するグループを選択します。
1. **[Lambda functions]** (Lambda 関数) タブを選択します。
1. **[Default Lambda function runtime environment]** (デフォルトの Lambda 関数ランタイム環境) から、**[Edit]** (編集) を選択します。
1. **[Edit default Lambda function runtime environment]** (デフォルトの Lambda 関数ランタイム環境を編集する) ページの、**[Default Lambda function containerization]** (デフォルトの Lambda 関数のコンテナ化) でコンテナ化の設定を変更します。
1. **[保存]** を選択します。
変更は、グループのデプロイ時に反映されます。
## Greengrass Lambda 関数のコミュニケーションフロー
Greengrass Lambda 関数は、 AWS IoT Greengrass グループの他のメンバー、ローカルサービス、クラウドサービス ( AWS サービスを含む) と通信するいくつかの方法をサポートしています。
### MQTT メッセージを使用した通信
Lambda 関数は、サブスクリプションによって制御される発行 - サブスクリプションパターンを使用して MQTT メッセージを送受信できます。
このコミュニケーションフローにより、Lambda 関数は以下のエンティティとメッセージを交換することができる。
+ グループ内のクライアントデバイス。
+ グループのコネクタ。
+ グループ内の他の Lambda 関数。
+ AWS IoT.
+ ローカルデバイスシャドウサービス。
サブスクリプションは、メッセージ送信元、メッセージターゲット、および送信元からターゲットへのメッセージのルーティングに使用されるトピック (または件名) を定義します。Lambda 関数に発行されるメッセージは、関数に登録されたハンドラに渡されます。サブスクリプションはより高度なセキュリティを可能にし、予測可能なやり取りを提供します。詳細については、「[MQTT メッセージングワークフローにおけるマネージドサブスクリプション](gg-sec.md#gg-msg-workflow)」を参照してください。
**注記**
Greengrass Lambda 関数は、クライアントデバイス、コネクタ、他の関数、およびコアがオフラインのときにローカルシャドウとメッセージを交換できますが、 AWS IoT へのメッセージはキュー状態になります。詳細については、「[クラウドターゲットの MQTT メッセージキュー](gg-core.md#mqtt-message-queue)」を参照してください。
### 他の通信フロー
+ コアデバイスでローカルデバイスおよびボリュームリソース、機械学習モデルとやり取りするため、Greengrass Lambda 関数はプラットフォーム固有のオペレーティングシステムインターフェイスを使用します。例えば、Python 関数で [os](https://docs.python.org/2/library/os.html) モジュールの `open` メソッドを使用できます。関数がリソースにアクセスすることを許可するには、この関数がリソースに*関連*し、`read-only` あるいは `read-write` アクセス許可を付与されていることが必要です。 AWS IoT Greengrass コアバージョンの可用性などの詳細については、[Lambda 関数とコネクタを使用してローカルリソースにアクセスする](access-local-resources.md)「」および「」を参照してください[Lambda 関数コードから機械学習リソースにアクセスする](access-ml-resources.md#access-resource-function-code)。
**注記**
コンテナ化せずに Lambda 関数を実行する場合、アタッチされたローカルデバイスおよびボリュームリソースを使用することはできず、直接それらのリソースにアクセスする必要があります。
+ Lambda 関数は、 AWS IoT Greengrass Core SDK の `Lambda`クライアントを使用して、Greengrass グループ内の他の Lambda 関数を呼び出すことができます。
+ Lambda 関数は AWS SDK を使用して AWS サービスと通信できます。詳細については、「[AWS SDK](#aws-sdk)」をご参照ください。
+ Lambda 関数は、クラウドベースの Lambda 関数のように、サードパーティーのインターフェイスを使用して外部のクラウドサービスと通信できます。
**注記**
Greengrass Lambda 関数は、コアがオフラインのときに AWS や他のクラウドサービスと通信できません。
## 入力 MQTT トピック (または件名) の取得
AWS IoT Greengrass はサブスクリプションを使用して、グループ内のクライアントデバイス、Lambda 関数、コネクタ間、および AWS IoT またはローカルシャドウサービスとの MQTT メッセージの交換を制御します。サブスクリプションは、メッセージソース、メッセージターゲット、およびメッセージのルーティングに使用される MQTT トピックを定義します。ターゲットが Lambda 関数の場合、ソースがメッセージを発行すると、関数のハンドラが呼び出されます。詳細については、「[MQTT メッセージを使用した通信](#lambda-messages)」を参照してください。
次の例は、Lambda 関数がハンドラに渡された `context` から入力トピックを取得する方法を示しています。これを行うには、コンテキスト階層から `subject` キーにアクセスします (`context.client_context.custom['subject']`)。この例では、入力 JSON メッセージも解析してから、解析したトピックとメッセージを発行します。
**注記**
AWS IoT Greengrass API では、[サブスクリプション](https://docs.aws.amazon.com/greengrass/v1/apireference/definitions-subscription.html)のトピックは `subject`プロパティで表されます。
```
import greengrasssdk
import logging
client = greengrasssdk.client('iot-data')
OUTPUT_TOPIC = 'test/topic_results'
def get_input_topic(context):
try:
topic = context.client_context.custom['subject']
except Exception as e:
logging.error('Topic could not be parsed. ' + repr(e))
return topic
def get_input_message(event):
try:
message = event['test-key']
except Exception as e:
logging.error('Message could not be parsed. ' + repr(e))
return message
def function_handler(event, context):
try:
input_topic = get_input_topic(context)
input_message = get_input_message(event)
response = 'Invoked on topic "%s" with message "%s"' % (input_topic, input_message)
logging.info(response)
except Exception as e:
logging.error(e)
client.publish(topic=OUTPUT_TOPIC, payload=response)
return
```
関数をテストするには、デフォルトの設定を使用してグループに追加します。次に、以下のサブスクリプションを追加し、グループをデプロイします。手順については、「[モジュール 3 (パート 1): での Lambda 関数 AWS IoT Greengrass](module3-I.md)」を参照してください。
****
| ソース | ターゲット | トピックのフィルター |
| --- | --- | --- |
| IoT クラウド | この関数 | test/input\$1message |
| この関数 | IoT クラウド | test/topic\$1results |
デプロイが完了したら、関数を呼び出します。
1. AWS IoT コンソールで、**MQTT テストクライアント**ページを開きます。
1. **[Subscribe to a topic]** (トピックへのサブスクライブ) タブを選択して、`test/topic_results` をサブスクライブします。
1. **[Publish to a topic]** (トピックへの発行) タブを選択して `test/input_message` トピックを発行します。この例では、JSON メッセージに `test-key` プロパティを含める必要があります。
```
{
"test-key": "Some string value"
}
```
成功した場合、関数は入力トピックとメッセージ文字列を `test/topic_results` トピックに発行します。
## Greengrass Lambda 関数のライフサイクル設定
Greengrass Lambda 関数ライフサイクルは、関数が開始する時期とどのようにコンテナを作成して使用するかを定義します。また、ライフサイクルは関数ハンドラの外部にある変数および処理中のロジックが保持されるかを定義します。
AWS IoT Greengrass は、オンデマンド (デフォルト) または存続期間の長いライフサイクルをサポートします。
+ **オンデマンド** 関数は、呼び出されたときに起動し、実行するタスクが残っていないときに停止します。関数の呼び出しは、再使用できる既存のコンテナが利用可能な場合を除き、呼び出し処理に別のコンテナ (またはサンドボックス) を作成します。関数に送信されたデータは、いずれかのコンテナによってプルされる可能性があります。
関数の複数の呼び出しは、同時に実行できます。
関数ハンドラの外部で定義される変数や前処理ロジックは、新しいコンテナが作成されるときに保持されません。
+ **存続期間の長い** (または*固定された*) 関数は、 AWS IoT Greengrass コアが 1 つのコンテナで起動および実行されると自動的に開始されます。関数に送信されたすべてのデータは、同じコンテナによってプルされます。
複数の呼び出しは、前の呼び出しが実行されるまでキュー状態になります。
関数ハンドラの外部で定義される変数と事前処理ロジックは、このハンドラの毎回の呼び出しのために保持されます。
長い存続期間の Lambda 関数は、初期の入力が全くない実行を開始する必要がある場合に便利です。例えば、存続期間が長い関数は、関数がデバイスデータの受信を開始するときに備えて、ML モデルをロードして処理を開始できます。
**注記**
長い存続期間の関数には、そのハンドラの呼び出しに関連付けられたタイムアウトがあることに注意してください。実行中のコードを無期限で実行する場合には、ハンドラ外でこれを開始する必要があります。関数の初期化の完了を妨害するようなハンドラ外のブロックコードがないことを確認します。
これらの関数は、コアが停止する (グループのデプロイ中やデバイスの再起動中など) か、関数がエラー状態 (ハンドラのタイムアウト、キャッチされない例外、またはメモリ制限を超えたときなど) にならない限り実行されます。
コンテナの再利用の詳細については、 AWS コンピューティングブログの[「 でのコンテナの再利用について AWS Lambda](https://aws.amazon.com/blogs/compute/container-reuse-in-lambda/)」を参照してください。
## Lambda 実行可能ファイル
この機能は AWS IoT Greengrass Core v1.6 以降で使用できます。
Lambda 実行可能ファイルは、コア環境でバイナリコードを実行するために使用できる Greengrass Lambda 関数の一種です。これによって、デバイス固有の機能を実行することができ、コンパイルされたコードの小さなフットプリントの利点を活用できます。Lambda 実行可能ファイルは、イベントによる呼び出し、他の関数の呼び出し、そしてローカルリソースにアクセスが可能です。
Lambda 実行可能ファイルはバイナリエンコードタイプのみ (JSON ではなく) をサポートします。それ以外では、Greengrass グループで管理し、他の Greengrass Lambda 関数のようにデプロイできます。ただし、Lambda 実行可能ファイルを作成するプロセスは、Python、Java、および Node.js の Lambda 関数とは異なります。
+ AWS Lambda コンソールを使用して Lambda 実行可能ファイルを作成 (または管理) することはできません。Lambda 実行可能ファイルは、 AWS Lambda API を使用してのみ作成できます。
+ Core [AWS IoT Greengrass SDK for C](https://github.com/aws/aws-greengrass-core-sdk-c) を含むコンパイルされた実行可能ファイル AWS Lambda として、関数コードを にアップロードします。
+ 実行可能ファイル名を関数のハンドラとして指定します。
Lambda 実行可能ファイルでは、その関数コードに特定の呼び出しおよびプログラミングパターンが実装されている必要があります。例えば、`main` メソッドは次を満たす必要があります。
+ Greengrass 内部グローバル変数を初期化する `gg_global_init` 呼び出し。この関数は、スレッドを作成する前、および他の AWS IoT Greengrass Core SDK 関数を呼び出す前に呼び出す必要があります。
+ Greengrass Lambda ランタイムに関数ハンドラを登録する `gg_runtime_start` の呼び出し。この関数は初期化中に呼び出す必要があります。この関数を呼び出すと、現在のスレッドはランタイムで使用されます。オプションの `GG_RT_OPT_ASYNC` パラメータはこの関数をブロックしませんが、代わりにランタイムに新規のスレッドを作成します。この関数は `SIGTERM` ハンドラを使用します。
次のスニペットは、GitHub の `main`simple\$1handler.c[ コード例の ](https://github.com/aws/aws-greengrass-core-sdk-c/blob/master/aws-greengrass-core-sdk-c-example/simple_handler.c) メソッドです。
```
int main() {
gg_error err = GGE_SUCCESS;
err = gg_global_init(0);
if(err) {
gg_log(GG_LOG_ERROR, "gg_global_init failed %d", err);
goto cleanup;
}
gg_runtime_start(handler, 0);
cleanup:
return -1;
}
```
実装の要件や制限などの詳細については、「[AWS IoT Greengrass Core SDK for C](https://github.com/aws/aws-greengrass-core-sdk-c)」を参照してください。
### Lambda 実行可能ファイルを作成する
SDK とともにコードをコンパイルしたら、 AWS Lambda API を使用して Lambda 関数を作成し、コンパイルした実行可能ファイルをアップロードします。
**注記**
関数は、C89 互換性のあるコンパイラーでコンパイルする必要があります。
次の例では、[create-function](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-function.html) CLI コマンドを使用して、Lambda 実行可能ファイルを作成します。このコマンドは以下を指定します。
+ ハンドラの実行可能ファイルの名前。これは、コンパイルされた実行可能ファイルの正確な名前である必要があります。
+ コンパイルされた実行可能ファイルを含む `.zip` ファイルへのパス。
+ ランタイムの `arn:aws:greengrass:::runtime/function/executable`。これはすべて Lambda 実行可能ファイルのランタイムです。
**注記**
`role` では、任意の Lambda 実行ロールの ARN を指定できます。 AWS IoT Greengrass はこのロールを使用しませんが、関数を作成するにはパラメータが必要です。Lambda 実行可能ファイルのロールの詳細については、「AWS Lambda デベロッパーガイド」の「[AWS Lambda アクセス権限モデル](https://docs.aws.amazon.com/lambda/latest/dg/intro-permission-model.html)」を参照してください。
```
aws lambda create-function \
--region aws-region \
--function-name function-name \
--handler executable-name \
--role role-arn \
--zip-file fileb://file-name.zip \
--runtime arn:aws:greengrass:::runtime/function/executable
```
次に、 AWS Lambda API を使用してバージョンを発行し、エイリアスを作成します。
+ [publish-version](https://docs.aws.amazon.com/cli/latest/reference/lambda/publish-version.html) を使用して、関数バージョンを発行します。
```
aws lambda publish-version \
--function-name function-name \
--region aws-region
```
+ [create-alias](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-alias.html) を使用して、先ほど発行したバージョンを指すエイリアスを作成します。Greengrass グループ に Lambda 関数を追加する場合、この関数をエイリアスで参照することが推奨されます。
```
aws lambda create-alias \
--function-name function-name \
--name alias-name \
--function-version version-number \
--region aws-region
```
**注記**
AWS Lambda コンソールには Lambda 実行可能ファイルは表示されません。関数コードを更新するには、 AWS Lambda API を使用する必要があります。
次に、Lambda 実行可能ファイルを Greengrass グループに追加し、このグループ固有の設定でバイナリ入力データを受け入れるように設定して、グループをデプロイします。これは、 AWS IoT Greengrass コンソールまたは AWS IoT Greengrass API を使用して実行できます。
# Docker コンテナ AWS IoT Greengrass での実行
AWS IoT Greengrass は、[Docker](https://www.docker.com/) コンテナで実行するように設定できます。
AWS IoT Greengrass Core ソフトウェアと依存関係がインストールされている Dockerfile は、[Amazon CloudFront から](what-is-gg.md#gg-docker-download)ダウンロードできます。Docker イメージを変更してさまざまなプラットフォームアーキテクチャで実行するか、Docker イメージのサイズを小さくするには、Docker パッケージダウンロードの `README` ファイルを参照してください。
の実験を開始できるように AWS IoT Greengrass、 には AWS IoT Greengrass Core ソフトウェアと依存関係がインストールされている構築済みの Docker イメージ AWS も用意されています。イメージは、[Docker Hub](https://hub.docker.com/r/amazon/aws-iot-greengrass) または [Amazon Elastic Container Registry](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html)(Amazon ECR) からダウンロードできます。これらの構築済みのイメージでは、Amazon Linux 2 (x86\$164) および Alpine Linux (x86\$164、Armv7l、または AArch64) のベースイメージを使用します。
**重要**
2022 年 6 月 30 日、 は、Amazon Elastic Container Registry (Amazon ECR) と Docker Hub に公開された AWS IoT Greengrass Core ソフトウェア v1.x Docker イメージのメンテナンス AWS IoT Greengrass を終了しました。これらの Docker イメージは、メンテナンス終了から 1 年後の 2023 年 6 月 30 日まで、Amazon ECR および Docker Hub から引き続きダウンロードすることができます。ただし、2022 年 6 月 30 日のメンテナンス終了後、 AWS IoT Greengrass Core ソフトウェア v1.x Docker イメージはセキュリティパッチやバグ修正を受け取らなくなりました。これらの Docker イメージに依存する本稼働ワークロードを実行する場合は、 AWS IoT Greengrass が提供する Dockerfiles を使用して独自の Docker イメージを構築することをお勧めします。詳細については、「[AWS IoT Greengrass Docker ソフトウェア](what-is-gg.md#gg-docker-download)」を参照してください。
このトピックでは、Amazon ECR から AWS IoT Greengrass Docker イメージをダウンロードし、Windows、macOS、または Linux (x86\$164) プラットフォームで実行する方法について説明します。以下の各ステップを示します。
1. [Amazon ECR から AWS IoT Greengrass コンテナイメージを取得する](#docker-pull-image)
1. [Greengrass のグループとコアを作成して設定する](#docker-config-gg)
1. [ AWS IoT Greengrass ローカルで を実行する](#docker-run-gg)
1. [グループの「コンテナなし」コンテナ化を設定する](#docker-no-container)
1. [Lambda 関数を Docker コンテナにデプロイする](#docker-add-lambdas)
1. [(オプション) Docker コンテナで Greengrass を操作するクライアントデバイスをデプロイする](#docker-add-devices)
Docker コンテナ AWS IoT Greengrass で を実行する場合、以下の機能はサポートされていません。
+ **[Greengrass container]** (Greengrass コンテナ) モードで実行される[コネクタ](connectors.md)。Docker コンテナでコネクタを実行するには、コネクタを**コンテナなし**モードで実行する必要があります。**コンテナなし**モードをサポートするコネクタを検索するには、「[AWSが提供する Greengrass コネクタ](connectors-list.md)」を参照してください。これらのコネクタの一部では、分離モードパラメータを使用されており、[**コンテナなし**] に設定する必要があります。
+ [ローカルデバイスおよびボリュームリソース](access-local-resources.md)。Docker コンテナで実行されるユーザー定義 Lambda 関数は、コア上のデバイスとボリュームに直接アクセスする必要があります。
これらの機能は、Greengrass グループの Lambda ランタイム環境が、Docker [コンテナで実行するために必要なコンテナなし](lambda-group-config.md#no-container-mode)に設定されている場合はサポートされていません。 AWS IoT Greengrass
## 前提条件
このチュートリアルを開始する前に、以下を実行する必要があります。
+ 選択した AWS Command Line Interface (AWS CLI) バージョンに基づいて、ホストコンピュータに次のソフトウェアとバージョンをインストールする必要があります。
------
#### [ AWS CLI version 2 ]
+ [Docker](https://docs.docker.com/install/) バージョン 18.09 以降。以前のバージョンでも動作する可能性がありますが、18.09 以降を推奨します。
+ AWS CLI バージョン 2.0.0 以降。
+ AWS CLI バージョン 2 をインストールするには、[「バージョン 2 AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html)のインストール」を参照してください。
+ を設定するには AWS CLI、[「 の設定 AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html)」を参照してください。
**注記**
Windows コンピュータで新しい AWS CLI バージョン 2 にアップグレードするには、[MSI のインストール](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2-windows.html)プロセスを繰り返す必要があります。
------
#### [ AWS CLI version 1 ]
+ [Docker](https://docs.docker.com/install/) バージョン 18.09 以降。以前のバージョンでも動作する可能性がありますが、18.09 以降を推奨します。
+ [Python](https://www.python.org/downloads/) バージョン 3.6 以降。
+ [pip](https://pip.pypa.io/en/stable/installing) バージョン 18.1 以降。
+ AWS CLI バージョン 1.17.10 以降
+ AWS CLI バージョン 1 をインストールするには、[「バージョン 1 AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv1.html)のインストール」を参照してください。
+ を設定するには AWS CLI、[「 の設定 AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html)」を参照してください。
+ バージョン 1 AWS CLI の最新バージョンにアップグレードするには、次のコマンドを実行します。
```
pip install awscli --upgrade --user
```
**注記**
Windows で AWS CLI バージョン 1 の [MSI インストール](https://docs.aws.amazon.com/cli/latest/userguide/install-windows.html#msi-on-windows)を使用する場合は、次の点に注意してください。
AWS CLI バージョン 1 のインストールで botocore のインストールに失敗した場合は、[Python と pip のインストール](https://docs.aws.amazon.com/cli/latest/userguide/awscli-install-windows.html#awscli-install-windows-pip)を試してください。
新しい AWS CLI バージョン 1 にアップグレードするには、MSI のインストールプロセスを繰り返す必要があります。
------
+ ユーザーが Amazon Elastic Container Registry (Amazon ECR) のリソースにアクセスできるようにするには、次のアクセス権限を付与する必要があります。
+ Amazon ECR では、レジストリに対して認証し、Amazon ECR リポジトリからイメージをプッシュまたはプルする前に、 AWS Identity and Access Management (IAM) ポリシーを通じてアクセス`ecr:GetAuthorizationToken`許可を付与する必要があります。詳細については、「Amazon ECR ユーザーガイド」の「[Amazon ECR Repository Policy Examples](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-policy-examples.html)」(Amazon ECR リポジトリポリシーの例) および「[1 つの Amazon ECR リポジトリにアクセスする](https://docs.aws.amazon.com/AmazonECR/latest/userguide/security_iam_id-based-policy-examples.html#security_iam_id-based-policy-examples-access-one-bucket)」を参照してください。
## ステップ 1: Amazon ECR から AWS IoT Greengrass コンテナイメージを取得する
AWS には、 AWS IoT Greengrass Core ソフトウェアがインストールされている Docker イメージが用意されています。
**警告**
AWS IoT Greengrass Core ソフトウェアの v1.11.6 以降、Greengrass Docker イメージには Python 2.7 が含まれなくなりました。Python 2.7 は end-of-lifeし、セキュリティ更新プログラムを受け取らなくなったためです。これらの Docker イメージに更新する場合は、アプリケーションが新しい Docker イメージで動作することを検証した後に、アップデートを本番デバイスに展開することをお勧めします。Greengrass Docker イメージを使用するアプリケーションに Python 2.7 が必要な場合は、Greengrass Dockerfile を変更して、アプリケーションに Python 2.7 を含めることができます。
Amazon ECR から `latest` イメージをプルする方法については、お使いのオペレーティングシステムを選択してください。
### コンテナイメージをプルする (Linux)
コンピュータのターミナルで以下のコマンドを実行します。
1. Amazon ECR の AWS IoT Greengrass レジストリにログインします。
```
aws ecr get-login-password --region us-west-2 | docker login --username AWS --password-stdin https://216483018798.dkr.ecr.us-west-2.amazonaws.com
```
成功すると、`Login Succeeded` が出力されます。
1. AWS IoT Greengrass コンテナイメージを取得します。
```
docker pull 216483018798.dkr.ecr.us-west-2.amazonaws.com/aws-iot-greengrass:latest
```
**注記**
`latest` イメージには、Amazon Linux 2 ベースイメージにインストールされている最新の安定バージョンの AWS IoT Greengrass Core ソフトウェアが含まれています。他のイメージをリポジトリからプルすることもできます。使用可能なすべてのイメージを確認するには、[Docker Hub](https://hub.docker.com/r/amazon/aws-iot-greengrass) の **[Tags]** (タグ) ページを確認するか、**aws ecr list-images** コマンドを使用してください。例:
```
aws ecr list-images --region us-west-2 --registry-id 216483018798 --repository-name aws-iot-greengrass
```
1. シンボリックリンクとハードリンクの保護を有効にします。コンテナ AWS IoT Greengrass での実行を試している場合は、現在のブートの設定のみを有効にできます。
**注記**
これらのコマンドを実行するには、**sudo** を使用することが必要な場合があります。
+ 現在のブートに対してのみ設定を有効にするには、以下のコマンドを使用します。
```
echo 1 > /proc/sys/fs/protected_hardlinks
echo 1 > /proc/sys/fs/protected_symlinks
```
+ 再起動しても維持される設定を有効にするには、以下のコマンドを使用します。
```
echo '# AWS IoT Greengrass' >> /etc/sysctl.conf
echo 'fs.protected_hardlinks = 1' >> /etc/sysctl.conf
echo 'fs.protected_symlinks = 1' >> /etc/sysctl.conf
sysctl -p
```
1. AWS IoT Greengrass クラウドデプロイと MQTT 通信が Linux で動作するために必要な IPv4 ネットワーク転送を有効にします。`/etc/sysctl.conf` ファイルで、`net.ipv4.ip_forward` を 1 に設定して、`sysctls` を再ロードします。
```
sudo nano /etc/sysctl.conf
# set this net.ipv4.ip_forward = 1
sudo sysctl -p
```
**注記**
nano の代わりに任意のエディタを使用できます。
### コンテナイメージをプルする (macOS)
コンピュータのターミナルで以下のコマンドを実行します。
1. Amazon ECR の AWS IoT Greengrass レジストリにログインします。
```
aws ecr get-login-password --region us-west-2 | docker login --username AWS --password-stdin https://216483018798.dkr.ecr.us-west-2.amazonaws.com
```
成功すると、`Login Succeeded` が出力されます。
1. AWS IoT Greengrass コンテナイメージを取得します。
```
docker pull 216483018798.dkr.ecr.us-west-2.amazonaws.com/aws-iot-greengrass:latest
```
**注記**
`latest` イメージには、Amazon Linux 2 ベースイメージにインストールされている最新の安定バージョンの AWS IoT Greengrass Core ソフトウェアが含まれています。他のイメージをリポジトリからプルすることもできます。使用可能なすべてのイメージを確認するには、[Docker Hub](https://hub.docker.com/r/amazon/aws-iot-greengrass) の **[Tags]** (タグ) ページを確認するか、**aws ecr list-images** コマンドを使用してください。例:
```
aws ecr list-images --region us-west-2 --registry-id 216483018798 --repository-name aws-iot-greengrass
```
### コンテナイメージをプルする (Windows)
コマンドプロンプトで次のコマンドを実行します。Windows で Docker コマンドを使用する前に、Docker デスクトップが実行されている必要があります。
1. Amazon ECR の AWS IoT Greengrass レジストリにログインします。
```
aws ecr get-login-password --region us-west-2 | docker login --username AWS --password-stdin https://216483018798.dkr.ecr.us-west-2.amazonaws.com
```
成功すると、`Login Succeeded` が出力されます。
1. AWS IoT Greengrass コンテナイメージを取得します。
```
docker pull 216483018798.dkr.ecr.us-west-2.amazonaws.com/aws-iot-greengrass:latest
```
**注記**
`latest` イメージには、Amazon Linux 2 ベースイメージにインストールされている最新の安定バージョンの AWS IoT Greengrass Core ソフトウェアが含まれています。他のイメージをリポジトリからプルすることもできます。使用可能なすべてのイメージを確認するには、[Docker Hub](https://hub.docker.com/r/amazon/aws-iot-greengrass) の **[Tags]** (タグ) ページを確認するか、**aws ecr list-images** コマンドを使用してください。例:
```
aws ecr list-images --region us-west-2 --registry-id 216483018798 --repository-name aws-iot-greengrass
```
## ステップ 2: Greengrass のグループとコアを作成して設定する
Docker イメージには AWS IoT Greengrass Core ソフトウェアがインストールされていますが、Greengrass グループとコアを作成する必要があります。これには、証明書とコア設定ファイルのダウンロードが含まれます。
+ 「[モジュール 2: AWS IoT Greengrass Core ソフトウェアのインストール](module2.md)」のステップを実行してください。 AWS IoT Greengrass Core ソフトウェアをダウンロードして実行するステップをスキップします。このソフトウェアとその実行時の依存関係は、Docker イメージにセットアップ済みです。
## ステップ 3: AWS IoT Greengrass ローカルで実行する
グループの設定が完了したら、コアを設定して開始する準備ができました。これを実行する方法を示す手順については、以下でオペレーティングシステムを選択します。
### Greengrass をローカルで実行する (Linux)
コンピュータのターミナルで以下のコマンドを実行します。
1. デバイスのセキュリティリソース用のフォルダを作成し、証明書とキーをそのフォルダに移動します。以下のコマンドを実行します。*path-to-security-files* (セキュリティファイルへのパス) をセキュリティリソースへのパスに置き換え、*certificateId* をファイル名に含まれる証明書 ID に置き換えます。
```
mkdir /tmp/certs
mv path-to-security-files/certificateId-certificate.pem.crt /tmp/certs
mv path-to-security-files/certificateId-public.pem.key /tmp/certs
mv path-to-security-files/certificateId-private.pem.key /tmp/certs
mv path-to-security-files/AmazonRootCA1.pem /tmp/certs
```
1. デバイスの設定用のフォルダを作成し、 AWS IoT Greengrass Core 設定ファイルをそのフォルダに移動します。以下のコマンドを実行します。*configuration-file-path* を、設定ファイルへのパスに置き換えます。
```
mkdir /tmp/config
mv path-to-config-file/config.json /tmp/config
```
1. Docker コンテナで証明書と設定ファイルを起動 AWS IoT Greengrass してバインドマウントします。
`/tmp` は、証明書と設定ファイルを解凍したパスに置き換えてください。
```
docker run --rm --init -it --name aws-iot-greengrass \
--entrypoint /greengrass-entrypoint.sh \
-v /tmp/certs:/greengrass/certs \
-v /tmp/config:/greengrass/config \
-p 8883:8883 \
216483018798.dkr.ecr.us-west-2.amazonaws.com/aws-iot-greengrass:latest
```
出力は、次の例のようになります。
```
Setting up greengrass daemon
Validating hardlink/softlink protection
Waiting for up to 30s for Daemon to start
Greengrass successfully started with PID: 10
```
### Greengrass をローカルで実行する (macOS)
コンピュータのターミナルで以下のコマンドを実行します。
1. デバイスのセキュリティリソース用のフォルダを作成し、証明書とキーをそのフォルダに移動します。以下のコマンドを実行します。*path-to-security-files* (セキュリティファイルへのパス) をセキュリティリソースへのパスに置き換え、*certificateId* をファイル名に含まれる証明書 ID に置き換えます。
```
mkdir /tmp/certs
mv path-to-security-files/certificateId-certificate.pem.crt /tmp/certs
mv path-to-security-files/certificateId-public.pem.key /tmp/certs
mv path-to-security-files/certificateId-private.pem.key /tmp/certs
mv path-to-security-files/AmazonRootCA1.pem /tmp/certs
```
1. デバイスの設定用のフォルダを作成し、 AWS IoT Greengrass Core 設定ファイルをそのフォルダに移動します。以下のコマンドを実行します。*configuration-file-path* を、設定ファイルへのパスに置き換えます。
```
mkdir /tmp/config
mv path-to-config-file/config.json /tmp/config
```
1. Docker コンテナで証明書と設定ファイルを起動 AWS IoT Greengrass してバインドマウントします。
`/tmp` は、証明書と設定ファイルを解凍したパスに置き換えてください。
```
docker run --rm --init -it --name aws-iot-greengrass \
--entrypoint /greengrass-entrypoint.sh \
-v /tmp/certs:/greengrass/certs \
-v /tmp/config:/greengrass/config \
-p 8883:8883 \
216483018798.dkr.ecr.us-west-2.amazonaws.com/aws-iot-greengrass:latest
```
出力は、次の例のようになります。
```
Setting up greengrass daemon
Validating hardlink/softlink protection
Waiting for up to 30s for Daemon to start
Greengrass successfully started with PID: 10
```
### Greengrass をローカルで実行する (Windows)
1. デバイスのセキュリティリソース用のフォルダを作成し、証明書とキーをそのフォルダに移動します。コマンドプロンプトで次のコマンドを実行します。*path-to-security-files* (セキュリティファイルへのパス) をセキュリティリソースへのパスに置き換え、*certificateId* をファイル名に含まれる証明書 ID に置き換えます。
```
mkdir C:\Users\%USERNAME%\Downloads\certs
move path-to-security-files\certificateId-certificate.pem.crt C:\Users\%USERNAME%\Downloads\certs
move path-to-security-files\certificateId-public.pem.key C:\Users\%USERNAME%\Downloads\certs
move path-to-security-files\certificateId-private.pem.key C:\Users\%USERNAME%\Downloads\certs
move path-to-security-files\AmazonRootCA1.pem C:\Users\%USERNAME%\Downloads\certs
```
1. デバイスの設定用のフォルダを作成し、 AWS IoT Greengrass Core 設定ファイルをそのフォルダに移動します。コマンドプロンプトで次のコマンドを実行します。*configuration-file-path* を、設定ファイルへのパスに置き換えます。
```
mkdir C:\Users\%USERNAME%\Downloads\config
move path-to-config-file\config.json C:\Users\%USERNAME%\Downloads\config
```
1. Docker コンテナで証明書と設定ファイルを起動 AWS IoT Greengrass してバインドマウントします。コマンドプロンプトで次のコマンドを実行します。
```
docker run --rm --init -it --name aws-iot-greengrass --entrypoint /greengrass-entrypoint.sh -v c:/Users/%USERNAME%/Downloads/certs:/greengrass/certs -v c:/Users/%USERNAME%/Downloads/config:/greengrass/config -p 8883:8883 216483018798.dkr.ecr.us-west-2.amazonaws.com/aws-iot-greengrass:latest
```
Docker で `C:\` ドライブを Docker デーモンと共有するように要求されたら、Docker コンテナ内で `C:\` ディレクトリをバインドマウントすることを許可します。詳細については、Docker ドキュメントの「[共有ドライブ](https://docs.docker.com/docker-for-windows/#shared-drives)」を参照してください。
出力は、次の例のようになります。
```
Setting up greengrass daemon
Validating hardlink/softlink protection
Waiting for up to 30s for Daemon to start
Greengrass successfully started with PID: 10
```
**注記**
コンテナがシェルを開かずにすぐに終了する場合は、イメージを起動したときに Greengrass ランタイムログをバインドマウントすることで問題をデバッグできます。詳細については、「[Docker コンテナの外部で Greengrass ランタイムログを永続化する](#debugging-docker-persist-logs)」を参照してください。
## ステップ 4: Greengrass グループの「コンテナなし」コンテナ化を設定する
Docker コンテナ AWS IoT Greengrass で を実行する場合、すべての Lambda 関数はコンテナ化なしで実行する必要があります。このステップでは、グループのデフォルトのコンテナ化を [**No container (コンテナなし)**] に設定します。グループを初めてデプロイする前に行う必要があります。
1. AWS IoT コンソールナビゲーションペインの**「管理**」で **Greengrass デバイス**を展開し、**「グループ (V1)**」を選択します。
1. 設定を変更するグループを選択します。
1. **[Lambda functions]** (Lambda 関数) タブを選択します。
1. **[Default Lambda function runtime environment]** (デフォルトの Lambda 関数ランタイム環境) から、**[Edit]** (編集) を選択します。
1. **[Edit default Lambda function runtime environment]** (デフォルトの Lambda 関数ランタイム環境を編集する) の、**[Default Lambda function containerization]** (デフォルトの Lambda 関数のコンテナ化) でコンテナ化の設定を変更します。
1. **[保存]** を選択します。
変更は、グループのデプロイ時に反映されます。
詳細については、「[グループ内の Lambda 関数のコンテナ化のデフォルト設定](lambda-group-config.md#lambda-containerization-groupsettings)」を参照してください。
**注記**
デフォルトでは、Lambda 関数はグループコンテナ化設定を使用します。 AWS IoT Greengrass を Docker コンテナで実行しているときに、Lambda 関数の **[No container]** (コンテナなし) 設定を上書きすると、デプロイは失敗します。
## ステップ 5: Lambda 関数を Docker AWS IoT Greengrass コンテナにデプロイする
存続期間の長い Lambda 関数を Greengrass Docker コンテナにデプロイできます。
+ 「[モジュール 3 (パート 1): での Lambda 関数 AWS IoT Greengrass](module3-I.md)」の手順に従って、存続期間の長い Hello World Lambda 関数をコンテナにデプロイします。
## ステップ 6: (オプション) Docker コンテナで実行中の Greengrass を操作するクライアントデバイスをデプロイする
Docker コンテナで実行されている AWS IoT Greengrass ときに とやり取りするクライアントデバイスをデプロイすることもできます。
+ 「[モジュール 4: AWS IoT Greengrass グループ内のクライアントデバイスを操作する](module4.md)」の手順に従って、コアに接続するクライアントデバイスをデプロイして、MQTT メッセージを送信します。
## Docker AWS IoT Greengrass コンテナの停止
Docker AWS IoT Greengrass コンテナを停止するには、ターミナルまたはコマンドプロンプトで Ctrl\$1C を押します。このアクションにより、`SIGTERM` が Greengrass デーモンプロセスに送信され、Greengrass デーモンプロセスとデーモンプロセスで開始されたすべての Lambda プロセスが破棄されます。Docker コンテナは `/dev/init` プロセスで PID 1 として初期化されます。これにより、残存するゾンビ状態のプロセスが削除されます。詳細については、[Docker run リファレンス](https://docs.docker.com/engine/reference/commandline/run/#options)を参照してください。
## Docker コンテナ AWS IoT Greengrass でのトラブルシューティング
以下の情報は、Docker コンテナ AWS IoT Greengrass で を実行する際の問題のトラブルシューティングに役立ちます。
### 次のエラーが発生する。Cannot perform an interactive login from a non TTY device。
**解決策:** `aws ecr get-login-password` コマンドを実行すると、このエラーが発生することがあります。最新の AWS CLI バージョン 2 またはバージョン 1 がインストールされていることを確認してください。 AWS CLI バージョン 2 を使用することをお勧めします。詳細については、「*AWS Command Line Interface ユーザーガイド*」の「[Installing the AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html)」を参照してください。
### エラー「Unknown options: -no-include-email」が発生する。
**解決策:** `aws ecr get-login` コマンドを実行すると、このエラーが発生することがあります。 AWS CLI 最新バージョンがインストールされていることを確認します (例: run: `pip install awscli --upgrade --user`)。Windows を使用していて、MSI インストーラを使用して CLI をインストールした場合は、インストールプロセスを繰り返す必要があります。詳細については、「*AWS Command Line Interface ユーザーガイド*」の「[Microsoft Windows に AWS Command Line Interface をインストールする](https://docs.aws.amazon.com/cli/latest/userguide/awscli-install-windows.html)」を参照してください。
### 警告: IPv4 is disabled. Networking will not work.
**解決策:** Linux コンピュータ AWS IoT Greengrass で を実行すると、この警告または同様のメッセージが表示されることがあります。[このステップ](#docker-linux-enable-ipv4)で説明しているようにIPv4 ネットワーク転送を有効にします。IPv4 転送が有効になっていない場合、 AWS IoT Greengrass クラウドデプロイと MQTT 通信は機能しません。詳細については、Docker ドキュメントの「[Configure namespaced kernel parameters (sysctls) at runtime](https://docs.docker.com/engine/reference/commandline/run/#configure-namespaced-kernel-parameters-sysctls-at-runtime)」を参照してください。
### エラー: A firewall is blocking file Sharing between windows and the containers.
**解決策:** Windows コンピュータで Docker を実行すると、このエラーまたは `Firewall Detected` メッセージが表示されることがあります。このエラーは、仮想プライベートネットワーク (VPN) にサインインしていて、ネットワーク設定が原因で共有ドライブをマウントできない場合にも発生することがあります。このような場合は、VPN をオフにし、Docker コンテナを再実行します。
### エラー: An error occurred (AccessDeniedException) when calling the GetAuthorizationToken operation: User: arn:aws:iam:::user/ is not authorized to perform: ecr:GetAuthorizationToken on resource: \$1
このエラーは、Amazon ECR リポジトリにアクセスするための十分な権限がない場合、`aws ecr get-login-password` コマンドの実行時に表示されることがあります。詳細については、「Amazon ECR ユーザーガイド」の「[Amazon ECR リポジトリポリシーの例](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-policy-examples.html)」および「[1 つの Amazon ECR リポジトリにアクセスする](https://docs.aws.amazon.com/AmazonECR/latest/userguide/security_iam_id-based-policy-examples.html)」を参照してください。
一般的な AWS IoT Greengrass トラブルシューティングのヘルプについては、「」を参照してください[トラブルシューティング AWS IoT Greengrass](gg-troubleshooting.md)。
### Docker コンテナ AWS IoT Greengrass でのデバッグ
Docker コンテナの問題をデバッグするには、Greengrass ランタイムログを維持するか、Docker コンテナにインタラクティブシェルをアタッチすることができます。
#### Docker コンテナの外部で Greengrass ランタイムログを永続化する
`/greengrass/ggc/var/log` ディレクトリをバインドマウントした後に AWS IoT Greengrass Docker コンテナを実行できます。ログは、コンテナが終了した後または削除された後も保持されます。
**Linux または macOS の場合**
ホスト上で実行されている[ Greengrass Docker コンテナ](#docker-stop)を停止してから、ターミナルで次のコマンドを実行します。これは Greengrass の `log` ディレクトリをバインドマウントして Docker イメージを起動します。
`/tmp` は、証明書と設定ファイルを解凍したパスに置き換えてください。
```
docker run --rm --init -it --name aws-iot-greengrass \
--entrypoint /greengrass-entrypoint.sh \
-v /tmp/certs:/greengrass/certs \
-v /tmp/config:/greengrass/config \
-v /tmp/log:/greengrass/ggc/var/log \
-p 8883:8883 \
216483018798.dkr.ecr.us-west-2.amazonaws.com/aws-iot-greengrass:latest
```
次に、ホストの `/tmp/log` でログを確認して、Greengrass が Docker コンテナ内で実行されている間に何が起こったのかを確認できます。
**Windows の場合**
ホスト上で実行されている[ Greengrass Docker コンテナ](#docker-stop)を停止してから、コマンドプロンプトで次のコマンドを実行します。これは Greengrass の `log` ディレクトリをバインドマウントして Docker イメージを起動します。
```
cd C:\Users\%USERNAME%\Downloads
mkdir log
docker run --rm --init -it --name aws-iot-greengrass --entrypoint /greengrass-entrypoint.sh -v c:/Users/%USERNAME%/Downloads/certs:/greengrass/certs -v c:/Users/%USERNAME%/Downloads/config:/greengrass/config -v c:/Users/%USERNAME%/Downloads/log:/greengrass/ggc/var/log -p 8883:8883 216483018798.dkr.ecr.us-west-2.amazonaws.com/aws-iot-greengrass:latest
```
次に、ホストの `C:/Users/%USERNAME%/Downloads/log` でログを確認して、Greengrass が Docker コンテナ内で実行されている間に何が起こったのかを確認できます。
#### インタラクティブシェルを Docker コンテナにアタッチするには
実行中の AWS IoT Greengrass Docker コンテナにインタラクティブシェルをアタッチできます。これは、Greengrass Docker コンテナの状態を調査するのに役立ちます。
**Linux または macOS の場合**
Greengrass Docker コンテナの実行中に、別の端末で次のコマンドを実行してください。
```
docker exec -it $(docker ps -a -q -f "name=aws-iot-greengrass") /bin/bash
```
**Windows の場合**
Greengrass Docker コンテナの実行中に、別のコマンドプロンプトで次のコマンドを実行してください。
```
docker ps -a -q -f "name=aws-iot-greengrass"
```
*gg-container-id* を、前のコマンドから得られた `container_id` の結果に置き換えます。
```
docker exec -it gg-container-id /bin/bash
```