翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。
# AWS IoT Greengrass コンポーネントを開発する
Greengrass コアデバイスでコンポーネントの開発とテストを行うことができます。そのため、AWS クラウド と対話することなく、AWS IoT Greengrass ソフトウェアを作成して繰り返すことが可能です。コンポーネントのバージョンが完成したら、クラウドの AWS IoT Greengrass にアップロードすることができるため、自分と自分が所属するチームが、コンポーネントをフリート内の他のデバイスにデプロイすることができます。コンポーネントをデプロイする方法の詳細については、「[AWS IoT Greengrass コンポーネントをデバイスにデプロイする](manage-deployments.md)」を参照してください。
すべてのコンポーネントは、*レシピ*と*アーティファクト*で設定されます。
+ **recipe**
すべてのコンポーネントには、メタデータを定義する recipe ファイルが含まれています。recipe では、コンポーネントの設定パラメータ、コンポーネントの依存関係、ライフサイクル、プラットフォームの互換性も指定します。コンポーネントのライフサイクルは、コンポーネントのインストール、実行、およびシャットダウンを行うコマンドを定義します。詳細については、「[AWS IoT Greengrass コンポーネントレシピリファレンス](component-recipe-reference.md)」を参照してください。
recipe は [JSON](https://en.wikipedia.org/wiki/JSON) または [YAML](https://en.wikipedia.org/wiki/YAML) 形式で定義できます。
+ **アーティファクト**
コンポーネントは、コンポーネントバイナリであるアーティファクトを必要な数だけ持つことができます。アーティファクトには、スクリプト、コンパイルされたコード、静的リソース、およびコンポーネントが消費するその他のファイルが含まれます。コンポーネントはコンポーネントの依存関係からアーティファクトを消費することもできます。
AWS IoT Greengrass では、アプリケーションで使用して、デバイスにデプロイすることができる事前に構築済みのコンポーネントが提供されています。例えば、ストリームマネージャーコンポーネントを使って様々な AWS サービスにデータをアップロードしたり、CloudWatch メトリクスコンポーネントを使って Amazon CloudWatch にカスタムメトリクスをパブリッシュしたりすることが可能です。詳細については、「[AWS が提供したコンポーネント](public-components.md)」を参照してください。
AWS IoT Greengrass は Greengrass ソフトウェアカタログと呼ばれる Greengrass コンポーネントのインデックスをキュレーションします。このカタログは、Greengrass コミュニティによって開発された Greengrass コンポーネントを追跡します。このカタログから、コンポーネントをダウンロード、変更、デプロイして Greengrass アプリケーションを作成できます。詳細については、「[コミュニティコンポーネント](greengrass-software-catalog.md)」を参照してください。
AWS IoT Greengrass Core ソフトウェアは、コアデバイスで設定した `ggc_user` や `ggc_group` などのコンポーネントをシステムユーザーおよびグループとして実行します。これは、コンポーネントがそのシステムユーザーの権限を持っていることを意味します。ホームディレクトリを持たないシステムユーザーを使用した場合、コンポーネントはホームディレクトリを使用する実行コマンドやコードを使用できません。これは、Python パッケージをインストールする場合などに、`pip install some-library --user` コマンドを使用できないことを意味します。[入門チュートリアル](getting-started.md)に従ってコアデバイスを設定している場合、システムユーザーにはホームディレクトリがありません。コンポーネントを実行するユーザーやグループを設定する方法の詳細については、「[コンポーネントを実行するユーザーを設定する](configure-greengrass-core-v2.md#configure-component-user)」を参照してください。
**注記**
AWS IoT Greengrass はコンポーネントのセマンティックバージョンを使用します。セマンティックバージョンは、*major*.*minor*.*patch* という番号体系に従います。例えば、バージョン `1.0.0` は、コンポーネントの最初のメジャーリリースを表しています。詳細については、「[セマンティックバージョンの仕様](https://semver.org/)」を参照してください。
**Topics**
+ [コンポーネントライフサイクル](#component-lifecycle)
+ [コンポーネントタイプ](#component-types)
+ [AWS IoT Greengrass コンポーネントを作成する](create-components.md)
+ [ローカルデプロイで AWS IoT Greengrass コンポーネントをテストする](test-components.md)
+ [コアデバイスにデプロイするコンポーネントをパブリッシュ](publish-components.md)
+ [AWS サービスとやり取り](interact-with-aws-services.md)
+ [Docker コンテナの実行](run-docker-container.md)
+ [AWS IoT Greengrass コンポーネントレシピリファレンス](component-recipe-reference.md)
+ [コンポーネントの環境変数リファレンス](component-environment-variables.md)
## コンポーネントライフサイクル
*コンポーネントライフサイクル*は、AWS IoT Greengrass Core ソフトウェアがコンポーネントをインストールして実行するために使用するステージを定義します。各ステージでは、スクリプトと、コンポーネントの動作を指定するその他の情報を定義します。例えば、コンポーネントをインストールするとき、AWS IoT Greengrass Core ソフトウェアはそのコンポーネントの `install` ライフサイクルスクリプトを実行します。コアデバイス上のコンポーネントには、次のライフサイクルステータスがあります。
+ `NEW` - コンポーネントのレシピとアーティファクトはコアデバイスに読み込まれていますが、コンポーネントはインストールされていません。コンポーネントがこの状態になった後、コンポーネントは [install script](component-recipe-reference.md#install-lifecycle-definition) を実行します。
+ `INSTALLED` - コンポーネントがコアデバイスにインストールされています。コンポーネントは、[install script](component-recipe-reference.md#install-lifecycle-definition) を実行した後にこの状態に入ります。
+ `STARTING` - コアデバイス上でコンポーネントが開始されています。コンポーネントは、[startup script](component-recipe-reference.md#startup-lifecycle-definition) を実行したときにこの状態に入ります。起動に成功すると、コンポーネントは `RUNNING` 状態に入ります。
+ `RUNNING` - コアデバイス上でコンポーネントが実行されています。コンポーネントは、[run script](component-recipe-reference.md#run-lifecycle-definition) を実行したとき、またはスタートアップスクリプトからのアクティブなバックグラウンドプロセスがある場合に、この状態になります。
+ `FINISHED` - コンポーネントが正常に実行され、実行が完了しました。
+ `STOPPING` - コンポーネントは停止しています。コンポーネントは、[shutdown script](component-recipe-reference.md#shutdown-lifecycle-definition) を実行したときにこの状態に入ります。
+ `ERRORED` - コンポーネントでエラーが発生しました。コンポーネントがこの状態に入ると、[recover script](component-recipe-reference.md#recover-lifecycle-definition) を実行します。その後、コンポーネントは再起動して、通常の使用に戻ろうと試みます。コンポーネントが正常に実行されずに 3 回 `ERRORED` 状態になると、コンポーネントは `BROKEN` になります。
+ `BROKEN` - コンポーネントでエラーが複数回発生し、回復できません。修復するには、コンポーネントをもう一度デプロイする必要があります。
## コンポーネントタイプ
*コンポーネントタイプ*は、AWS IoT Greengrass Core ソフトウェアがコンポーネントを実行する方法を指定します。コンポーネントには次のタイプがあります。
+ **Nucleus** (`aws.greengrass.nucleus`)
Greengrass nucleus は、AWS IoT Greengrass Core ソフトウェアの最低限の機能のみを提供するコンポーネントです。詳細については、「[Greengrass nucleus](greengrass-nucleus-component.md)」を参照してください。
+ **プラグイン** (`aws.greengrass.plugin`)
Greengrass nucleus は nucleus と同じ Java 仮想マシン (JVM) で、プラグインコンポーネントを実行します。コアデバイス上のプラグインコンポーネントのバージョンが変更されると、nucleus は再起動します。プラグインコンポーネントをインストールして実行するには、Greengrass nucleus をシステムサービスとして実行するように設定する必要があります。詳細については、「[Greengrass nucleus をシステムサービスとして設定する](configure-greengrass-core-v2.md#configure-system-service)」を参照してください。
AWS から提供されるコンポーネントにはプラグインコンポーネントが複数あり、Greengrass nucleus と直接インターフェイス接続することができます。プラグインコンポーネントは Greengrass nucleus と同じログファイルを使用します。詳細については、「[AWS IoT Greengrass ログのモニタリング](monitor-logs.md)」を参照してください。
+ **ジェネリック** (`aws.greengrass.generic`)
Greengrass nucleus は、コンポーネントがライフサイクルを定義している場合、ジェネリックコンポーネントのライフサイクルスクリプトを実行します。
このタイプは、カスタムコンポーネントのデフォルトタイプです。
+ **Lambda** (`aws.greengrass.lambda`)
Greengrass nucleus は、[Lambda ランチャーコンポーネント](lambda-launcher-component.md)を使用して Lambda 関数コンポーネントを実行します。
Lambda 関数からコンポーネントを作成すると、コンポーネントはこのタイプになります。詳細については、「[AWS Lambda 関数を実行する](run-lambda-functions.md)」を参照してください。
**注記**
レシピでコンポーネントタイプを指定することは推奨しません。AWS IoT Greengrass がコンポーネントを作成するときにタイプを設定します。
# AWS IoT Greengrass コンポーネントを作成する
カスタム AWS IoT Greengrass コンポーネントは、ローカルの開発用コンピュータや Greengrass コアデバイスで開発することができます。AWS IoT Greengrass では、[AWS IoT Greengrass Development Kit Command-Line Interface (GDK CLI)](greengrass-development-kit-cli.md) を提供しており、定義済みのコンポーネントテンプレートや[コミュニティコンポーネント](greengrass-software-catalog.md)からコンポーネントを作成、ビルド、公開することができます。組み込みのシェルコマンドを実行して、コンポーネントを作成、ビルド、パブリッシュすることもできます。カスタム Greengrass コンポーネントを作成するには、次のオプションから選択します。
+ **Greengrass Development Kit CLI を使用する**
GDK CLI を使用して、ローカル開発コンピュータ上でコンポーネントを開発します。GDK CLI は、コンポーネントのソースコードを構築して recipe とアーティファクトにパッケージ化するため、AWS IoT Greengrass サービスへのプライベートコンポーネントとしてパブリッシュすることができます。コンポーネントをパブリッシュするときにコンポーネントのバージョンとアーティファクト URI を自動的に更新するように GDK CLI を設定できるため、recipe を毎回更新する必要はありません。GDK CLI を使用してコンポーネントを開発する場合、テンプレートまたは [Greengrass ソフトウェアカタログ](greengrass-software-catalog.md)にあるコミュニティコンポーネントを使って開始することができます。詳細については、「[AWS IoT Greengrass Development Kit Command-Line Interface](greengrass-development-kit-cli.md)」を参照してください。
+ **組み込みのシェルコマンドを実行する**
組み込みのシェルコマンドを実行して、ローカル開発コンピュータまたは Greengrass コアデバイス上でコンポーネントを開発できます。シェルコマンドを使用して、コンポーネントのソースコードをアーティファクトにコピーするか構築します。コンポーネントの新しいバージョンを作成するたびに、新しいコンポーネントバージョンで recipe を作成または更新する必要があります。コンポーネントを AWS IoT Greengrass サービスにパブリッシュするときには、recipe 内の各コンポーネントアーティファクトに URI を更新する必要があります。
**Topics**
+ [コンポーネントを作成する (GDK CLI)](#create-component-gdk-cli)
+ [コンポーネントを作成する (シェルコマンド)](#create-component-shell-commands)
## コンポーネントを作成する (GDK CLI)
このセクションの指示に従って、GDK CLI を使用してコンポーネントを作成および構築します。
**Greengrass コンポーネントを開発するには (GDK CLI)**
1. GDK CLI をまだインストールしていない場合は、開発コンピュータにインストールします。詳細については、「[AWS IoT Greengrass Development Kit Command-Line Interface をインストールまたは更新する](install-greengrass-development-kit-cli.md)」を参照してください。
1. コンポーネントフォルダを作成するフォルダに移動します。
------
#### [ Linux or Unix ]
```
mkdir ~/greengrassv2
cd ~/greengrassv2
```
------
#### [ Windows Command Prompt (CMD) ]
```
mkdir %USERPROFILE%\greengrassv2
cd %USERPROFILE%\greengrassv2
```
------
#### [ PowerShell ]
```
mkdir ~/greengrassv2
cd ~/greengrassv2
```
------
1. ダウンロードするコンポーネントテンプレートまたはコミュニティコンポーネントを選択します。GDK CLI がテンプレートまたはコミュニティコンポーネントをダウンロードし、実用的な例を使って開始することができます。[component list](greengrass-development-kit-cli-component.md#greengrass-development-kit-cli-component-list) コマンドを使用して、利用可能なテンプレートとコミュニティコンポーネントのリストを取得します。
+ コンポーネントテンプレートをリスト表示するには、次のコマンドを実行します。レスポンスの各行には、テンプレートの名前とプログラミング言語が含まれています。
```
gdk component list --template
```
+ コミュニティコンポーネントをリスト表示するには、次のコマンドを実行します。
```
gdk component list --repository
```
1. GDK CLI がテンプレートまたはコミュニティコンポーネントをダウンロードするコンポーネントフォルダを作成および変更します。*HelloWorld* をコンポーネントの名前、またはこのコンポーネントフォルダを識別するのに役立つ別の名前に置き換えます。
------
#### [ Linux or Unix ]
```
mkdir HelloWorld
cd HelloWorld
```
------
#### [ Windows Command Prompt (CMD) ]
```
mkdir HelloWorld
cd HelloWorld
```
------
#### [ PowerShell ]
```
mkdir HelloWorld
cd HelloWorld
```
------
1. テンプレートまたはコミュニティコンポーネントを現在のフォルダにダウンロードします。[component init](greengrass-development-kit-cli-component.md#greengrass-development-kit-cli-component-init) コマンドを使用します。
+ テンプレートからコンポーネントフォルダを作成するには、次のコマンドを実行します。*HelloWorld* をテンプレートの名前に置き換えて、*python* をプログラミング言語の名前に置き換えます。
```
gdk component init --template HelloWorld --language python
```
+ コミュニティコンポーネントからコンポーネントフォルダを作成するには、次のコマンドを実行します。*ComponentName* をコミュニティコンポーネントの名前に置き換えます。
```
gdk component init --repository ComponentName
```
**注記**
GDK CLI v1.0.0 を使用している場合は、このコマンドは空のフォルダで実行する必要があります。GDK CLI がテンプレートまたはコミュニティコンポーネントを現在のフォルダにダウンロードします。
GDK CLI v1.1.0 以降を使用する場合、`--name` 引数を使用して、GDK CLI がテンプレートまたはコミュニティコンポーネントをダウンロードするフォルダを指定することができます。この引数を使用する場合は、存在しないフォルダを指定します。GDK CLI によってフォルダが作成されます。この引数を指定しなかった場合、GDK CLI は現在のフォルダを使用しますが、このフォルダは空である必要があります。
1. GDK CLI は `gdk-config.json` という名の [GDK CLI 設定ファイル](gdk-cli-configuration-file.md)から読み込むことで、コンポーネントをビルドおよびパブリッシュします。この設定ファイルは、コンポーネントフォルダのルートにあります。前の手順では、このファイルが作成されました。このステップでは、`gdk-config.json` をコンポーネントに関する情報で更新します。以下の操作を実行します。
1. テキストエディタで `gdk-config.json` を開きます。
1. (オプション) コンポーネントの名前を変更します。コンポーネント名は、`component` オブジェクトのキーです。
1. コンポーネントの作成者を変更します。
1. (オプション) コンポーネントのバージョンを変更します。次のいずれかを指定します。
+ `NEXT_PATCH` - このオプションを選択すると、コンポーネントをパブリッシュするときに GDK CLI がバージョンを設定します。GDK CLI は AWS IoT Greengrass サービスを照会して、コンポーネントの最新のパブリッシュバージョンを特定します。次に、そのバージョンの後の次のパッチバージョンにバージョンを設定します。コンポーネントをまだパプリッシュしていない場合は、GDK CLI はバージョン`1.0.0` を使用します。
このオプションを選択する場合、AWS IoT Greengrass Core ソフトウェアが動作するローカル開発用コンピュータにコンポーネントをデプロイしテストするために、[Greengrass CLI](greengrass-cli-component.md) を使用することはできません。ローカルデプロイを有効にするには、代わりにセマンティックバージョンを指定する必要があります。
+ **1.0.0** などのセマンティックバージョンです。セマンティックバージョンは、major.minor.patch という番号方式になっています。詳細については、「[セマンティックバージョンの仕様](https://semver.org/)」を参照してください。
コンポーネントをデプロイしてテストする Greengrass コアデバイスでコンポーネントを開発する場合は、このオプションを選択します。[Greengrass CLI](greengrass-cli-component.md) を使用してローカルデプロイを作成する場合は、特定のバージョンでコンポーネントを構築する必要があります。
1. (オプション) コンポーネントのビルド設定を変更します。ビルド設定では、GDK CLI がコンポーネントのソースをアーティファクトにビルドする方法を定義します。次の `build_system` のオプションの中から選択します。
+ `zip` - コンポーネントのフォルダを ZIP ファイルにパッケージ化し、コンポーネントの唯一のアーティファクトとして定義します。次のタイプのコンポーネントには、このオプションを選択します。
+ Python や JavaScript などのインタプリタ形式のプログラミング言語を使用するコンポーネント。
+ 機械学習モデルやその他のリソースなどの、コード以外のファイルをパッケージ化するコンポーネント。
GDK CLI は、コンポーネントのフォルダをコンポーネントフォルダと同じ名前の zip ファイルに圧縮します。例えば、コンポーネントフォルダの名前が `HelloWorld` の場合、GDK CLI は `HelloWorld.zip` という名前の zip ファイルを作成します。
**注記**
Windows デバイスで GDK CLI バージョン 1.0.0 を使用する場合、コンポーネントフォルダと zip ファイル名には小文字のみを含める必要があります。
GDK CLI がコンポーネントのフォルダを zip ファイルに圧縮する際、次のファイルはスキップされます。
+ `gdk-config.json` ファイル
+ recipe ファイル (`recipe.json` または `recipe.yaml`)
+ ビルドフォルダ (`greengrass-build` など)
+ `maven` - `mvn clean package` コマンドを実行して、コンポーネントのソースをアーティファクト内にビルドします。Java コンポーネントなどの [Maven](https://maven.apache.org/) を使用するコンポーネントの場合は、このオプションを選択します。
Windows デバイスでは、この機能は GDK CLI v1.1.0 以降で利用できます。
+ `gradle` - `gradle build` コマンドを実行して、コンポーネントのソースをアーティファクト内にビルドします。[Gradle](https://gradle.org/) を使用するコンポーネントの場合は、このオプションを選択します。この機能は GDK CLI v1.1.0 以降で利用できます。
`gradle` ビルドシステムは、ビルドファイルとして Kotlin DSL をサポートしています。この機能は GDK CLI v1.2.0 以降で利用できます。
+ `gradlew` - `gradlew` コマンドを実行して、コンポーネントのソースをアーティファクト内にビルドします。[Gradle Wrapper](https://docs.gradle.org/current/userguide/gradle_wrapper.html) を使用するコンポーネントの場合は、このオプションを選択します。
この機能は GDK CLI v1.2.0 以降で利用できます。
+ `custom` - カスタムコマンドを実行して、コンポーネントのソースを recipe とアーティファクトにビルドします。`custom_build_command` パラメータでカスタムコマンドを指定します。
1. `build_system` の `custom` を指定する場合は、`build` オブジェクトに `custom_build_command` を追加します。`custom_build_command` で、1 つの文字列または文字列のリストを指定します。各文字列が、コマンド内の単語になります。例えば、C\$1\$1 コンポーネントのカスタムビルドコマンドを実行する場合は、 **["cmake", "--build", "build", "--config", "Release"]** を指定することができます。
1. GDK CLI v1.1.0 以降を使用する場合、`--bucket` 引数を指定して、GDK CLI がコンポーネントのアーティファクトをアップロードする S3 バケットを指定します。この引数を指定しない場合、GDK CLI は名前が `bucket-region-accountId` である S3 バケットにアップロードします。ここでは、`gdk-config.json` で指定する値は *bucket* と *region* であり、*accountId* は AWS アカウント ID です。GDK CLI は、バケットが存在しない場合に作成します。
コンポーネントのパブリッシュ設定を変更します。以下の操作を実行します。
1. コンポーネントのアーティファクトをホストするために使用する S3 バケット名を指定します。
1. GDK CLI がコンポーネントをパブリッシュする場所となる AWS リージョン を指定します。
このステップを終了した時点で、`gdk-config.json` ファイルは、次の例のようになります。
```
{
"component": {
"com.example.PythonHelloWorld": {
"author": "Amazon",
"version": "NEXT_PATCH",
"build": {
"build_system" : "zip"
},
"publish": {
"bucket": "greengrass-component-artifacts",
"region": "us-west-2"
}
}
},
"gdk_version": "1.0.0"
}
```
1. `recipe.yaml` または `recipe.json` という名のコンポーネント recipe ファイルを更新します。以下の操作を実行します。
1. `zip` ビルドシステムを使用するテンプレートまたはコミュニティコンポーネントをダウンロードした場合は、ZIP アーティファクト名がコンポーネントフォルダの名前と一致していることを確認してください。GDK CLI は、コンポーネントのフォルダをコンポーネントフォルダと同じ名前の zip ファイルに圧縮します。recipe では、コンポーネントアーティファクトのリストと、ZIP アーティファクト内のファイルを使用するライフサイクルスクリプトの中に、ZIP アーティファクトの名前が含まれます。ZIP ファイル名がコンポーネントフォルダの名前と一致するように `Artifacts` および `Lifecycle` の定義を更新します。次の recipe 例では、`Artifacts` と `Lifecycle` の定義内の zip ファイルの名前が強調表示されています。
------
#### [ JSON ]
```
{
...
"Manifests": [
{
"Platform": {
"os": "all"
},
"Artifacts": [
{
"URI": "s3://{COMPONENT_NAME}/{COMPONENT_VERSION}/HelloWorld.zip",
"Unarchive": "ZIP"
}
],
"Lifecycle": {
"Run": "python3 -u {artifacts:decompressedPath}/HelloWorld/main.py {configuration:/Message}"
}
}
]
}
```
------
#### [ YAML ]
```
---
...
Manifests:
- Platform:
os: all
Artifacts:
- URI: "s3://BUCKET_NAME/COMPONENT_NAME/COMPONENT_VERSION/HelloWorld.zip"
Unarchive: ZIP
Lifecycle:
Run: "python3 -u {artifacts:decompressedPath}/HelloWorld/main.py {configuration:/Message}"
```
------
1. (オプション) コンポーネントの説明、デフォルト設定、アーティファクト、ライフサイクルスクリプト、およびプラットフォームサポートを更新します。詳細については、「[AWS IoT Greengrass コンポーネントレシピリファレンス](component-recipe-reference.md)」を参照してください。
このステップを終了した時点で、recipe ファイルは、次の例のようになります。
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "{COMPONENT_NAME}",
"ComponentVersion": "{COMPONENT_VERSION}",
"ComponentDescription": "This is a simple Hello World component written in Python.",
"ComponentPublisher": "{COMPONENT_AUTHOR}",
"ComponentConfiguration": {
"DefaultConfiguration": {
"Message": "World"
}
},
"Manifests": [
{
"Platform": {
"os": "all"
},
"Artifacts": [
{
"URI": "s3://{COMPONENT_NAME}/{COMPONENT_VERSION}/HelloWorld.zip",
"Unarchive": "ZIP"
}
],
"Lifecycle": {
"Run": "python3 -u {artifacts:decompressedPath}/HelloWorld/main.py {configuration:/Message}"
}
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: "2020-01-25"
ComponentName: "{COMPONENT_NAME}"
ComponentVersion: "{COMPONENT_VERSION}"
ComponentDescription: "This is a simple Hello World component written in Python."
ComponentPublisher: "{COMPONENT_AUTHOR}"
ComponentConfiguration:
DefaultConfiguration:
Message: "World"
Manifests:
- Platform:
os: all
Artifacts:
- URI: "s3://BUCKET_NAME/COMPONENT_NAME/COMPONENT_VERSION/HelloWorld.zip"
Unarchive: ZIP
Lifecycle:
Run: "python3 -u {artifacts:decompressedPath}/HelloWorld/main.py {configuration:/Message}"
```
------
1. Greengrass コンポーネントを開発して構築します。[コンポーネントビルド](greengrass-development-kit-cli-component.md#greengrass-development-kit-cli-component-build)コマンドは、コンポーネントフォルダにある `greengrass-build` フォルダに recipe とアーティファクトを作成します。以下のコマンドを実行してください。
```
gdk component build
```
コンポーネントをテストする準備ができたら、GDK CLI を使用して、AWS IoT Greengrass サービスにパブリッシュします。その後に、コンポーネントを Greengrass コアデバイスにデプロイできます。詳細については、「[コアデバイスにデプロイするコンポーネントをパブリッシュ](publish-components.md)」を参照してください。
## コンポーネントを作成する (シェルコマンド)
このセクションの手順に従って、複数のコンポーネントのソースコードとアーティファクトが含まれる recipe とアーティファクトフォルダを作成します。
**Greengrass コンポーネントを開発するには (シェルコマンド)**
1. recipe とアーティファクトのサブフォルダを含むコンポーネントのフォルダを作成します。Greengrass コアデバイスで次のコマンドを実行してこれらのフォルダを作成し、コンポーネントフォルダに変更します。*\$1/greengrassv2* または *%USERPROFILE%\$1greengrassv2* をローカル開発に使用するフォルダへのパスに置き換えます。
------
#### [ Linux or Unix ]
```
mkdir -p ~/greengrassv2/{recipes,artifacts}
cd ~/greengrassv2
```
------
#### [ Windows Command Prompt (CMD) ]
```
mkdir %USERPROFILE%\greengrassv2\\recipes, %USERPROFILE%\greengrassv2\\artifacts
cd %USERPROFILE%\greengrassv2
```
------
#### [ PowerShell ]
```
mkdir ~/greengrassv2/recipes, ~/greengrassv2/artifacts
cd ~/greengrassv2
```
------
1. テキストエディタを使用して、コンポーネントのメタデータ、パラメータ、依存関係、ライフサイクル、プラットフォーム機能を定義する recipe ファイルを作成します。recipe ファイル名にコンポーネントのバージョンを含めるようにして、どの recipe がどのコンポーネントバージョンを反映しているのかを特定できるようにします。recipe には YAML 形式または JSON 形式を選択できます。
例えば、Linux ベースのシステムでは、次のコマンドを実行し、GNU nano を使用してファイルを作成できます。
------
#### [ JSON ]
```
nano recipes/com.example.HelloWorld-1.0.0.json
```
------
#### [ YAML ]
```
nano recipes/com.example.HelloWorld-1.0.0.yaml
```
------
**注記**
AWS IoT Greengrass はコンポーネントのセマンティックバージョンを使用します。セマンティックバージョンは、major.minor.patch といった番号システムに準拠します。例えば、バージョン `1.0.0` は、コンポーネントの最初のメジャーリリースを表しています。詳細については、「[セマンティックバージョンの仕様](https://semver.org/)」を参照してください。
1. コンポーネントの recipe を定義します。詳細については、「[AWS IoT Greengrass コンポーネントレシピリファレンス](component-recipe-reference.md)」を参照してください。
recipe は、次 Hello World の recipe 例のようになります。
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.HelloWorld",
"ComponentVersion": "1.0.0",
"ComponentDescription": "My first AWS IoT Greengrass component.",
"ComponentPublisher": "Amazon",
"ComponentConfiguration": {
"DefaultConfiguration": {
"Message": "world"
}
},
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"run": "python3 -u {artifacts:path}/hello_world.py {configuration:/Message}"
}
},
{
"Platform": {
"os": "windows"
},
"Lifecycle": {
"run": "py -3 -u {artifacts:path}/hello_world.py {configuration:/Message}"
}
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.HelloWorld
ComponentVersion: '1.0.0'
ComponentDescription: My first AWS IoT Greengrass component.
ComponentPublisher: Amazon
ComponentConfiguration:
DefaultConfiguration:
Message: world
Manifests:
- Platform:
os: linux
Lifecycle:
run: |
python3 -u {artifacts:path}/hello_world.py "{configuration:/Message}"
- Platform:
os: windows
Lifecycle:
run: |
py -3 -u {artifacts:path}/hello_world.py "{configuration:/Message}"
```
------
この recipe は、Hello World Python スクリプトを実行します。次のスクリプト例のようになります。
```
import sys
message = "Hello, %s!" % sys.argv[1]
# Print the message to stdout, which Greengrass saves in a log file.
print(message)
```
1. 開発するコンポーネントバージョン用のフォルダを作成します。どのアーティファクトがどのコンポーネントバージョンのものなのかを識別できるように、各コンポーネントバージョンのアーティファクトに対して個別のフォルダを使用することをお勧めします。以下のコマンドを実行してください。
------
#### [ Linux or Unix ]
```
mkdir -p artifacts/com.example.HelloWorld/1.0.0
```
------
#### [ Windows Command Prompt (CMD) ]
```
mkdir artifacts/com.example.HelloWorld/1.0.0
```
------
#### [ PowerShell ]
```
mkdir artifacts/com.example.HelloWorld/1.0.0
```
------
**重要**
アーティファクトフォルダのパスには、次のフォーマットを使用する必要があります。recipe で指定したコンポーネント名とバージョンを含めてください。
```
artifacts/componentName/componentVersion/
```
1. 前のステップで作成したフォルダに、コンポーネントのアーティファクトを作成します。アーティファクトには、ソフトウェア、イメージ、およびその他のコンポーネントが使用するバイナリを含めることができます。
コンポーネントの準備ができたら、[コンポーネントをテストします](test-components.md)。
# ローカルデプロイで AWS IoT Greengrass コンポーネントをテストする
コアデバイスで Greengrass コンポーネントを開発する場合は、ローカルデプロイを作成してインストールしてテストできます。このセクションのステップに従ってローカルデプロイを作成します。
ローカルデプロイコンピュータなど、別のコンピュータでコンポーネントを開発する場合、ローカルデプロイを作成することはできません。代わりに、Greengrass コアデバイスにデプロイしてテストできるように、コンポーネントを AWS IoT Greengrass サービスに公開します。詳細については、「[コアデバイスにデプロイするコンポーネントをパブリッシュ](publish-components.md)」および「[AWS IoT Greengrass コンポーネントをデバイスにデプロイする](manage-deployments.md)」を参照してください。
**Greengrass コアデバイスでコンポーネントをテストするには**
1. コアデバイスは、コンポーネントの更新などのイベントをログに記録します。このログファイルを表示して、無効なレシピなど、コンポーネントのエラーを検出してトラブルシューティングできます。このログファイルには、コンポーネントが標準出力 (stdout) に出力するメッセージも表示されます。コアデバイスで追加のターミナルセッションを開き、新しいログメッセージをリアルタイムで監視することをお勧めします。SSH などの新しいターミナルセッションを開き、次のコマンドを実行してログを表示します。`/greengrass/v2` を AWS IoT Greengrass ルートフォルダへのパスに置き換えます。
------
#### [ Linux or Unix ]
```
sudo tail -f /greengrass/v2/logs/greengrass.log
```
------
#### [ PowerShell ]
```
gc C:\greengrass\v2\logs\greengrass.log -Tail 10 -Wait
```
------
コンポーネントのログファイルを表示することもできます。
------
#### [ Linux or Unix ]
```
sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log
```
------
#### [ PowerShell ]
```
gc C:\greengrass\v2\logs\com.example.HelloWorld.log -Tail 10 -Wait
```
------
1. 元のターミナルセッションで、次のコマンドを実行して、コアデバイスをコンポーネントで更新します。`/greengrass/v2` を AWS IoT Greengrass ルートフォルダへのパスに置き換え、*\$1/greengrassv2* をローカル開発フォルダへのパスに置き換えます。
------
#### [ Linux or Unix ]
```
sudo /greengrass/v2/bin/greengrass-cli deployment create \
--recipeDir ~/greengrassv2/recipes \
--artifactDir ~/greengrassv2/artifacts \
--merge "com.example.HelloWorld=1.0.0"
```
------
#### [ Windows Command Prompt (CMD) ]
```
C:\greengrass\v2\bin\greengrass-cli deployment create ^
--recipeDir %USERPROFILE%\greengrassv2\recipes ^
--artifactDir %USERPROFILE%\greengrassv2\artifacts ^
--merge "com.example.HelloWorld=1.0.0"
```
------
#### [ PowerShell ]
```
C:\greengrass\v2\bin\greengrass-cli deployment create `
--recipeDir ~/greengrassv2/recipes `
--artifactDir ~/greengrassv2/artifacts `
--merge "com.example.HelloWorld=1.0.0"
```
------
**注記**
また、`greengrass-cli deployment create` コマンドを使用して、コンポーネントの設定パラメータの値を設定することもできます。詳細については、「[作成](gg-cli-deployment.md#deployment-create)」を参照してください。
1. `greengrass-cli deployment status` コマンドを使用して、コンポーネントのデプロイの進行状況を監視します。
------
#### [ Unix or Linux ]
```
sudo /greengrass/v2/bin/greengrass-cli deployment status \
-i deployment-id
```
------
#### [ Windows Command Prompt (CMD) ]
```
C:\greengrass\v2\bin\greengrass-cli deployment status ^
-i deployment-id
```
------
#### [ PowerShell ]
```
C:\greengrass\v2\bin\greengrass-cli deployment status `
-i deployment-id
```
------
1. Greengrass コアデバイスで実行されるコンポーネントをテストします。このバージョンのコンポーネントを終了したら、AWS IoT Greengrass サービスにアップロードできます。その後、コンポーネントを他のコアデバイスに展開できます。詳細については、「[コアデバイスにデプロイするコンポーネントをパブリッシュ](publish-components.md)」を参照してください。
# コアデバイスにデプロイするコンポーネントをパブリッシュ
コンポーネントのバージョンを構築または完成した後、AWS IoT Greengrass サービスにパブリッシュできます。次に、Greengrass コアデバイスにデプロイできます。
[Greengrass Development Kit CLI (GDK CLI)](greengrass-development-kit-cli.md) を使用して[コンポーネントを開発と構築](create-components.md)する場合、[GDK CLI を使用](#publish-component-gdk-cli)してコンポーネントを AWS クラウド にパブリッシュできます。それ以外の場合、[組込み型のシェルコマンドと AWS CLI を使用](#publish-component-shell-commands)してコンポーネントをパブリッシュします。
AWS CloudFormation を使用して、テンプレートでコンポーネントと他の AWS リソースを作成することもできます。詳細については、「AWS CloudFormation ユーザーガイド」の「[AWS CloudFormation とは](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html)」と「[https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-greengrassv2-componentversion.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-greengrassv2-componentversion.html)」を参照してください。
**Topics**
+ [コンポーネントをパブリッシュ (GDK CLI)](#publish-component-gdk-cli)
+ [コンポーネントをパブリッシュ (シェルコマンド)](#publish-component-shell-commands)
## コンポーネントをパブリッシュ (GDK CLI)
このセクションの指示に従って、GDK CLI を使用してコンポーネントをパブリッシュします。GDK CLI は、S3 バケットにビルドアーティファクトをアップロード、recipe のアーティファクト URI を更新、recipe からコンポーネントを作成します。S3 バケットとリージョンが [GDK CLI 設定ファイル](gdk-cli-configuration-file.md)を使用するように指定します。
GDK CLI v1.1.0 以降を使用する場合、`--bucket` 引数を指定して、GDK CLI がコンポーネントのアーティファクトをアップロードする S3 バケットを指定します。この引数を指定しない場合、GDK CLI は名前が `bucket-region-accountId` である S3 バケットにアップロードします。ここでは、`gdk-config.json` で指定する値は *bucket* と *region* であり、*accountId* は AWS アカウント ID です。GDK CLI は、バケットが存在しない場合に作成します。
**重要**
コアデバイスのロールは、デフォルトで S3 バケットへのアクセスを許可しません。この S3 バケットを初めて使用する場合、コアデバイスがこの S3 バケットからコンポーネントアーティファクトを取得するため、ロールに許可を追加する必要があります。詳細については、「[コンポーネントのアーティファクトの S3 バケットへのアクセスを許可する](device-service-role.md#device-service-role-access-s3-bucket)」を参照してください。
**Greengrass コンポーネントをパブリッシュするには (GDK CLI)**
1. コマンドプロントまたはターミナルでコンポーネントフォルダを開きます。
1. まだ作成していない場合、Greengrass コンポーネントを作成します。[コンポーネントビルド](greengrass-development-kit-cli-component.md#greengrass-development-kit-cli-component-build)コマンドは、コンポーネントフォルダにある `greengrass-build` フォルダに recipe とアーティファクトを作成します。以下のコマンドを実行してください。
```
gdk component build
```
1. コンポーネントを AWS クラウド にパブリッシュします。[コンポーネントをパブリッシュ](greengrass-development-kit-cli-component.md#greengrass-development-kit-cli-component-publish)コマンドは、コンポーネントのアーティファクトを Amazon S3 にアップロードし、各アーティファクトの URI でコンポーネントの recipe を更新します。次に、コンポーネントを AWS IoT Greengrass サービスに作成します。
**注記**
AWS IoT Greengrass は、コンポーネントの作成時に各アーティファクトのダイジェストを計算します。つまり、コンポーネントを作成した後、S3 バケットのアーティファクトファイルを修正することはできません。そうした場合、ファイルダイジェストが一致しないため、このコンポーネントを含むデプロイは失敗します。アーティファクトファイルを修正する場合、コンポーネントの新しいバージョンを作成する必要があります。
GDK CLI 設定ファイルのコンポーネントバージョンに `NEXT_PATCH` を指定した場合、GDK CLI は AWS IoT Greengrass サービスにまだ存在しない次のパッチバージョンを使用します。
以下のコマンドを実行してください。
```
gdk component publish
```
出力には、GDK CLI が作成したコンポーネントのバージョンが示されます。
コンポーネントをパブリッシュした後、コンポーネントをコアデバイスにデプロイできます。詳細については、「[AWS IoT Greengrass コンポーネントをデバイスにデプロイする](manage-deployments.md)」を参照してください。
## コンポーネントをパブリッシュ (シェルコマンド)
シェルコマンドと AWS Command Line Interface (AWS CLI) を使用してコンポーネントをパブリッシュするには、次の手順を実行します。コンポーネントをパブリッシュするときは、次の手順を実行します。
1. S3 バケットにコンポーネントアーティファクトをパブリッシュします。
1. 各アーティファクトの Amazon S3 URI をコンポーネント recipe に追加します。
1. コンポーネント recipe から AWS IoT Greengrass でコンポーネントバージョンを作成します。
**注記**
アップロードする各コンポーネントバージョンは一意である必要があります。アップロード後は編集できないため、必ず正しいコンポーネントバージョンをアップロードしてください。
これらの手順に従って、開発コンピュータまたは Greengrass コアデバイスからコンポーネントをパブリッシュできます。
**コンポーネントをパブリッシュするには (シェルコマンド)**
1. コンポーネントが、AWS IoT Greengrass サービスに存在するバージョンを使用している場合、コンポーネントのバージョンを変更する必要があります。テキストエディタで recipe を開き、バージョンをインクリメントしてファイルを保存します。コンポーネントに加えた変更を反映する新しいバージョンを選択します。
**注記**
AWS IoT Greengrass はコンポーネントのセマンティックバージョンを使用します。セマンティックバージョンは、major.minor.patch といった番号システムに準拠します。例えば、バージョン `1.0.0` は、コンポーネントの最初のメジャーリリースを表しています。詳細については、「[セマンティックバージョンの仕様](https://semver.org/)」を参照してください。
1. コンポーネントにアーティファクトがある場合、次の手順を実行します。
1. AWS アカウント の S3 バケットにコンポーネントのアーティファクトをパブリッシュします。
**ヒント**
S3 バケットのアーティファクトへのパスに、コンポーネント名とバージョンを含めることをお勧めします。この命名規則は、以前のバージョンのコンポーネントが使用していたアーティファクトを維持するうえで役立ち、以前のコンポーネントバージョンを引き続きサポートできるようにします。
次のコマンドを実行して、アーティファクトファイルを S3 バケットにパブリッシュします。amzn-s3-demo-bucket をバケットの名前に置き換えて、*artifacts/com.example.HelloWorld/1.0.0/artifact.py* をアーティファクトファイルへのパスに置き換えます。
```
aws s3 cp artifacts/com.example.HelloWorld/1.0.0/artifact.py s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/artifact.py
```
**重要**
コアデバイスのロールは、デフォルトで S3 バケットへのアクセスを許可しません。この S3 バケットを初めて使用する場合、コアデバイスがこの S3 バケットからコンポーネントアーティファクトを取得するため、ロールに許可を追加する必要があります。詳細については、「[コンポーネントのアーティファクトの S3 バケットへのアクセスを許可する](device-service-role.md#device-service-role-access-s3-bucket)」を参照してください。
1. `Artifacts` という名前のリストが存在しない場合、コンポーネント recipe に追加します。`Artifacts` リストは各マニフェストに表示され、サポートする各プラットフォームにおけるコンポーネントの要件 (またはすべてのプラットフォームに対するコンポーネントのデフォルト要件) を定義します。
1. 各アーティファクトをアーティファクトのリストに追加、あるいは既存アーティファクトの URI を更新します。Amazon S3 URI は、バケット名とバケット内のアーティファクトオブジェクトへのパスで設定されます。アーティファクトの Amazon S3 URI は次の例のようになります。
```
s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/artifact.py
```
これらのステップが完了したら、recipe の `Artifacts` リストは次のようになります。
------
#### [ JSON ]
```
{
...
"Manifests": [
{
"Lifecycle": {
...
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/MyGreengrassComponent/1.0.0/artifact.py",
"Unarchive": "NONE"
}
]
}
]
}
```
**注記**
ZIP アーティファクトに `"Unarchive": "ZIP"` オプションを追加して AWS IoT Greengrass Core ソフトウェアを設定して、コンポーネントのデプロイ時にアーティファクトを解凍できます。
------
#### [ YAML ]
```
...
Manifests:
- Lifecycle:
...
Artifacts:
- URI: s3://amzn-s3-demo-bucket/artifacts/MyGreengrassComponent/1.0.0/artifact.py
Unarchive: NONE
```
**注記**
コンポーネントのデプロイ時に ZIP アーティファクトを解凍するため、`Unarchive: ZIP` オプションを使用して AWS IoT Greengrass Core ソフトウェアを設定できます。コンポーネントで ZIP アーティファクトを使用する方法の詳細については、[アーティファクト: decompressedPath recipe 変数](component-recipe-reference.md#component-recipe-artifacts-decompressed-path)を参照してください。
------
recipe の詳細については、「[AWS IoT Greengrass コンポーネントレシピリファレンス](component-recipe-reference.md)」を参照してください。
1. AWS IoT Greengrass コンソールを使用して、recipe ファイルからコンポーネントを作成します。
次のコマンドを実行して、recipe ファイルからコンポーネントを作成します。このコマンドは、コンポーネントを作成して AWS アカウント のプライベート AWS IoT Greengrass コンポーネントとしてパブリッシュします。*path/to/recipeFile* を recipe ファイルへのパスに置き換えます。
```
aws greengrassv2 create-component-version --inline-recipe fileb://path/to/recipeFile
```
レスポンスから `arn` をコピーして、次のステップでコンポーネントの状態をチェックします。
**注記**
AWS IoT Greengrass は、コンポーネントの作成時に各アーティファクトのダイジェストを計算します。つまり、コンポーネントを作成した後、S3 バケットのアーティファクトファイルを修正することはできません。そうした場合、ファイルダイジェストが一致しないため、このコンポーネントを含むデプロイは失敗します。アーティファクトファイルを修正する場合、コンポーネントの新しいバージョンを作成する必要があります。
1. AWS IoT Greengrass サービスの各コンポーネントには状態があります。次のコマンドを実行して、この手順でパブリッシュするコンポーネントバージョンの状態を確認します。*com.example.HelloWorld* と *1.0.0* をクエリするコンポーネントバージョンに置き換えます。`arn` を、前のステップで書き留めた ARN に置き換えます。
```
aws greengrassv2 describe-component --arn "arn:aws:greengrass:region:account-id:components:com.example.HelloWorld:versions:1.0.0"
```
このオペレーションは、コンポーネントのメタデータを含むレスポンスを返します。メタデータには、コンポーネントの状態とエラーを含む `status` オブジェクトが含まれています (該当する場合)。
コンポーネントの状態が `DEPLOYABLE` な場合、コンポーネントをデバイスにデプロイできます。詳細については、「[AWS IoT Greengrass コンポーネントをデバイスにデプロイする](manage-deployments.md)」を参照してください。
# AWS サービスとやり取り
Greengrass コアデバイスは、TLS 相互認証プロトコルを使用して AWS IoT Core に接続するために、X.509 証明書を使用します。これらの証明書は、AWS 認証情報 (通常はアクセスキー ID とシークレットアクセスキー) がなくても、デバイスが AWS IoT とやり取りできるようにします。その他の AWS サービスは、サービスエンドポイントで API オペレーションを呼び出す際に、X.509 証明書ではなく AWS 認証情報が必要になります。AWS IoT Core には認証情報プロバイダがあり、これはデバイスが AWS リクエストを認証するために X.509 証明書を使用することを可能にします。AWS IoT 認証情報プロバイダは、X.509 証明書を使用してデバイスを認証し、一時的で制限された権限のセキュリティトークンの形で AWS 認証情報を発行します。デバイスはこのトークンを使用して、すべての AWS リクエストに署名と認証を行うことができます。これにより、Greengrass コアデバイスでは AWS 認証情報を保存する必要がなくなります。詳細については、「AWS IoT Core デベロッパーガイド」の「[AWS サービスへの直接呼び出しを認証する](https://docs.aws.amazon.com/iot/latest/developerguide/authorizing-direct-aws.html)」を参照してください。
AWS IoT から認証情報を取得するために、Greengrass コアデバイスは IAM ロールを指す AWS IoT ロールエイリアスを使用します。この IAM ロールは「トークン交換ロール」と呼ばれます。ロールエイリアスとトークン交換ロールは、AWS IoT Greengrass Core ソフトウェアをインストールする際に作成します。コアデバイスが使用するロールエイリアスを指定するには、[Greengrass nucleus](greengrass-nucleus-component.md) の `iotRoleAlias` パラメータを設定します。
AWS IoT 認証情報プロバイダは、ユーザーに代わって、コアデバイスに AWS 認証情報を提供するためのトークン交換ロールを引き受けます。適切な IAM ポリシーをこのロールにアタッチすることで、S3 バケット内のコンポーネントアーティファクトなどの AWS リソースにコアデバイスがアクセスできるようになります。トークン交換ロールを設定する方法の詳細については、「[コアデバイスが AWS サービスとやり取りできるように認可する](device-service-role.md)」を参照してください。
Greengrass コアデバイスは AWS 認証情報をメモリに保存しますが、デフォルトでは、認証情報は 1 時間で期限が切れます。AWS IoT Greengrass Core ソフトウェアが再起動した場合は、認証情報を再度取得する必要があります。[UpdateRoleAlias](https://docs.aws.amazon.com/iot/latest/apireference/API_UpdateRoleAlias.html) オペレーションを使用すると、認証情報が有効である期間を設定できます。
AWS IoT Greengrass はパブリックコンポーネントの 1 つであるトークン交換サービスコンポーネントを提供します。これはカスタムコンポーネントの依存関係として定義でき、AWS サービスとやり取りを可能にします。トークン交換サービスはコンポーネントに環境変数 `AWS_CONTAINER_CREDENTIALS_FULL_URI` を提供します。これは AWS 認証情報を提供するローカルサーバーへの URI を定義するものです。AWS SDK クライアントを作成すると、クライアントはこの環境変数をチェックしてローカルサーバーに接続し、AWS 認証情報を取得して、これを使用して API リクエストに署名します。これにより、コンポーネントで AWS サービスを呼び出すために、AWS SDK などのツールを使用できるようになります。詳細については、「[トークン交換サービス](token-exchange-service-component.md)」を参照してください。
**重要**
この方法で AWS 認証情報を取得するサポートは、2016 年 7 月 13 日に AWS の SDK に追加されました。コンポーネントは、その日以降に作成された AWS SDK バージョンを使用する必要があります。詳細については、「Amazon Elastic Container Service デベロッパーガイド」の「[サポートされる AWS SDK の使用](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html#task-iam-roles-minimum-sdk)」を参照してください。
カスタムコンポーネントで AWS 認証情報を取得するには、コンポーネントレシピで `aws.greengrass.TokenExchangeService` を依存関係として定義します。次のサンプルレシピは、[boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) をインストールし、Amazon S3 バケットを一覧表示するためにトークン交換サービスからの AWS 認証情報を使用する Python スクリプトを実行するコンポーネントを定義します。
**注記**
このサンプルコンポーネントを実行するには、デバイスに `s3:ListAllMyBuckets` アクセス許可が必要です。詳細については、「[コアデバイスが AWS サービスとやり取りできるように認可する](device-service-role.md)」を参照してください。
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.ListS3Buckets",
"ComponentVersion": "1.0.0",
"ComponentDescription": "A component that uses the token exchange service to list S3 buckets.",
"ComponentPublisher": "Amazon",
"ComponentDependencies": {
"aws.greengrass.TokenExchangeService": {
"VersionRequirement": "^2.0.0",
"DependencyType": "HARD"
}
},
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"install": "pip3 install --user boto3",
"Run": "python3 -u {artifacts:path}/list_s3_buckets.py"
}
},
{
"Platform": {
"os": "windows"
},
"Lifecycle": {
"install": "pip3 install --user boto3",
"Run": "py -3 -u {artifacts:path}/list_s3_buckets.py"
}
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.ListS3Buckets
ComponentVersion: '1.0.0'
ComponentDescription: A component that uses the token exchange service to list S3 buckets.
ComponentPublisher: Amazon
ComponentDependencies:
aws.greengrass.TokenExchangeService:
VersionRequirement: '^2.0.0'
DependencyType: HARD
Manifests:
- Platform:
os: linux
Lifecycle:
install:
pip3 install --user boto3
Run: |-
python3 -u {artifacts:path}/list_s3_buckets.py
- Platform:
os: windows
Lifecycle:
install:
pip3 install --user boto3
Run: |-
py -3 -u {artifacts:path}/list_s3_buckets.py
```
------
このサンプルコンポーネントは、Amazon S3 バケットを一覧表示する、以下の Python スクリプト (`list_s3_buckets.py`) を実行します。
```
import boto3
import os
try:
print("Creating boto3 S3 client...")
s3 = boto3.client('s3')
print("Successfully created boto3 S3 client")
except Exception as e:
print("Failed to create boto3 s3 client. Error: " + str(e))
exit(1)
try:
print("Listing S3 buckets...")
response = s3.list_buckets()
for bucket in response['Buckets']:
print(f'\t{bucket["Name"]}')
print("Successfully listed S3 buckets")
except Exception as e:
print("Failed to list S3 buckets. Error: " + str(e))
exit(1)
```
# Docker コンテナの実行
以下の場所に保存されているイメージから [Docker](https://www.docker.com/) コンテナを実行するように AWS IoT Greengrass コンポーネントを設定できます。
+ Amazon Elastic Container Registry (Amazon ECR) のパブリックイメージリポジトリおよびプライベートイメージリポジトリ
+ パブリック Docker Hub リポジトリ
+ パブリック Docker の信頼レジストリ
+ S3 バケット
カスタムコンポーネントで、Docker イメージ URI をアーティファクトとして含めて、イメージを取得してコアデバイスに実行します。Amazon ECR と Docker Hub イメージの場合、[Docker アプリケーションマネージャー](docker-application-manager-component.md)コンポーネントを使用して、プライベート Amazon ECR リポジトリ用にイメージのダウンロードと認証情報の管理ができます。
**Topics**
+ [要件](#run-docker-container-requirements)
+ [Amazon ECR または Docker Hub のパブリックイメージから Docker コンテナを実行する](#run-docker-container-public-ecr-dockerhub)
+ [Amazon ECR のプライベートイメージから Docker コンテナを実行](#run-docker-container-private-ecr)
+ [Amazon S3 のイメージから Docker コンテナの実行](#run-docker-container-s3)
+ [Docker コンテナコンポーネントでプロセス間通信の使用](#docker-container-ipc)
+ [Docker コンテナコンポーネントで AWS 認証情報を使用する (Linux)](#docker-container-token-exchange-service)
+ [Docker コンテナコンポーネント (Linux) でストリームマネージャーの使用](#docker-container-stream-manager)
## 要件
コンポーネントの Docker コンテナを実行するには、次のものが必要です:
+ Greengrass コアデバイス。アカウントをお持ちでない場合は、「[チュートリアル: AWS IoT Greengrass V2 の開始方法](getting-started.md)」を参照してください。
+ [Docker Engine](https://docs.docker.com/engine/) 1.9.1 以降が Greengrass コアにインストールされていいること。バージョン 20.10 は、 AWS IoT Greengrass Core ソフトウェアで動作することが検証された最新バージョンです。Docker コンテナを実行するコンポーネントをデプロイする前に、コアデバイスに直接、Docker をインストールしておく必要があります。
**ヒント**
コンポーネントのインストール時に、Docker Engine をインストールするようにコアデバイスを設定することもできます。例えば、次のインストールスクリプトは、Docker イメージをロードする前に Docker Engine をインストールします。このインストールスクリプトは、Ubuntu など、 Debian ベースの Linux ディストリビューションに動作します。このコマンドで Docker Engine をインストールするようにコンポーネントを設定する場合、ライフサイクルスクリプトに `RequiresPrivilege` を `true` に設定して、インストールと `docker` コマンドを実行する必要があります。詳細については、「[AWS IoT Greengrass コンポーネントレシピリファレンス](component-recipe-reference.md)」を参照してください。
```
apt-get install docker-ce docker-ce-cli containerd.io && docker load -i {artifacts:path}/hello-world.tar
```
+ Docker コンテナコンポーネントを実行するシステムユーザーには、ルート権限または管理者権限が必要です。権限がない場合は、ルート権限または管理者権限を持たないユーザーとして実行されるように Docker を設定する必要があります。
+ Linux デバイスでは、ユーザーを `docker` グループに追加することで、`sudo` のない `docker` コマンドを呼び出せます。
+ Windows デバイスでは、ユーザーを `docker-users` グループ に追加することで、管理者の権限のない `docker` コマンドを呼び出せます。
------
#### [ Linux or Unix ]
Docker コンテナコンポーネントの実行に使用する `ggc_user` または非ルートユーザーを `docker` グループに追加するには、次のコマンドを実行します。
```
sudo usermod -aG docker ggc_user
```
詳細については、「[Docker を非ルートユーザーとして管理する](https://docs.docker.com/engine/install/linux-postinstall/#manage-docker-as-a-non-root-user)」を参照してください。
------
#### [ Windows Command Prompt (CMD) ]
Docker コンテナコンポーネントの実行に使用する `ggc_user` またはユーザーを `docker-users` グループに追加するには、次のコマンドを管理者として実行します。
```
net localgroup docker-users ggc_user /add
```
------
#### [ Windows PowerShell ]
Docker コンテナコンポーネントの実行に使用する `ggc_user` またはユーザーを `docker-users` グループに追加するには、次のコマンドを管理者として実行します。
```
Add-LocalGroupMember -Group docker-users -Member ggc_user
```
------
+ Docker コンテナ内にある Docker コンテナコンポーネントによってアクセスされる[ボリュームとしてマウントされた](https://docs.docker.com/storage/volumes/)ファイル。
+ [ネットワークプロキシを使用するように AWS IoT Greengrass Core ソフトウェアを設定する](configure-greengrass-core-v2.md#configure-alpn-network-proxy)場合は、[同じプロキシサーバーを使用するように Docker を設定](https://docs.docker.com/network/proxy/)する必要があります。
これらの要件に加えて、環境に該当する場合、次の要件も満たす必要があります:
+ [Docker Compose](https://docs.docker.com/compose/) を使用して Docker コンテナを作成して起動するには、Greengrass コアデバイスに Docker Compose をインストールして、Docker Compose ファイルを S3 バケットにアップロードします。Compose ファイルは、 AWS リージョン コンポーネントと同じ AWS アカウント および の S3 バケットに保存する必要があります。カスタムコンポーネントに `docker-compose up` コマンドを使用する例については、「[Amazon ECR または Docker Hub のパブリックイメージから Docker コンテナを実行する](#run-docker-container-public-ecr-dockerhub)」を参照してください。
+ ネットワークプロキシの AWS IoT Greengrass 背後で を実行する場合は、[プロキシサーバー](https://docs.docker.com/network/proxy/)を使用するように Docker デーモンを設定します。
+ Docker イメージが Amazon ECR または Docker Hub に保存されている場合、[Docker コンポーネントマネージャー](docker-application-manager-component.md)コンポーネントを Docker コンテナコンポーネントの従属関係として含めます。コンポーネントをデプロイする前に、コアデバイスの Docker デーモンを起動する必要があります。
また、イメージ URI をコンポーネントアーティファクトとして含めます。イメージ URI は、次の例で示すように、形式 `docker:registry/image[:tag|@digest]` である必要があります。
+ プライベート Amazon ECR イメージ: `docker:account-id.dkr.ecr.region.amazonaws.com/repository/image[:tag|@digest]`
+ パブリック Amazon ECR イメージ: `docker:public.ecr.aws/repository/image[:tag|@digest]`
+ パブリック Docker Hub イメージ: `docker:name[:tag|@digest]`
パブリックリポジトリに格納されているイメージから Docker コンテナを実行する方法の詳細については、「[Amazon ECR または Docker Hub のパブリックイメージから Docker コンテナを実行する](#run-docker-container-public-ecr-dockerhub)」を参照してください。
+ Docker イメージが Amazon ECR プライベートリポジトリに格納されている場合、トークン交換のサービスコンポーネントを従属関係として Docker コンテナコンポーネントに含める必要があります。また、[Greengrass デバイスのロール](device-service-role.md)は、以下の IAM ポリシー例で示されているように、`ecr:GetAuthorizationToken`、`ecr:BatchGetImage`、`ecr:GetDownloadUrlForLayer` アクションを許可する必要があります。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"ecr:GetAuthorizationToken",
"ecr:BatchGetImage",
"ecr:GetDownloadUrlForLayer"
],
"Resource": [
"*"
],
"Effect": "Allow"
}
]
}
```
------
Amazon ECR プライベートリポジトリに格納されているイメージから Docker コンテナを実行する方法の情報については、「[Amazon ECR のプライベートイメージから Docker コンテナを実行](#run-docker-container-private-ecr)」を参照してください。
+ Amazon ECR プライベートリポジトリに保存されている Docker イメージを使用するには、プライベートリポジトリがコアデバイス AWS リージョン と同じ にある必要があります。
+ Docker イメージまたは Compose ファイルが S3 バケットに保存されている場合、[Greengrass デバイスのロール](device-service-role.md)は `s3:GetObject` 許可を付与して、次の IAM ポリシーの例で示すように、コアデバイスがコンポーネントアーティファクトとしてイメージをダウンロードできるようにする必要があります。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"s3:GetObject"
],
"Resource": [
"*"
],
"Effect": "Allow"
}
]
}
```
------
Amazon S3 に格納されているイメージから Docker コンテナを実行する方法の情報については、「[Amazon S3 のイメージから Docker コンテナの実行](#run-docker-container-s3)」を参照してください。
+ Docker コンテナコンポーネントのプロセス間通信 (IPC)、 AWS 認証情報、ストリームマネージャーを使用するには、Docker コンテナの実行時に追加のオプションを指定する必要があります。詳細については次を参照してください:
+ [Docker コンテナコンポーネントでプロセス間通信の使用](#docker-container-ipc)
+ [Docker コンテナコンポーネントで AWS 認証情報を使用する (Linux)](#docker-container-token-exchange-service)
+ [Docker コンテナコンポーネント (Linux) でストリームマネージャーの使用](#docker-container-stream-manager)
## Amazon ECR または Docker Hub のパブリックイメージから Docker コンテナを実行する
このセクションでは、Docker Compose を使用して Amazon ECR と Docker Hub に格納されている Docker イメージから Docker コンテナを実行するカスタムコンポーネントを作成する方法について説明します。
**Docker Compose を使用して Docker コンテナを実行するには**
1. Docker Compose ファイルを作成して Amazon S3 バケットにアップロードします。[Greengrass デバイスのロール](device-service-role.md) がデバイスが Compose ファイルにアクセスできるようにする `s3:GetObject` 許可を付与することを確認します。次の例で示す Compose ファイルの例には、Amazon ECR の Amazon CloudWatch エージェントイメージと、Docker Hub の MySQL イメージが含まれています。
```
version: "3"
services:
cloudwatchagent:
image: "public.ecr.aws/cloudwatch-agent/cloudwatch-agent:latest"
mysql:
image: "mysql:8.0"
```
1. AWS IoT Greengrass コアデバイスに[カスタムコンポーネントを作成します](create-components.md)。次の例に示すレシピの例には、次のプロパティがあります:
+ 従属関係としての Docker アプリケーション マネージャー コンポーネント。このコンポーネントは、 AWS IoT Greengrass がパブリック Amazon ECR と Docker Hub リポジトリからイメージをダウンロードできるようにします。
+ パブリック Amazon ECR リポジトリの Docker イメージを指定するコンポーネントアーティファクト。
+ パブリック Docker Hub リポジトリの Docker イメージを指定するコンポーネントアーティファクト。
+ 実行する Docker イメージのコンテナを含む Docker Compose ファイルを指定するコンポーネントアーティファクト。
+ 指定したイメージからコンテナを作成して起動するため、[docker-compose up](https://docs.docker.com/compose/reference/up/) を使用するライフサイクル実行スクリプト。
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.MyDockerComposeComponent",
"ComponentVersion": "1.0.0",
"ComponentDescription": "A component that uses Docker Compose to run images from public Amazon ECR and Docker Hub.",
"ComponentPublisher": "Amazon",
"ComponentDependencies": {
"aws.greengrass.DockerApplicationManager": {
"VersionRequirement": "~2.0.0"
}
},
"Manifests": [
{
"Platform": {
"os": "all"
},
"Lifecycle": {
"Run": "docker-compose -f {artifacts:path}/docker-compose.yaml up"
},
"Artifacts": [
{
"URI": "docker:public.ecr.aws/cloudwatch-agent/cloudwatch-agent:latest"
},
{
"URI": "docker:mysql:8.0"
},
{
"URI": "s3://amzn-s3-demo-bucket/folder/docker-compose.yaml"
}
]
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.MyDockerComposeComponent
ComponentVersion: '1.0.0'
ComponentDescription: 'A component that uses Docker Compose to run images from public Amazon ECR and Docker Hub.'
ComponentPublisher: Amazon
ComponentDependencies:
aws.greengrass.DockerApplicationManager:
VersionRequirement: ~2.0.0
Manifests:
- Platform:
os: all
Lifecycle:
Run: docker-compose -f {artifacts:path}/docker-compose.yaml up
Artifacts:
- URI: "docker:public.ecr.aws/cloudwatch-agent/cloudwatch-agent:latest"
- URI: "docker:mysql:8.0"
- URI: "s3://amzn-s3-demo-bucket/folder/docker-compose.yaml"
```
------
**注記**
Docker コンテナコンポーネントのプロセス間通信 (IPC)、 AWS 認証情報、ストリームマネージャーを使用するには、Docker コンテナの実行時に追加のオプションを指定する必要があります。詳細については次を参照してください:
[Docker コンテナコンポーネントでプロセス間通信の使用](#docker-container-ipc)
[Docker コンテナコンポーネントで AWS 認証情報を使用する (Linux)](#docker-container-token-exchange-service)
[Docker コンテナコンポーネント (Linux) でストリームマネージャーの使用](#docker-container-stream-manager)
1. [コンポーネントをテスト](test-components.md)してが正常に作動することを確認します。
**重要**
コンポーネントをデプロイする前に、Docker デーモンをインストールして起動する必要があります。
コンポーネントをローカルにデプロイした後、[Docker コンテナ ls](https://docs.docker.com/engine/reference/commandline/container_ls/) コマンドを実行してコンテナが実行されていることを確認できます。
```
docker container ls
```
1. コンポーネントの準備ができたら、コンポーネントを にアップロード AWS IoT Greengrass して他のコアデバイスにデプロイします。詳細については、「[コアデバイスにデプロイするコンポーネントをパブリッシュ](publish-components.md)」を参照してください。
## Amazon ECR のプライベートイメージから Docker コンテナを実行
このセクションでは、Amazon ECR のプライベートリポジトリに格納されている Docker イメージから、Docker コンテナを実行するカスタムコンポーネントを作成する方法について説明します。
**Docker コンテナを実行するには**
1. AWS IoT Greengrass コアデバイスに[カスタムコンポーネントを作成します](create-components.md)。次のプロパティが含まれる次のレシピの例を使用します:
+ 従属関係としての Docker アプリケーション マネージャー コンポーネント。このコンポーネントは、 AWS IoT Greengrass がプライベートリポジトリからイメージをダウンロードするための認証情報を管理できるようにします。
+ 従属関係としてのトークン交換のサービスコンポーネント。このコンポーネントにより、 AWS IoT Greengrass は Amazon ECR とやり取りするための AWS 認証情報を取得できます。
+ プライベート Amazon ECR リポジトリの Docker イメージを指定するコンポーネントアーティファクト。
+ イメージからコンテナを作成して起動するため、[docker 実行](https://docs.docker.com/engine/reference/commandline/run/)を使用するライフサイクル実行スクリプト。
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.MyPrivateDockerComponent",
"ComponentVersion": "1.0.0",
"ComponentDescription": "A component that runs a Docker container from a private Amazon ECR image.",
"ComponentPublisher": "Amazon",
"ComponentDependencies": {
"aws.greengrass.DockerApplicationManager": {
"VersionRequirement": "~2.0.0"
},
"aws.greengrass.TokenExchangeService": {
"VersionRequirement": "~2.0.0"
}
},
"Manifests": [
{
"Platform": {
"os": "all"
},
"Lifecycle": {
"Run": "docker run account-id.dkr.ecr.region.amazonaws.com/repository[:tag|@digest]"
},
"Artifacts": [
{
"URI": "docker:account-id.dkr.ecr.region.amazonaws.com/repository[:tag|@digest]"
}
]
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.MyPrivateDockerComponent
ComponentVersion: '1.0.0'
ComponentDescription: 'A component that runs a Docker container from a private Amazon ECR image.'
ComponentPublisher: Amazon
ComponentDependencies:
aws.greengrass.DockerApplicationManager:
VersionRequirement: ~2.0.0
aws.greengrass.TokenExchangeService:
VersionRequirement: ~2.0.0
Manifests:
- Platform:
os: all
Lifecycle:
Run: docker run account-id.dkr.ecr.region.amazonaws.com/repository[:tag|@digest]
Artifacts:
- URI: "docker:account-id.dkr.ecr.region.amazonaws.com/repository[:tag|@digest]"
```
------
**注記**
Docker コンテナコンポーネントのプロセス間通信 (IPC)、 AWS 認証情報、ストリームマネージャーを使用するには、Docker コンテナの実行時に追加のオプションを指定する必要があります。詳細については次を参照してください:
[Docker コンテナコンポーネントでプロセス間通信の使用](#docker-container-ipc)
[Docker コンテナコンポーネントで AWS 認証情報を使用する (Linux)](#docker-container-token-exchange-service)
[Docker コンテナコンポーネント (Linux) でストリームマネージャーの使用](#docker-container-stream-manager)
1. [コンポーネントをテスト](test-components.md)してが正常に作動することを確認します。
**重要**
コンポーネントをデプロイする前に、Docker デーモンをインストールして起動する必要があります。
コンポーネントをローカルにデプロイした後、[Docker コンテナ ls](https://docs.docker.com/engine/reference/commandline/container_ls/) コマンドを実行してコンテナが実行されていることを確認できます。
```
docker container ls
```
1. コンポーネントを にアップロード AWS IoT Greengrass して、他のコアデバイスにデプロイします。詳細については、「[コアデバイスにデプロイするコンポーネントをパブリッシュ](publish-components.md)」を参照してください。
## Amazon S3 のイメージから Docker コンテナの実行
このセクションでは、Amazon S3 に格納されている Docker イメージのコンポーネントに Docker コンテナを実行する方法について説明します。
**Amazon S3 のイメージのコンポーネントに Docker コンテナを実行するには**
1. [docker 保存](https://docs.docker.com/engine/reference/commandline/save/)コマンドを実行して、Docker コンテナのバックアップを作成します。このバックアップは、 AWS IoT Greengrassでコンテナを実行するコンポーネントアーティファクトとして提供します。*hello-world* をイメージの名前に置き換えて、*hello-world.tar* を作成するアーカイブファイルの名前に置き換えます。
```
docker save hello-world > artifacts/com.example.MyDockerComponent/1.0.0/hello-world.tar
```
1. AWS IoT Greengrass コアデバイスに[カスタムコンポーネントを作成します](create-components.md)。次のプロパティが含まれる次のレシピの例を使用します:
+ アーカイブから Docker イメージをロードするため、[docker ロード](https://docs.docker.com/engine/reference/commandline/load/)を使用するライフサイクル インストール スクリプト。
+ イメージからコンテナを作成して起動するため、[docker 実行](https://docs.docker.com/engine/reference/commandline/run/)を使用するライフサイクル実行スクリプト。`--rm` オプションは、コンテナの終了時にコンテナのクリーンアップが実行します。
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.MyS3DockerComponent",
"ComponentVersion": "1.0.0",
"ComponentDescription": "A component that runs a Docker container from an image in an S3 bucket.",
"ComponentPublisher": "Amazon",
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"install": {
"Script": "docker load -i {artifacts:path}/hello-world.tar"
},
"Run": {
"Script": "docker run --rm hello-world"
}
}
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.MyS3DockerComponent
ComponentVersion: '1.0.0'
ComponentDescription: 'A component that runs a Docker container from an image in an S3 bucket.'
ComponentPublisher: Amazon
Manifests:
- Platform:
os: linux
Lifecycle:
install:
Script: docker load -i {artifacts:path}/hello-world.tar
Run:
Script: docker run --rm hello-world
```
------
**注記**
Docker コンテナコンポーネントのプロセス間通信 (IPC)、 AWS 認証情報、ストリームマネージャーを使用するには、Docker コンテナの実行時に追加のオプションを指定する必要があります。詳細については次を参照してください:
[Docker コンテナコンポーネントでプロセス間通信の使用](#docker-container-ipc)
[Docker コンテナコンポーネントで AWS 認証情報を使用する (Linux)](#docker-container-token-exchange-service)
[Docker コンテナコンポーネント (Linux) でストリームマネージャーの使用](#docker-container-stream-manager)
1. [コンポーネントをテスト](test-components.md)してが正常に作動することを確認します。
コンポーネントをローカルにデプロイした後、[Docker コンテナ ls](https://docs.docker.com/engine/reference/commandline/container_ls/) コマンドを実行してコンテナが実行されていることを確認できます。
```
docker container ls
```
1. コンポーネントの準備ができたら、S3 バケットに Docker イメージアーカイブをアップロードし、コンポーネントレシピに URI を追加します。次に、コンポーネントを にアップロード AWS IoT Greengrass して、他のコアデバイスにデプロイできます。詳細については、「[コアデバイスにデプロイするコンポーネントをパブリッシュ](publish-components.md)」を参照してください。
完了したら、コンポーネントレシピは次の例のようになります。
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.MyS3DockerComponent",
"ComponentVersion": "1.0.0",
"ComponentDescription": "A component that runs a Docker container from an image in an S3 bucket.",
"ComponentPublisher": "Amazon",
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"install": {
"Script": "docker load -i {artifacts:path}/hello-world.tar"
},
"Run": {
"Script": "docker run --rm hello-world"
}
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.MyDockerComponent/1.0.0/hello-world.tar"
}
]
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.MyS3DockerComponent
ComponentVersion: '1.0.0'
ComponentDescription: 'A component that runs a Docker container from an image in an S3 bucket.'
ComponentPublisher: Amazon
Manifests:
- Platform:
os: linux
Lifecycle:
install:
Script: docker load -i {artifacts:path}/hello-world.tar
Run:
Script: docker run --rm hello-world
Artifacts:
- URI: s3://amzn-s3-demo-bucket/artifacts/com.example.MyDockerComponent/1.0.0/hello-world.tar
```
------
## Docker コンテナコンポーネントでプロセス間通信の使用
で Greengrass プロセス間通信 (IPC) ライブラリを使用して AWS IoT Device SDK 、Greengrass nucleus、その他の Greengrass コンポーネント、および と通信できます AWS IoT Core。詳細については、「[を使用して AWS IoT Device SDK Greengrass nucleus、その他のコンポーネント、および と通信します。 AWS IoT CoreGreengrass nucleus、その他のコンポーネント、および と通信する AWS IoT Core](interprocess-communication.md)」を参照してください。
Docker コンテナコンポーネントで IPC を使用するには、次のパラメータで Docker コンテナを実行する必要があります。
+ IPC ソケットをコンテナに取り付けます。Greengrass nucleus は、`AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT` 環境変数で IPC ソケットファイルパスを提供します。
+ `SVCUID` と `AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT` の環境変数を Greengrass nucleus がコンポーネントに提供する値に設定します。コンポーネントは、これらの環境変数を使用して Greengrass nucleus への接続を認証します。
**Example レシピの例: MQTT メッセージを AWS IoT Core (Python) に発行する**
次のレシピは、MQTT メッセージを発行する Docker コンテナコンポーネントの例を定義します AWS IoT Core。このレシピには以下のプロパティがあります。
+ コンポーネントが AWS IoT Core すべてのトピックで MQTT メッセージを に発行できるようにする認可ポリシー (`accessControl`)。詳細については、「[コンポーネントに IPC オペレーションの実行を許可する](interprocess-communication.md#ipc-authorization-policies)」と「[AWS IoT Core MQTT IPC 承認](ipc-iot-core-mqtt.md#ipc-iot-core-mqtt-authorization)」を参照してください。
+ Amazon S3 の Docker イメージを TAR アーカイブとして指定するコンポーネントアーティファクト。
+ TAR アーカイブから Docker イメージをロードするライフサイクル インストール スクリプト。
+ イメージから Docker コンテナを実行するライフサイクル実行スクリプト。[Docker 実行](https://docs.docker.com/engine/reference/run/)コマンドは次の引数がありります。
+ `-v` 引数は Greengrass IPC ソケットをコンテナにマウントします。
+ 最初の 2 つの `-e` 引数は、Docker コンテナに必要な環境変数を設定します。
+ 追加の `-e` 引数は、この例で使用される環境変数を設定します。
+ `--rm` 引数は、終了時にコンテナのクリーンアップを実行します。
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.python.docker.PublishToIoTCore",
"ComponentVersion": "1.0.0",
"ComponentDescription": "Uses interprocess communication to publish an MQTT message to IoT Core.",
"ComponentPublisher": "Amazon",
"ComponentConfiguration": {
"DefaultConfiguration": {
"topic": "test/topic/java",
"message": "Hello, World!",
"qos": "1",
"accessControl": {
"aws.greengrass.ipc.mqttproxy": {
"com.example.python.docker.PublishToIoTCore:pubsub:1": {
"policyDescription": "Allows access to publish to IoT Core on all topics.",
"operations": [
"aws.greengrass#PublishToIoTCore"
],
"resources": [
"*"
]
}
}
}
}
},
"Manifests": [
{
"Platform": {
"os": "all"
},
"Lifecycle": {
"install": "docker load -i {artifacts:path}/publish-to-iot-core.tar",
"Run": "docker run -v $AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT:$AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT -e SVCUID -e AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT -e MQTT_TOPIC=\"{configuration:/topic}\" -e MQTT_MESSAGE=\"{configuration:/message}\" -e MQTT_QOS=\"{configuration:/qos}\" --rm publish-to-iot-core"
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.python.docker.PublishToIoTCore/1.0.0/publish-to-iot-core.tar"
}
]
}
]
}
```
```
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.python.docker.PublishToIoTCore
ComponentVersion: 1.0.0
ComponentDescription: Uses interprocess communication to publish an MQTT message to IoT Core.
ComponentPublisher: Amazon
ComponentConfiguration:
DefaultConfiguration:
topic: 'test/topic/java'
message: 'Hello, World!'
qos: '1'
accessControl:
aws.greengrass.ipc.mqttproxy:
'com.example.python.docker.PublishToIoTCore:pubsub:1':
policyDescription: Allows access to publish to IoT Core on all topics.
operations:
- 'aws.greengrass#PublishToIoTCore'
resources:
- '*'
Manifests:
- Platform:
os: all
Lifecycle:
install: 'docker load -i {artifacts:path}/publish-to-iot-core.tar'
Run: |
docker run \
-v $AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT:$AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT \
-e SVCUID \
-e AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT \
-e MQTT_TOPIC="{configuration:/topic}" \
-e MQTT_MESSAGE="{configuration:/message}" \
-e MQTT_QOS="{configuration:/qos}" \
--rm publish-to-iot-core
Artifacts:
- URI: s3://amzn-s3-demo-bucket/artifacts/com.example.python.docker.PublishToIoTCore/1.0.0/publish-to-iot-core.tar
```
## Docker コンテナコンポーネントで AWS 認証情報を使用する (Linux)
[トークン交換サービスコンポーネント](token-exchange-service-component.md)を使用して、Greengrass コンポーネントの AWS サービスとやり取りできます。このコンポーネントは、ローカル コンテナ サーバーを使用してコアデバイスの[トークン交換ロール](device-service-role.md)の AWS 認証情報を提供します。詳細については、「[AWS サービスとやり取り](interact-with-aws-services.md)」を参照してください。
**注記**
このセクションの例は Linux コアデバイスにのみ使えます。
Docker コンテナコンポーネントでトークン交換サービスの AWS 認証情報を使用するには、次のパラメータを指定して Docker コンテナを実行する必要があります。
+ `--network=host` 引数を使用して、ホストネットワークへのアクセスを提供します。このオプションを使用すると、Docker コンテナはローカルトークン交換サービスに接続して AWS 認証情報を取得できます。この引数は、Linux 用 Docker にのみ機能します。
**警告**
このオプションは、コンテナがホストのすべてのローカル ネットワーク インターフェイスにアクセスできるようにするため、このオプションは、ホストネットワークにこのアクセスなしで Docker コンテナを実行した場合よりも安全性が低くなります。このオプションを使用する Docker コンテナコンポーネントを開発して実行するときに、この点に注意してください。詳細については、「Docker マニュアル」の「[ネットワーク: ホスト](https://docs.docker.com/engine/reference/run/#network-host)」を参照してください。
+ Greengrass nucleus がコンポーネントに提供する値に `AWS_CONTAINER_CREDENTIALS_FULL_URI`および `AWS_CONTAINER_AUTHORIZATION_TOKEN`環境変数を設定します。 AWS SDKsこれらの環境変数を使用して AWS 認証情報を取得します。
**Example レシピの例: Docker コンテナコンポーネント (Python) で S3 バケットを一覧表示**
次のレシピは、 AWS アカウントの S3 バケットを一覧表示する Docker コンテナコンポーネントの例を定義します。このレシピには以下のプロパティがあります。
+ 従属関係としてのトークン交換のサービスコンポーネント。この依存関係により、コンポーネントは他の AWS サービスとやり取りするための AWS 認証情報を取得できます。
+ Amazon S3 の Docker イメージを TAR アーカイブとして指定するコンポーネントアーティファクト。
+ TAR アーカイブから Docker イメージをロードするライフサイクル インストール スクリプト。
+ イメージから Docker コンテナを実行するライフサイクル実行スクリプト。[Docker 実行](https://docs.docker.com/engine/reference/run/)コマンドは次の引数がありります。
+ `--network=host` 引数は、コンテナがホストネットワークにアクセスを提供するため、コンテナがトークン交換サービスに接続できます。
+ `-e` 引数は、Docker コンテナの必要な環境変数を設定します。
+ `--rm` 引数は、終了時にコンテナのクリーンアップを実行します。
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.python.docker.ListS3Buckets",
"ComponentVersion": "1.0.0",
"ComponentDescription": "Uses the token exchange service to lists your S3 buckets.",
"ComponentPublisher": "Amazon",
"ComponentDependencies": {
"aws.greengrass.TokenExchangeService": {
"VersionRequirement": "^2.0.0",
"DependencyType": "HARD"
}
},
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"install": "docker load -i {artifacts:path}/list-s3-buckets.tar",
"Run": "docker run --network=host -e AWS_CONTAINER_AUTHORIZATION_TOKEN -e AWS_CONTAINER_CREDENTIALS_FULL_URI --rm list-s3-buckets"
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.python.docker.ListS3Buckets/1.0.0/list-s3-buckets.tar"
}
]
}
]
}
```
```
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.python.docker.ListS3Buckets
ComponentVersion: 1.0.0
ComponentDescription: Uses the token exchange service to lists your S3 buckets.
ComponentPublisher: Amazon
ComponentDependencies:
aws.greengrass.TokenExchangeService:
VersionRequirement: ^2.0.0
DependencyType: HARD
Manifests:
- Platform:
os: linux
Lifecycle:
install: 'docker load -i {artifacts:path}/list-s3-buckets.tar'
Run: |
docker run \
--network=host \
-e AWS_CONTAINER_AUTHORIZATION_TOKEN \
-e AWS_CONTAINER_CREDENTIALS_FULL_URI \
--rm list-s3-buckets
Artifacts:
- URI: s3://amzn-s3-demo-bucket/artifacts/com.example.python.docker.ListS3Buckets/1.0.0/list-s3-buckets.tar
```
## Docker コンテナコンポーネント (Linux) でストリームマネージャーの使用
[ストリーム マネージャー コンポーネント](stream-manager-component.md) を使用して Greengrass コンポーネントのデータストリームを管理します。このコンポーネントを使用すると、データストリームを処理し、大量の IoT データを に転送できます AWS クラウド。 は、ストリームマネージャーコンポーネントとのやり取りに使用するストリームマネージャー SDK AWS IoT Greengrass を提供します。詳細については、「[Greengrass コアデバイスでのデータストリームの管理](manage-data-streams.md)」を参照してください。
**注記**
このセクションの例は Linux コアデバイスにのみ使えます。
Docker コンテナコンポーネントでストリームマネージャー SDK を使用するには、次のパラメータで Docker コンテナを実行する必要があります。
+ `--network=host` 引数を使用して、ホストネットワークへのアクセスを提供します。このオプションは、Docker コンテナがローカル TLS 接続を介してストリームマネージャーコンポーネントとやり取りできるようにします。この引数は Linux 用 Docker にのみ使えます
**警告**
このオプションは、コンテナがホストのすべてのローカル ネットワーク インターフェイスにアクセスできるようにするため、このオプションは、ホストネットワークにこのアクセスなしで Docker コンテナを実行した場合よりも安全性が低くなります。このオプションを使用する Docker コンテナコンポーネントを開発して実行するときに、この点に注意してください。詳細については、「Docker マニュアル」の「[ネットワーク: ホスト](https://docs.docker.com/engine/reference/run/#network-host)」を参照してください。
+ 認証を要求する (デフォルト動作) ようにストリーム マネージャー コンポーネントを設定する場合、`AWS_CONTAINER_CREDENTIALS_FULL_URI` 環境変数を Greengrass nucleus がコンポーネントに提供する値に設定します。詳細については、「[ストリームマネージャーの設定](stream-manager-component.md#stream-manager-component-configuration)」を参照してください。
+ ストリーム マネージャー コンポーネントがデフォルト以外のポートを使用するように設定する場合は、[プロセス間通信 (IPC)](interprocess-communication.md) を使用してストリーム マネージャー コンポーネント設定からポートを取得します。IPC を使用するには、追加オプションを指定して Docker コンテナを実行する必要があります。詳細については次を参照してください:
+ [アプリケーションコードでストリームマネージャーに接続](use-stream-manager-in-custom-components.md#connect-to-stream-manager)
+ [Docker コンテナコンポーネントでプロセス間通信の使用](#docker-container-ipc)
**Example レシピの例: Docker コンテナコンポーネント (Python) で S3 バケットにファイルのストリーミング**
次のレシピは、ファイルを作成して S3 バケットにストリーミングする Docker コンテナコンポーネントの例を定義します。このレシピには以下のプロパティがあります。
+ 従属関係としてのストリーム マネージャー コンポーネント。この依存関係により、コンポーネントはストリームマネージャー SDK を使用してストリームマネージャーコンポーネントとやり取りできます。
+ Amazon S3 の Docker イメージを TAR アーカイブとして指定するコンポーネントアーティファクト。
+ TAR アーカイブから Docker イメージをロードするライフサイクル インストール スクリプト。
+ イメージから Docker コンテナを実行するライフサイクル実行スクリプト。[Docker 実行](https://docs.docker.com/engine/reference/run/)コマンドは次の引数がありります。
+ `--network=host` 引数は、コンテナにホストネットワークへのアクセスを提供するため、コンテナがストリームマネージャーコンポーネントに接続できます。
+ 最初の `-e` 引数は、Docker コンテナの必要な `AWS_CONTAINER_AUTHORIZATION_TOKEN` 環境変数を設定します。
+ 追加の `-e` 引数は、この例で使用される環境変数を設定します。
+ `-v` 引数は、コンポーネントの[作業フォルダ](component-recipe-reference.md#component-recipe-work-path)をコンテナにマウントします。この例では、ストリームマネージャーを使用して、Amazon S3 にアップロードするファイルを作業フォルダに作成します。
+ `--rm` 引数は、終了時にコンテナのクリーンアップを実行します。
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.python.docker.StreamFileToS3",
"ComponentVersion": "1.0.0",
"ComponentDescription": "Creates a text file and uses stream manager to stream the file to S3.",
"ComponentPublisher": "Amazon",
"ComponentDependencies": {
"aws.greengrass.StreamManager": {
"VersionRequirement": "^2.0.0",
"DependencyType": "HARD"
}
},
"ComponentConfiguration": {
"DefaultConfiguration": {
"bucketName": ""
}
},
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"install": "docker load -i {artifacts:path}/stream-file-to-s3.tar",
"Run": "docker run --network=host -e AWS_CONTAINER_AUTHORIZATION_TOKEN -e BUCKET_NAME=\"{configuration:/bucketName}\" -e WORK_PATH=\"{work:path}\" -v {work:path}:{work:path} --rm stream-file-to-s3"
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.python.docker.StreamFileToS3/1.0.0/stream-file-to-s3.tar"
}
]
}
]
}
```
```
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.python.docker.StreamFileToS3
ComponentVersion: 1.0.0
ComponentDescription: Creates a text file and uses stream manager to stream the file to S3.
ComponentPublisher: Amazon
ComponentDependencies:
aws.greengrass.StreamManager:
VersionRequirement: ^2.0.0
DependencyType: HARD
ComponentConfiguration:
DefaultConfiguration:
bucketName: ''
Manifests:
- Platform:
os: linux
Lifecycle:
install: 'docker load -i {artifacts:path}/stream-file-to-s3.tar'
Run: |
docker run \
--network=host \
-e AWS_CONTAINER_AUTHORIZATION_TOKEN \
-e BUCKET_NAME="{configuration:/bucketName}" \
-e WORK_PATH="{work:path}" \
-v {work:path}:{work:path} \
--rm stream-file-to-s3
Artifacts:
- URI: s3://amzn-s3-demo-bucket/artifacts/com.example.python.docker.StreamFileToS3/1.0.0/stream-file-to-s3.tar
```
# AWS IoT Greengrass コンポーネントレシピリファレンス
コンポーネントレシピは、コンポーネントの詳細、依存関係、アーティファクト、およびライフサイクルを定義するファイルです。コンポーネントのライフサイクルでは、コンポーネントのインストール、実行、シャットダウンなどのために実行するコマンドを指定します。 AWS IoT Greengrass コアは、レシピで定義したライフサイクルを使用してコンポーネントをインストールして実行します。この AWS IoT Greengrass サービスは レシピを使用して、コンポーネントのデプロイ時にコアデバイスにデプロイする依存関係とアーティファクトを識別します。
レシピでは、コンポーネントがサポートしているプラットフォームごとに、固有の依存関係とライフサイクルを定義できます。この機能を使用すれば、要件が異なる複数のプラットフォームを持つデバイスにコンポーネントをデプロイすることができます。また、これを使用して、 がコンポーネントをサポートしていないデバイスにコンポーネントをインストール AWS IoT Greengrass しないようにすることもできます。
各レシピには、マニフェストのリストが含まれます。各マニフェストは、プラットフォームがそれらの要件を満たすコアデバイスに使用する一連のプラットフォーム要件、ライフサイクル、そしてアーティファクトを指定します。コアデバイスは、デバイスが満たすプラットフォーム要件が含まれる最初のマニフェストを使用します。プラットフォーム要件のないマニフェストを指定すれば、すべてのコアデバイスと一致します。
マニフェストにないグローバルライフサイクルを指定することもできます。グローバルライフサイクルでは、ライフサイクルのサブセクションを識別する選択キーを使用することができます。その後、マニフェスト内でこれらの選択キーを指定することで、マニフェストのライフサイクルに加えて、グローバルライフサイクルのこれらのセクションも使用することができます。コアデバイスは、マニフェストがライフサイクルを定義していない場合にのみ、マニフェストの選択キーを使用します。マニフェストの `all` 選択を使用すると、選択キーのないグローバルライフサイクルのセクションに一致させることができます。
AWS IoT Greengrass Core ソフトウェアは、コアデバイスに一致するマニフェストを選択した後、以下を実行して、使用するライフサイクルステップを特定します。
+ 選択したマニフェストがライフサイクルを定義している場合、コアデバイスはそのライフサイクルを使用します。
+ 選択したマニフェストがライフサイクルを定義していない場合、コアデバイスはグローバルサイクルを使用します。コアデバイスは、グローバルライフサイクルのどのセクションを使用するかを特定するために以下を実行します。
+ マニフェストが選択キーを定義している場合、コアデバイスはマニフェストの選択キーが含まれるグローバルライフサイクルのセクションを使用します。
+ マニフェストが選択キーを定義していない場合、コアデバイスはマニフェストの選択キーが含まれないグローバルライフサイクルのセクションを使用します。この動作は、`all` 選択を定義するマニフェストと同じです。
**重要**
コアデバイスは、コンポーネントをインストールするにあたり、マニフェストのプラットフォーム要件を少なくとも 1 つ満たす必要があります。コアデバイスに一致するマニフェストがない場合、 AWS IoT Greengrass Core ソフトウェアはコンポーネントをインストールせず、デプロイは失敗します。
レシピは [JSON](https://en.wikipedia.org/wiki/JSON) または [YAML](https://en.wikipedia.org/wiki/YAML) 形式で定義できます。レシピの例セクションには、各形式のレシピが含まれています。
**Topics**
+ [レシピの検証](#recipe-validation)
+ [レシピの形式](#recipe-format)
+ [レシピ変数](#recipe-variables)
+ [レシピの例](#recipe-examples)
## レシピの検証
Greengrass は、コンポーネントバージョンを作成するときに JSON または YAML コンポーネントレシピを検証します。このレシピの検証では、デプロイの問題の可能性を防ぐために、JSON または YAML コンポーネントレシピに一般的なエラーがないかをチェックします。検証では、レシピに一般的なエラー (カンマ、中括弧、フィールドの欠落など) がないかチェックし、レシピに正しい形式が使用されていることを確認します。
レシピ検証エラーメッセージが表示された場合は、カンマ、中括弧、またはフィールドが欠落していないかレシピを確認してください。[レシピの形式](#recipe-format)を見て、フィールドが欠落していないことを確認します。
## レシピの形式
コンポーネントのレシピを定義するときには、レシピドキュメントで次の情報を指定します。YAML と JSON 形式のレシピにも同じ構造が適用されます。
`RecipeFormatVersion`
レシピのテンプレートバージョン。次のオプションを選択します。
+ `2020-01-25`
`ComponentName`
このレシピが定義するコンポーネントの名前。コンポーネント名は、各リージョンの AWS アカウント で一意である必要があります。
**ヒント**
+ 逆ドメイン名の形式にすれば、社内での名前のコリジョンを回避することができます。例えば、会社が `example.com` を所有しており、太陽エネルギープロジェクトに取り組んでいる場合は、Hello World コンポーネントの名前を `com.example.solar.HelloWorld` にすることができます。こうすることで、会社内のコンポーネント名のコリジョンを回避できます。
+ コンポーネント名に `aws.greengrass` プレフィックスを使用することは避けてください。 AWS IoT Greengrass は提供する[パブリックコンポーネント](public-components.md)でこのプレフィックスを使用します。パブリックコンポーネントと同じ名前を選択すると、パブリックコンポーネントがあなたのコンポーネントに置き換えられます。次に、 は、そのパブリックコンポーネントへの依存関係を持つコンポーネントをデプロイするときに、パブリックコンポーネントの代わりにコンポーネント AWS IoT Greengrass を提供します。この機能を使用すると、パブリックコンポーネントの動作を上書きできますが、パブリックコンポーネントの上書きを意図していない場合には、他のコンポーネントも破損させてしまう可能性があります。
`ComponentVersion`
コンポーネントのバージョン。major、minor、および patch の各値の最大値は 999999 です。
AWS IoT Greengrass はコンポーネントにセマンティックバージョンを使用します。セマンティックバージョンは、major.minor.patch といった番号システムに準拠します。例えば、バージョン `1.0.0` は、コンポーネントの最初のメジャーリリースを表しています。詳細については、「[セマンティックバージョンの仕様](https://semver.org/)」を参照してください。
`ComponentDescription`
(オプション) コンポーネントの説明。
`ComponentPublisher`
コンポーネントのパブリッシャーまたは作成者。
`ComponentConfiguration`
(オプション) コンポーネントの設定またはパラメータを定義するオブジェクト。デフォルト設定を定義しておけば、コンポーネントをデプロイするときに、コンポーネントに提供する設定オブジェクトを指定することができます。コンポーネント設定は、ネストされたパラメータと構造をサポートします。このオブジェクトには、次の情報が含まれます。
`DefaultConfiguration`
コンポーネントのデフォルト設定を定義するオブジェクト。このオブジェクトの構造を定義します。
AWS IoT Greengrass は設定値に JSON を使用します。JSON は数値タイプを指定しますが、整数と浮動小数点数を区別しません。その結果、 AWS IoT Greengrassで設定値が浮動小数点数に変換されることがあります。コンポーネントが正しいデータタイプを使用することを確認するには、数値の設定値を文字列として定義することをお勧めします。次に、整数または浮動小数点としてコンポーネントでパースします。これにより、設定値が設定とコアデバイスに対して同じタイプであることを保証します。
`ComponentDependencies`
(オプション) コンポーネントのコンポーネント依存関係を定義するオブジェクトのディクショナリ。各オブジェクトのキーは、コンポーネントの依存関係の名前を識別します。 AWS IoT Greengrass は、コンポーネントのインストール時にコンポーネントの依存関係をインストールします。 は、コンポーネントの起動前に依存関係が開始されるまで AWS IoT Greengrass 待機します。各オブジェクトには、次の情報が含まれます:
`VersionRequirement`
この依存関係との互換性のあるコンポーネントバージョンを定義する npm スタイルのセマンティックバージョン制約。1 つのバージョンまたはバージョンの範囲を指定できます。詳細については、「[npm セマンティックバージョン計算ツール](https://semver.npmjs.com/)」を参照してください。
`DependencyType`
(オプション) 依存関係のタイプ。次のオプションから選択します。
+ `SOFT` - 依存関係が状態を変化させても、コンポーネントは再起動しません。
+ `HARD` - 依存関係が状態を変化させると、コンポーネントは再起動します。
デフォルトは `HARD` です。
`ComponentType`
(オプション) コンポーネントのタイプ。
コンポーネントの作成時に recipe. AWS IoT Greengrass sets でコンポーネントタイプを指定することはお勧めしません。
タイプは、次のいずれかになります。
+ `aws.greengrass.generic` - コンポーネントはコマンドを実行するか、アーティファクトを提供します。
+ `aws.greengrass.lambda` – コンポーネントは [Lambda ランチャーコンポーネント](lambda-launcher-component.md)を使用して、 Lambda 関数を実行します。`ComponentSource` パラメータは、このコンポーネントが実行する Lambda 関数の ARN を指定します。
Lambda 関数からコンポーネントを作成する AWS IoT Greengrass ときに によって設定されるため、このオプションを使用することはお勧めしません。詳細については、「[AWS Lambda 関数を実行する](run-lambda-functions.md)」を参照してください。
+ `aws.greengrass.plugin` – コンポーネントは Greengrass nucleus と同じ Java 仮想マシン (JVM) で実行されます。プラグインコンポーネントをデプロイするか再起動すると、Greengrass nucleus が再起動します。
プラグインコンポーネントは Greengrass nucleus と同じログファイルを使用します。詳細については、「[AWS IoT Greengrass ログのモニタリング](monitor-logs.md)」を参照してください。
このオプションは、Greengrass nucleus と直接インターフェイスする AWS Java で記述された提供コンポーネントを対象としているため、コンポーネントレシピで使用することはお勧めしません。どのパブリックコンポーネントがプラグインなのかの詳細については、「[AWS が提供したコンポーネント](public-components.md)」を参照してください。
+ `aws.greengrass.nucleus` - nucleus コンポーネント。詳細については、「[Greengrass nucleus](greengrass-nucleus-component.md)」を参照してください。
コンポーネントレシピでこのオプションを使用することは推奨しません。これは、Greengrass nucleus コンポーネントを対象としたもので、 AWS IoT Greengrass Core ソフトウェアの最低限の機能のみが提供されるからです。
レシピからコンポーネントを作成する場合は `aws.greengrass.generic`、Lambda 関数からコンポーネントを作成する場合は `aws.greengrass.lambda` がデフォルトです。
詳細については、「[コンポーネントタイプ](develop-greengrass-components.md#component-types)」を参照してください。
`ComponentSource`
(オプション) コンポーネントが実行する Lambda 関数の ARN。
Lambda 関数からコンポーネントを作成するときに、recipe. AWS IoT Greengrass sets でコンポーネントソースを指定することはお勧めしません。詳細については、「[AWS Lambda 関数を実行する](run-lambda-functions.md)」を参照してください。
`Manifests`
オブジェクトのリストで、各オブジェクトがコンポーネントのライフサイクル、パラメータ、およびプラットフォームに対する要件を定義しています。コアデバイスが複数のマニフェストのプラットフォーム要件に一致する場合、 はコアデバイスが一致する最初のマニフェスト AWS IoT Greengrass を使用します。コアデバイスが正しいマニフェストを確実に使用するように、まずはより厳格なプラットフォーム要件を持つマニフェストを定義してください。すべてのプラットフォームに適用されるマニフェストは、リストの最後のマニフェストである必要があります。
コアデバイスは、コンポーネントをインストールするにあたり、マニフェストのプラットフォーム要件を少なくとも 1 つ満たす必要があります。コアデバイスに一致するマニフェストがない場合、 AWS IoT Greengrass Core ソフトウェアはコンポーネントをインストールせず、デプロイは失敗します。
各オブジェクトには、次の情報が含まれます:
`Name`
(オプション) このマニフェストが定義するプラットフォームのわかりやすい名前。
このパラメータを省略すると、 はプラットフォーム`os`と から名前 AWS IoT Greengrass を作成します`architecture`。
`Platform`
(オプション) このマニフェストが適用されるプラットフォームを定義するオブジェクト。すべてのプラットフォームに適用されるマニフェストを定義する場合は、このパラメータを省略します。
このオブジェクトは、コアデバイスが動作するプラットフォームに関するキーと値のペアを指定します。このコンポーネントをデプロイすると、 AWS IoT Greengrass Core ソフトウェアはこれらのキーと値のペアをコアデバイスのプラットフォーム属性と比較します。 AWS IoT Greengrass Core ソフトウェアは常に `os`と を定義し`architecture`、追加の属性を定義する場合があります。Greengrass nucleus コンポーネントをデプロイするときに、コアデバイスのカスタムプラットフォーム属性を指定することができます。詳細については、「[Greengrass nucleus コンポーネント](greengrass-nucleus-component.md)」の「[プラットフォームの上書きパラメータ](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration-platform-overrides)」を参照してください。
キーと値のペアごとに、次のいずれかの値を指定できます。
+ `linux` または `windows` などの正確な値。正確な値は、数字または文字で始まっている必要があります。
+ `*`: これはすべての値と一致します。値が存在しない場合でも一致します。
+ `/windows|linux/` などの Java スタイルの正規表現。正規表現は、スラッシュ文字 (`/`) で開始し終了する必要があります。たとえば、正規表現 `/.+/` は空白以外のすべての値と一致します。
このオブジェクトには、次の情報が含まれます。
`runtime`
このマニフェストがサポートするプラットフォームの [Greengrass nucleus ランタイム](https://docs.aws.amazon.com/greengrass/v2/developerguide/how-it-works.html#concept-overview)。プラットフォーム `runtime` で複数のマニフェストを定義する場合、レシピでサポートされているランタイム値は `aws_nucleus_lite` および `*` のみです。クラシックデバイスをターゲットにするには、レシピでランタイムフィールドを指定しないでください。サポートされている Greengrass Nucleus ランタイムには、以下の値が含まれます。
+ `*`
+ `aws_nucleus_lite`
`os`
(オプション) このマニフェストがサポートするプラットフォームのオペレーティングシステムの名前。一般的なプラットフォームには次の値が含まれます。
+ `linux`
+ `windows`
+ `darwin` (macOS)
`architecture`
(オプション) このマニフェストがサポートするプラットフォームのプロセッサアーキテクチャ。一般的なアーキテクチャには次の値が含まれます。
+ `amd64`
+ `arm`
+ `aarch64`
+ `x86`
`architecture.detail`
(オプション) このマニフェストがサポートするプラットフォームのプロセッサアーキテクチャの詳細。一般的なアーキテクチャの詳細には次の値が含まれます。
+ `arm61`
+ `arm71`
+ `arm81`
`key`
(オプション) このマニフェストに対して定義するプラットフォーム属性。*Key* をプラットフォーム属性の名前に置き換えます。 AWS IoT Greengrass Core ソフトウェアは、このプラットフォーム属性を Greengrass nucleus コンポーネント設定で指定したキーと値のペアと一致させます。詳細については、「[Greengrass nucleus コンポーネント](greengrass-nucleus-component.md)」の「[プラットフォームの上書きパラメータ](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration-platform-overrides)」を参照してください。
逆ドメイン名の形式にすれば、社内での名前のコリジョンを回避することができます。例えば、会社が `example.com` を所有していて、ラジオプロジェクトで作業している場合には、カスタムプラットフォーム属性に `com.example.radio.RadioModule` という名前を付けることができます。こうすることで、会社内のプラットフォーム属性名のコリジョンを回避できます。
たとえば、`com.example.radio.RadioModule` というプラットフォーム属性を定義して、コアデバイスで利用可能な無線モジュールに基づいて、異なるマニフェストを指定することができます。各マニフェストには、異なるハードウェア設定に適用する異なるアーティファクトを含めることができるため、コアデバイスにデプロイするソフトウェアセットを最小限に抑えることができます。
`Lifecycle`
このマニフェストが定義するプラットフォームに、コンポーネントをインストールして実行する方法を定義するオブジェクトまたは文字列。すべてのプラットフォームに適用される[グローバルライフサイクル](#global-lifecycle-definition)を定義することもできます。コアデバイスは、使用するマニフェストでライフサイクルが指定されていない場合にのみ、グローバルライフサイクルを使用します。
このライフサイクルはマニフェスト内で定義します。ここで指定するライフサイクルステップは、このマニフェストが定義するプラットフォームにのみ適用されます。すべてのプラットフォームに適用される[グローバルライフサイクル](#global-lifecycle-definition)を定義することもできます。
このオブジェクトまたは文字列には、次の情報が含まれます。
`Setenv`
(オプション) すべてのライフサイクルスクリプトに提供する、環境変数のディクショナリ。これらの環境変数は、各ライフサイクルスクリプトの `Setenv` で上書きすることができます。
`install`
(オプション) コンポーネントのインストール時に実行するスクリプトを定義するオブジェクトまたは文字列。 AWS IoT Greengrass Core ソフトウェアは、ソフトウェアが起動するたびにこのライフサイクルステップも実行します。
`install` スクリプトが成功コードで終了すると、コンポーネントは `INSTALLED` 状態に入ります。
このオブジェクトまたは文字列には、次の情報が含まれます。
`Script`
実行するスクリプト。
`RequiresPrivilege`
(オプション) ルート権限でスクリプトを実行できます。このオプションを に設定すると`true`、 AWS IoT Greengrass Core ソフトウェアはこのコンポーネントを実行するように設定したシステムユーザーとしてではなく、このライフサイクルスクリプトをルートとして実行します。デフォルトは `false` です。
`Skipif`
(オプション) スクリプトを実行するかどうかを決定するためのチェック。実行可能ファイルがパス上にあるかどうか、あるいはファイルが存在するかどうかを確認するように定義できます。出力が true の場合、 AWS IoT Greengrass Core ソフトウェアはステップをスキップします。次のいずれかの値を選択します。
+ `onpath runnable` - システムパス上に runnable があるかどうかをチェックします。例えば、Python 3 が利用可能な場合には、**onpath python3** を使用してこのライフサイクルステップをスキップします。
+ `exists file` - ファイルが存在するかどうかをチェックします。たとえば、`/tmp/my-configuration.db` が存在する場合には、**exists /tmp/my-configuration.db** を使用してこのライフサイクルステップをスキップします。
`Timeout`
(オプション) AWS IoT Greengrass Core ソフトウェアがプロセスを終了する前に、スクリプトが実行できる最大時間 (秒単位)。
デフォルト: 120 秒
`Setenv`
(オプション) スクリプトに提供する環境変数のディクショナリ。これらの環境変数は、`Lifecycle.Setenv` で指定した変数を上書きします。
`run`
(オプション) コンポーネントの開始時に実行するスクリプトを定義するオブジェクトまたは文字列。
このライフサイクルステップが実行されると、コンポーネントは `RUNNING` 状態に入ります。`run` スクリプトが成功コードで終了すると、コンポーネントは `STOPPING` 状態に入ります。`shutdown` スクリプトを指定すると実行されます。指定しない場合、コンポーネントは `FINISHED` 状態になります。
このコンポーネントに依存するコンポーネントは、このライフサイクルステップが実行されたときに開始されます。依存コンポーネントが使用するサービスなどのバックグラウンドプロセスを実行するには、代わりに `startup` ライフサイクルステップを使用します。
`run` ライフサイクルによりコンポーネントをデプロイすると、そのライフサイクルスクリプトが実行された直後から、デプロイが完了したコアデバイスを報告できるようになります。その結果、`run` ライフサイクルスクリプトが実行後すぐに失敗した場合でも、そのデプロイを正常に完了することができます。デプロイステータスを、コンポーネントの開始スクリプトの結果に依存させたい場合は、代わりに `startup` ライフサイクルステップを使用します。
1 つの `startup` または `run` ライフサイクルのみを定義できます。
このオブジェクトまたは文字列には、次の情報が含まれます。
`Script`
実行するスクリプト。
`RequiresPrivilege`
(オプション) ルート権限でスクリプトを実行できます。このオプションを に設定すると`true`、 AWS IoT Greengrass Core ソフトウェアはこのコンポーネントを実行するように設定したシステムユーザーとしてではなく、このライフサイクルスクリプトをルートとして実行します。デフォルトは `false` です。
`Skipif`
(オプション) スクリプトを実行するかどうかを決定するためのチェック。実行可能ファイルがパス上にあるかどうか、あるいはファイルが存在するかどうかを確認するように定義できます。出力が True の場合、 AWS IoT Greengrass Core ソフトウェアはこのステップをスキップします。次のいずれかの値を選択します。
+ `onpath runnable` - システムパス上に runnable があるかどうかをチェックします。例えば、Python 3 が利用可能な場合には、**onpath python3** を使用してこのライフサイクルステップをスキップします。
+ `exists file` - ファイルが存在するかどうかをチェックします。たとえば、`/tmp/my-configuration.db` が存在する場合には、**exists /tmp/my-configuration.db** を使用してこのライフサイクルステップをスキップします。
`Timeout`
(オプション) AWS IoT Greengrass Core ソフトウェアがプロセスを終了するまでにスクリプトが実行できる秒単位の最大時間。
デフォルトでは、このライフサイクルステップはタイムアウトしません。このタイムアウトを省略すると、`run` スクリプトが終了するまで実行されます。
`Setenv`
(オプション) スクリプトに提供する環境変数のディクショナリ。これらの環境変数は、`Lifecycle.Setenv` で指定した変数を上書きします。
`startup`
(オプション) コンポーネントの開始時に実行するバックグラウンドプロセスを定義するオブジェクトまたは文字列。
依存関係のあるコンポーネントを起動する前に、正常に終了させる、あるいはコンポーネントのステータスを `RUNNING` に更新するコマンドを実行するには、`startup` を使用します。終了していないスクリプトをコンポーネントが開始した場合に、そのコンポーネントのステータスを `RUNNING` または `ERRORED` にセットするには、[UpdateState](ipc-component-lifecycle.md#ipc-operation-updatestate) IPC オペレーションを使用します。例えば、`/etc/init.d/mysqld start` で MySQL プロセスを開始する `startup` ステップを定義することができます。
このライフサイクルステップが実行されると、コンポーネントは `STARTING` 状態に入ります。`startup` スクリプトが成功コードで終了すると、コンポーネントは `RUNNING` 状態に入ります。その後、依存コンポーネントを開始することができます。
`startup` ライフサイクルによりコンポーネントをデプロイすると、そのライフサイクルスクリプトが終了したか、もしくは状態を報告した後に、コアデバイスがデプロイの完了を報告できるようになります。言い換えると、すべてのコンポーネントの起動スクリプトが終了したか、あるいは状態を報告するまで、デプロイのステータスは `IN_PROGRESS` のままです
1 つの `startup` または `run` ライフサイクルのみを定義できます。
このオブジェクトまたは文字列には、次の情報が含まれます。
`Script`
実行するスクリプト。
`RequiresPrivilege`
(オプション) ルート権限でスクリプトを実行できます。このオプションを に設定すると`true`、 AWS IoT Greengrass Core ソフトウェアはこのコンポーネントを実行するように設定したシステムユーザーとしてではなく、このライフサイクルスクリプトをルートとして実行します。デフォルトは `false` です。
`Skipif`
(オプション) スクリプトを実行するかどうかを決定するためのチェック。実行可能ファイルがパス上にあるかどうか、あるいはファイルが存在するかどうかを確認するように定義できます。出力が True の場合、 AWS IoT Greengrass Core ソフトウェアはこのステップをスキップします。次のいずれかの値を選択します。
+ `onpath runnable` - システムパス上に runnable があるかどうかをチェックします。例えば、Python 3 が利用可能な場合には、**onpath python3** を使用してこのライフサイクルステップをスキップします。
+ `exists file` - ファイルが存在するかどうかをチェックします。たとえば、`/tmp/my-configuration.db` が存在する場合には、**exists /tmp/my-configuration.db** を使用してこのライフサイクルステップをスキップします。
`Timeout`
(オプション) AWS IoT Greengrass Core ソフトウェアがプロセスを終了する前に、スクリプトが実行できる最大時間 (秒単位)。
デフォルト: 120 秒
`Setenv`
(オプション) スクリプトに提供する環境変数のディクショナリ。これらの環境変数は、`Lifecycle.Setenv` で指定した変数を上書きします。
`shutdown`
(オプション) コンポーネントのシャットダウン時に実行するスクリプトを定義するオブジェクトまたは文字列。シャットダウンライフサイクルを使用して、コンポーネントが `STOPPING` 状態にあるときに実行するコードを実行します。シャットダウンライフサイクルは、`startup` または `run` スクリプトによって開始されたプロセスを停止するために使用できます。
`startup` でバックグラウンドプロセスを開始した場合は、コンポーネントがシャットダウンするときには `shutdown` ステップを使用してそのプロセスを停止します。例えば、`/etc/init.d/mysqld stop` で MySQL プロセスを停止する `shutdown` ステップを定義することができます。
`shutdown` スクリプトは、コンポーネントが `STOPPING` 状態になった後に実行されます。スクリプトが正常に完了すると、コンポーネントは `FINISHED` 状態になります。
このオブジェクトまたは文字列には、次の情報が含まれます。
`Script`
実行するスクリプト。
`RequiresPrivilege`
(オプション) ルート権限でスクリプトを実行できます。このオプションを に設定すると`true`、 AWS IoT Greengrass Core ソフトウェアはこのコンポーネントを実行するように設定したシステムユーザーとしてではなく、このライフサイクルスクリプトをルートとして実行します。デフォルトは `false` です。
`Skipif`
(オプション) スクリプトを実行するかどうかを決定するためのチェック。実行可能ファイルがパス上にあるかどうか、あるいはファイルが存在するかどうかを確認するように定義できます。出力が True の場合、 AWS IoT Greengrass Core ソフトウェアはこのステップをスキップします。次のいずれかの値を選択します。
+ `onpath runnable` - システムパス上に runnable があるかどうかをチェックします。例えば、Python 3 が利用可能な場合には、**onpath python3** を使用してこのライフサイクルステップをスキップします。
+ `exists file` - ファイルが存在するかどうかをチェックします。たとえば、`/tmp/my-configuration.db` が存在する場合には、**exists /tmp/my-configuration.db** を使用してこのライフサイクルステップをスキップします。
`Timeout`
(オプション) AWS IoT Greengrass Core ソフトウェアがプロセスを終了するまでにスクリプトが実行できる秒単位の最大時間。
デフォルト: 15 秒。
`Setenv`
(オプション) スクリプトに提供する環境変数のディクショナリ。これらの環境変数は、`Lifecycle.Setenv` で指定した変数を上書きします。
`recover`
(オプション) コンポーネントにエラーが発生したときに実行するスクリプトを定義するオブジェクトまたは文字列。
この手順は、コンポーネントが `ERRORED` 状態になったときに実行されます。コンポーネントが正常に回復しないで 3 回 `ERRORED` になると、コンポーネントは `BROKEN` 状態に変わります。`BROKEN` コンポーネントを修復するには、もう一度デプロイする必要があります。
このオブジェクトまたは文字列には、次の情報が含まれます。
`Script`
実行するスクリプト。
`RequiresPrivilege`
(オプション) ルート権限でスクリプトを実行できます。このオプションを に設定すると`true`、 AWS IoT Greengrass Core ソフトウェアはこのコンポーネントを実行するように設定したシステムユーザーとしてではなく、このライフサイクルスクリプトをルートとして実行します。デフォルトは `false` です。
`Skipif`
(オプション) スクリプトを実行するかどうかを決定するためのチェック。実行可能ファイルがパス上にあるかどうか、あるいはファイルが存在するかどうかを確認するように定義できます。出力が True の場合、 AWS IoT Greengrass Core ソフトウェアはこのステップをスキップします。次のいずれかの値を選択します。
+ `onpath runnable` - システムパス上に runnable があるかどうかをチェックします。例えば、Python 3 が利用可能な場合には、**onpath python3** を使用してこのライフサイクルステップをスキップします。
+ `exists file` - ファイルが存在するかどうかをチェックします。たとえば、`/tmp/my-configuration.db` が存在する場合には、**exists /tmp/my-configuration.db** を使用してこのライフサイクルステップをスキップします。
`Timeout`
(オプション) AWS IoT Greengrass Core ソフトウェアがプロセスを終了するまでにスクリプトが実行できる秒単位の最大時間。
デフォルト: 60 秒
`Setenv`
(オプション) スクリプトに提供する環境変数のディクショナリ。これらの環境変数は、`Lifecycle.Setenv` で指定した変数を上書きします。
`bootstrap`
(オプション) AWS IoT Greengrass Core ソフトウェアまたはコアデバイスの再起動が必要となるスクリプトを定義するオブジェクトまたは文字列。これにより、オペレーティングシステムの更新やランタイムの更新などをインストールした後に再起動するコンポーネントを開発することができます。
AWS IoT Greengrass Core ソフトウェアまたはデバイスの再起動を必要としない更新プログラムまたは依存関係をインストールするには、[インストールライフサイクル](#install-lifecycle-definition)を使用します。
Core AWS IoT Greengrass ソフトウェアがコンポーネントをデプロイする場合、このライフサイクルステップはインストールライフサイクルステップの前に実行されます。
+ コンポーネントがコアデバイスに初めてデプロイされる場合。
+ コンポーネントのバージョンが変更される場合。
+ コンポーネント設定が更新されたことで、ブートストラップスクリプトが変更される場合。
AWS IoT Greengrass Core ソフトウェアがデプロイにブートストラップステップがあるすべてのコンポーネントのブートストラップステップを完了すると、ソフトウェアが再起動します。
Core ソフトウェアまたは AWS IoT Greengrass コアデバイスを再起動するには、 AWS IoT Greengrass Core ソフトウェアをシステムサービスとして設定する必要があります。 AWS IoT Greengrass Core ソフトウェアをシステムサービスとして設定しない場合、ソフトウェアは再起動しません。詳細については、「[Greengrass nucleus をシステムサービスとして設定する](configure-greengrass-core-v2.md#configure-system-service)」を参照してください。
このオブジェクトまたは文字列には、次の情報が含まれます。
`BootstrapOnRollback`
この機能を有効にすると、`BootstrapOnRollback` は、失敗したターゲットデプロイの一部としてブートストラップライフサイクルステップを完了または実行しようとしたコンポーネントに対してのみ実行されます。この機能は、Greengrass nucleus バージョン 2.12.0 以降で使用できます。
(オプション) ロールバックデプロイの一部としてブートストラップライフサイクルステップを実行できます。このオプションを `true` に設定すると、ロールバックデプロイ内で定義されたブートストラップライフサイクルステップが実行されます。デプロイが失敗すると、ロールバックデプロイ中にコンポーネントのブートストラップライフサイクルの以前のバージョンが再実行されます。
デフォルトは `false` です。
`Script`
実行するスクリプト。このスクリプトの終了コードは、再起動の指示を定義しています。次の終了コードを使用します。
+ `0` – AWS IoT Greengrass Core ソフトウェアまたはコアデバイスを再起動しないでください。 AWS IoT Greengrass Core ソフトウェアは、すべてのコンポーネントのブートストラップ後も再起動します。
+ `100` – AWS IoT Greengrass Core ソフトウェアの再起動をリクエストします。
+ `101` - コアデバイスの再起動をリクエストします。
終了コード 100～199 は特別動作向けに予約済みです。その他の終了コードは、スクリプトエラーを表します。
`RequiresPrivilege`
(オプション) ルート権限でスクリプトを実行できます。このオプションを に設定すると`true`、 AWS IoT Greengrass Core ソフトウェアはこのコンポーネントを実行するように設定したシステムユーザーとしてではなく、このライフサイクルスクリプトをルートとして実行します。デフォルトは `false` です。
`Timeout`
(オプション) AWS IoT Greengrass Core ソフトウェアがプロセスを終了する前に、スクリプトが実行できる最大時間 (秒単位)。
デフォルト: 120 秒
`Setenv`
(オプション) スクリプトに提供する環境変数のディクショナリ。これらの環境変数は、`Lifecycle.Setenv` で指定した変数を上書きします。
`Selections`
(オプション) このマニフェストに対して実行する[グローバルライフサイクル](#global-lifecycle-definition)のセクションを指定する選択キーのリスト。グローバルライフサイクルでは、任意のレベルで選択キーを使用してライフサイクルステップを定義し、ライフサイクルのサブセクションを選択することができます その後、コアデバイスは、このマニフェストの選択キーと一致するセクションを使用します。詳細については、「[グローバルライフサイクルの例](#global-lifecycle-definition)」を参照してください。
コアデバイスは、このマニフェストがライフサイクルを指定していない場合にのみ、グローバルライフサイクルを使用します。
`all` 選択キーを指定して、選択キーを持たないグローバルライフサイクルのセクションを実行することができます。
`Artifacts`
(オプション) このマニフェストが定義するプラットフォーム上のコンポーネントのバイナリアーティファクトを定義するオブジェクトのリスト。例えば、コードまたはイメージをアーティファクトとして定義できます。
コンポーネントがデプロイされると、 AWS IoT Greengrass Core ソフトウェアはアーティファクトをコアデバイスのフォルダにダウンロードします。アーティファクトは、ソフトウェアがダウンロードした後に抽出するアーカイブファイルとして定義することもできます。
[レシピ変数](#recipe-variables)を使用すれば、コアデバイス上のアーティファクトがインストールされているフォルダへのパスを取得することができます。
+ 通常のファイル - [artifacts:path レシピ変数](#component-recipe-artifacts-path)を使用して、アーティファクトが含まれるフォルダへのパスを取得します。例えば、レシピで `{artifacts:path}/my_script.py` を指定すれば、URI `s3://amzn-s3-demo-bucket/path/to/my_script.py` を持つアーティファクトへのパスを取得できます。
+ 抽出されたアーカイブ - [artifacts:decompressedPath レシピ変数](#component-recipe-artifacts-decompressed-path)を使用して、抽出されたアーカイブアーティファクトが含まれるフォルダへのパスを取得します。 AWS IoT Greengrass Core ソフトウェアは、各アーカイブをアーカイブと同じ名前のフォルダに抽出します。例えば、レシピで `{artifacts:decompressedPath}/my_archive/my_script.py` を指定すれば、URI `s3://amzn-s3-demo-bucket/path/to/my_archive.zip` を持つアーカイブアーティファクト内にある `my_script.py` へのパスを取得できます。
ローカルコアデバイス上でアーカイブアーティファクトを持つコンポーネントを開発する場合、そのアーティファクトの URI がない可能性があります。アーティファクトを抽出する `Unarchive` オプションを使用してコンポーネントをテストするには、ファイル名がアーカイブアーティファクトファイルの名前と一致する URI を指定します。アーカイブアーティファクトのアップロード先となる予定の URI を指定することも、新しいプレースホルダ URI を指定することもできます。例えば、ローカルデプロイ時に `my_archive.zip` アーティファクトを抽出する場合には、`s3://amzn-s3-demo-bucket/my_archive.zip` を指定できます。
各オブジェクトには、次の情報が含まれます:
`Uri`
S3 バケット内のアーティファクトの URI。 AWS IoT Greengrass Core ソフトウェアは、アーティファクトがすでにデバイスに存在する場合を除き、コンポーネントのインストール時にこの URI からアーティファクトを取得します。各アーティファクトには、各マニフェスト内に一意のファイル名がある必要があります。
`Unarchive`
(オプション) 解凍するアーカイブのタイプ。次のオプションから選択します。
+ `NONE` - ファイルは解凍するアーカイブではありません。 AWS IoT Greengrass Core ソフトウェアによって、コアデバイス上のフォルダにアーティファクトがインストールされます。[artifacts:path レシピ変数](#component-recipe-artifacts-path)を使用して、このフォルダへのパスを取得することができます。
+ `ZIP` - ファイルは ZIP アーカイブです。 AWS IoT Greengrass Core ソフトウェアは、アーカイブと同じ名前のフォルダにアーカイブを抽出します。[artifacts:decompressedPath レシピ変数](#component-recipe-artifacts-decompressed-path)を使用して、このフォルダが含まれるフォルダへのパスを取得することができます。
デフォルトは `NONE` です。
`Permission`
(オプション) このアーティファクトファイルに設定するアクセス許可を定義するオブジェクト。読み取り許可と実行許可を設定できます。
AWS IoT Greengrass Core ソフトウェアではコンポーネントがアーティファクトフォルダ内のアーティファクトファイルを編集できないため、書き込みアクセス許可を設定することはできません。コンポーネント内のアーティファクトファイルを編集するには、別の場所にコピーするか、新しいアーティファクトファイルをパブリッシュしてデプロイします。
アーティファクトを解凍するアーカイブとして定義すると、 AWS IoT Greengrass Core ソフトウェアはアーカイブから解凍するファイルにこれらのアクセス許可を設定します。 AWS IoT Greengrass Core ソフトウェアは、フォルダのアクセス許可を `Read`および `ALL`の に設定します`Execute`。これにより、コンポーネントはフォルダ内の解凍されたファイルを表示できるようになります。アーカイブからの個々のファイルにアクセス許可を設定する場合は、[インストールライフサイクルスクリプト](#install-lifecycle-definition)でアクセス許可を設定することができます。
このオブジェクトには、次の情報が含まれます。
`Read`
(オプション) このアーティファクトファイルに設定する読み取りアクセス許可。このコンポーネントに依存するコンポーネントなどの他のコンポーネントがこのアーティファクトにアクセスできるようにするには、`ALL` を指定します。次のオプションから選択します。
+ `NONE` - ファイルは読み取れません。
+ `OWNER` - このコンポーネントを実行するように設定したシステムユーザーがファイルを読み取ることができます。
+ `ALL` - このファイルはすべてのユーザーが読み取ることができます。
デフォルトは `OWNER` です。
`Execute`
(オプション) このアーティファクトファイルに設定する実行アクセス許可。`Execute` アクセス許可は、`Read` アクセス許可を意味します。例えば、`Execute` に対して `ALL` を指定すると、すべてのユーザーがこのアーティファクトファイルを読み取り、実行できるようになります。
次のオプションから選択します。
+ `NONE` - ファイルは実行できません。
+ `OWNER` - このコンポーネントを実行するように設定したシステムユーザーがファイルを実行することができます。
+ `ALL` - このファイルはすべてのユーザーが実行することができます。
デフォルトは `NONE` です。
`Digest`
(読み取り専用) アーティファクトの暗号化ダイジェストハッシュ。コンポーネントを作成すると、 はハッシュアルゴリズム AWS IoT Greengrass を使用してアーティファクトファイルのハッシュを計算します。その後、コンポーネントをデプロイするときに、Greengrass nucleus がダウンロードされたアーティファクトのハッシュを計算し、このダイジェストとハッシュを比較することでインストール前にアーティファクトを検証します。ハッシュがダイジェストと一致しない場合、デプロイは失敗します。
このパラメータを設定すると、 はコンポーネントの作成時に設定した値を AWS IoT Greengrass 置き換えます。
`Algorithm`
(読み取り専用) アーティファクトのダイジェストハッシュを計算するために が AWS IoT Greengrass 使用するハッシュアルゴリズム。
このパラメータを設定すると、 はコンポーネントの作成時に設定した値を AWS IoT Greengrass 置き換えます。
`Lifecycle`
コンポーネントをインストールして実行する方法を定義するオブジェクト。コアデバイスは、使用する[マニフェスト](#manifest-definition)でライフサイクルが指定されていない場合にのみ、グローバルライフサイクルを使用します。
このライフサイクルはマニフェスト外で定義します。マニフェストと一致するプラットフォームに適用される[マニフェストのライフサイクル](#manifest-lifecycle-definition)を定義することもできます。
グローバルライフサイクルでは、各マニフェストで指定した特定の[選択キー](#manifest-selections-definition)に対して実行するライフサイクルを指定することができます。選択キーは、各マニフェストに対して実行するグローバルライフサイクルのセクションを識別する文字列です。
選択キーがないセクションのデフォルトは、`all` 選択キーです。つまり、マニフェストで `all` 選択キーを指定することで、選択キーがないグローバルライフサイクルのセクションを実行することができることになります。グローバルライフサイクルで `all` 選択キーを指定する必要はありません
マニフェストでライフサイクルまたは選択キーが定義されていない場合、コアデバイスはデフォルトで `all` 選択を使用します。つまりこの場合、コアデバイスは、選択キーを使用しないグローバルライフサイクルのセクションを使用することになります。
このオブジェクトには、[マニフェストのライフサイクル](#manifest-lifecycle-definition)と同じ情報が含まれていますが、任意のレベルで選択キーを指定することで、ライフサイクルのサブセクションを選択することができます。
選択キーとライフサイクルキーが競合することがないように、各選択キーには小文字のみを使用することを推奨します。ライフサイクルキーは大文字で始まります。
**Example トップレベルの選択キーを使用したグローバルライフサイクルの例**
```
Lifecycle:
key1:
install:
SkipIf: either onpath executable or exists file
Script: command1
key2:
install:
Script: command2
all:
install:
Script: command3
```
**Example 末尾レベルの選択キーを使用したグローバルライフサイクルの例**
```
Lifecycle:
install:
Script:
key1: command1
key2: command2
all: command3
```
**Example 複数のレベルの選択キーを使用したグローバルライフサイクルの例**
```
Lifecycle:
key1:
install:
SkipIf: either onpath executable or exists file
Script: command1
key2:
install:
Script: command2
all:
install:
Script:
key3: command3
key4: command4
all: command5
```
## レシピ変数
レシピ変数は、現在のコンポーネントと nucleus の情報を公開し、レシピで使用できるようにします。例えば、レシピ変数を使用して、ライフサイクルスクリプトで実行するアプリケーションにコンポーネント設定パラメータを渡すことができます。
レシピ変数は、以下のコンポーネントレシピの各セクションで使用できます。
+ ライフサイクル定義。
+ コンポーネント構成定義 ([Greengrass nucleus](greengrass-nucleus-component.md) v2.6.0 以降を選択し、[interpolateComponentConfiguration](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration-interpolate-component-configuration) 設定オプションに `true` を設定している場合)。レシピ変数は、[コンポーネント設定の更新をデプロイ](update-component-configurations.md#merge-configuration-update-recipe-variables)する際にも、使用することが可能です。
レシピ変数は `{recipe_variable}` 構文を使用します。中括弧はレシピ変数を示しています。
AWS IoT Greengrass では、次のレシピ変数がサポートされています。
`component_dependency_name:configuration:json_pointer`
このレシピが定義するコンポーネント、またはこのコンポーネントが依存するコンポーネントの設定パラメータの値。
この変数を使用して、コンポーネントのライフサイクルで実行するスクリプトにパラメータを提供することができます。
AWS IoT Greengrass は、コンポーネントライフサイクル定義でのみこのレシピ変数をサポートします。
このレシピ変数には、次の入力があります。
+ `component_dependency_name` - (オプション) クエリを実行するコンポーネント依存関係の名前。このレシピが定義するコンポーネントを照会する場合は、このセグメントを省略します。直接的な依存関係のみを指定できます。
+ `json_pointer` - 評価する設定値への JSON ポインタ。JSON ポインタはフォワードスラッシュ (`/`) で始まります。ネストされたコンポーネント設定の値を識別するには、フォワードスラッシュ (`/`) を使用して、設定の各レベルのキーを区切ります。数字をキーとして使用して、リスト内のインデックスを指定できます。詳細については、「[JSON ポインタの仕様](https://tools.ietf.org/html/rfc6901)」を参照してください。
AWS IoT Greengrass Core は YAML 形式のレシピに JSON ポインタを使用します。
JSON ポインタは次のノードタイプを参照できます。
+ 値 node. AWS IoT Greengrass Core は、レシピ変数を値の文字列表現に置き換えます。Null 値は文字列の `null` に置き換えられます。
+ オブジェクト node. AWS IoT Greengrass Core は、レシピ変数をそのオブジェクトのシリアル化された JSON 文字列表現に置き換えます。
+ node. AWS IoT Greengrass Core はレシピ変数を置き換えません。
例えば、`{configuration:/Message}` レシピ変数は、コンポーネント設定の `Message` キーの値を取得します。`{com.example.MyComponentDependency:configuration:/server/port}` レシピ変数は、コンポーネント依存関係の `server` 設定オブジェクトにある `port` の値を取得します。
`component_dependency_name:artifacts:path`
このレシピが定義するコンポーネント、またはこのコンポーネントが依存するコンポーネントのアーティファクトのルートパス。
コンポーネントをインストールすると、 はコンポーネントのアーティファクトを、この変数が公開するフォルダ AWS IoT Greengrass にコピーします。この変数を使用して、コンポーネントのライフサイクルで実行するスクリプトの場所などを特定できます。
このパスのフォルダは読み取り専用です。アーティファクトファイルを変更するには、ファイルを現在の作業ディレクトリなどの別の場所にコピーします (`$PWD` または `.`)。その後、その場所でファイルを変更します。
コンポーネントの依存関係からアーティファクトを読み取るか実行するには、そのアーティファクトの `Read` または `Execute` のアクセス許可が `ALL` である必要があります。詳細については、コンポーネントレシピで定義した「[アーティファクトアクセス許可](#component-artifact-permission)」を参照してください。
このレシピ変数には、次の入力があります。
+ `component_dependency_name` - (オプション) クエリを実行するコンポーネント依存関係の名前。このレシピが定義するコンポーネントを照会する場合は、このセグメントを省略します。直接的な依存関係のみを指定できます。
`component_dependency_name:artifacts:decompressedPath`
このレシピが定義するコンポーネント、またはこのコンポーネントが依存するコンポーネントの解凍されたアーカイブアーティファクトのルートパス。
コンポーネントをインストールすると、 はコンポーネントのアーカイブアーティファクトを、この変数が公開するフォルダに AWS IoT Greengrass 解凍します。この変数を使用して、コンポーネントのライフサイクルで実行するスクリプトの場所などを特定できます。
各アーティファクトは、解凍されたパス内のフォルダに解凍されます。フォルダの名前はアーティファクトと同じ名前から拡張子を引いたものになります。例えば、`models.zip` という名前の ZIP アーティファクトは、`{artifacts:decompressedPath}/models` フォルダに解凍されます。
このパスのフォルダは読み取り専用です。アーティファクトファイルを変更するには、ファイルを現在の作業ディレクトリなどの別の場所にコピーします (`$PWD` または `.`)。その後、その場所でファイルを変更します。
コンポーネントの依存関係からアーティファクトを読み取るか実行するには、そのアーティファクトの `Read` または `Execute` のアクセス許可が `ALL` である必要があります。詳細については、コンポーネントレシピで定義した「[アーティファクトアクセス許可](#component-artifact-permission)」を参照してください。
このレシピ変数には、次の入力があります。
+ `component_dependency_name` - (オプション) クエリを実行するコンポーネント依存関係の名前。このレシピが定義するコンポーネントを照会する場合は、このセグメントを省略します。直接的な依存関係のみを指定できます。
`component_dependency_name:work:path`
この機能は、[Greengrass nucleus コンポーネント](greengrass-nucleus-component.md)の v2.0.4 以降に利用できます。
このレシピが定義するコンポーネント、またはこのコンポーネントが依存するコンポーネントのワークパス。このレシピ変数の値は、コンポーネントのコンテキストから実行されたときの `$PWD` 環境変数と [pwd](https://en.wikipedia.org/wiki/Pwd) コマンドの出力と同じです。
このレシピ変数を使用して、コンポーネントと依存関係間でファイルを共有できます。
このパスのフォルダは、このレシピが定義するコンポーネントと、同じユーザーおよびグループとして実行される他のコンポーネントが、読み取り書き込むことができます。
このレシピ変数には、次の入力があります。
+ `component_dependency_name` - (オプション) クエリを実行するコンポーネント依存関係の名前。このレシピが定義するコンポーネントを照会する場合は、このセグメントを省略します。直接的な依存関係のみを指定できます。
`kernel:rootPath`
AWS IoT Greengrass Core ルートパス。
`iot:thingName`
この機能は、[Greengrass nucleus コンポーネント](greengrass-nucleus-component.md)の v2.3.0 以降に利用できます。
コアデバイスの AWS IoT モノの名前。
## レシピの例
コンポーネントのレシピを作成する際には、次のレシピ例を参照してください。
AWS IoT Greengrass は、Greengrass ソフトウェアカタログと呼ばれる Greengrass コンポーネントのインデックスをキュレートします。このカタログは、Greengrass コミュニティによって開発された Greengrass コンポーネントを追跡します。このカタログから、コンポーネントをダウンロード、変更、デプロイして Greengrass アプリケーションを作成できます。詳細については、「[コミュニティコンポーネント](greengrass-software-catalog.md)」を参照してください。
**Topics**
+ [Hello World コンポーネントレシピ](#recipe-example-hello-world)
+ [Python ランタイムコンポーネントの例](#recipe-example-python-runtime)
+ [複数のフィールドを指定するコンポーネントレシピ](#recipe-example-all-fields)
### Hello World コンポーネントレシピ
次のレシピは、Python スクリプトを実行する Hello World コンポーネントについて説明しています。このコンポーネントはすべてのプラットフォームをサポートしており、 AWS IoT Greengrass が Python スクリプトに引数としてわたす `Message` パラメータを受け入れます。これは、[入門チュートリアル](getting-started.md)の Hello World コンポーネントのためのレシピです。
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.HelloWorld",
"ComponentVersion": "1.0.0",
"ComponentDescription": "My first AWS IoT Greengrass component.",
"ComponentPublisher": "Amazon",
"ComponentConfiguration": {
"DefaultConfiguration": {
"Message": "world"
}
},
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"run": "python3 -u {artifacts:path}/hello_world.py {configuration:/Message}"
}
},
{
"Platform": {
"os": "windows"
},
"Lifecycle": {
"run": "py -3 -u {artifacts:path}/hello_world.py {configuration:/Message}"
}
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.HelloWorld
ComponentVersion: '1.0.0'
ComponentDescription: My first AWS IoT Greengrass component.
ComponentPublisher: Amazon
ComponentConfiguration:
DefaultConfiguration:
Message: world
Manifests:
- Platform:
os: linux
Lifecycle:
run: |
python3 -u {artifacts:path}/hello_world.py "{configuration:/Message}"
- Platform:
os: windows
Lifecycle:
run: |
py -3 -u {artifacts:path}/hello_world.py "{configuration:/Message}"
```
------
### Python ランタイムコンポーネントの例
次のレシピは、Python をインストールするコンポーネントについて説明しています。このコンポーネントは 64 ビット Linux デバイスをサポートします。
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.PythonRuntime",
"ComponentDescription": "Installs Python 3.7",
"ComponentPublisher": "Amazon",
"ComponentVersion": "3.7.0",
"Manifests": [
{
"Platform": {
"os": "linux",
"architecture": "amd64"
},
"Lifecycle": {
"install": "apt-get update\napt-get install python3.7"
}
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.PythonRuntime
ComponentDescription: Installs Python 3.7
ComponentPublisher: Amazon
ComponentVersion: '3.7.0'
Manifests:
- Platform:
os: linux
architecture: amd64
Lifecycle:
install: |
apt-get update
apt-get install python3.7
```
------
### 複数のフィールドを指定するコンポーネントレシピ
次のコンポーネントレシピでは、複数のレシピフィールドを使用します。
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.FooService",
"ComponentDescription": "Complete recipe for AWS IoT Greengrass components",
"ComponentPublisher": "Amazon",
"ComponentVersion": "1.0.0",
"ComponentConfiguration": {
"DefaultConfiguration": {
"TestParam": "TestValue"
}
},
"ComponentDependencies": {
"BarService": {
"VersionRequirement": "^1.1.0",
"DependencyType": "SOFT"
},
"BazService": {
"VersionRequirement": "^2.0.0"
}
},
"Manifests": [
{
"Platform": {
"os": "linux",
"architecture": "amd64"
},
"Lifecycle": {
"install": {
"Skipif": "onpath git",
"Script": "sudo apt-get install git"
},
"Setenv": {
"environment_variable1": "variable_value1",
"environment_variable2": "variable_value2"
}
},
"Artifacts": [
{
"Uri": "s3://amzn-s3-demo-bucket/hello_world.zip",
"Unarchive": "ZIP"
},
{
"Uri": "s3://amzn-s3-demo-bucket/hello_world_linux.py"
}
]
},
{
"Lifecycle": {
"install": {
"Skipif": "onpath git",
"Script": "sudo apt-get install git",
"RequiresPrivilege": "true"
}
},
"Artifacts": [
{
"Uri": "s3://amzn-s3-demo-bucket/hello_world.py"
}
]
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.FooService
ComponentDescription: Complete recipe for AWS IoT Greengrass components
ComponentPublisher: Amazon
ComponentVersion: 1.0.0
ComponentConfiguration:
DefaultConfiguration:
TestParam: TestValue
ComponentDependencies:
BarService:
VersionRequirement: ^1.1.0
DependencyType: SOFT
BazService:
VersionRequirement: ^2.0.0
Manifests:
- Platform:
os: linux
architecture: amd64
Lifecycle:
install:
SkipIf: onpath git
Script: sudo apt-get install git
SetEnv:
environment_variable1: variable_value1
environment_variable2: variable_value2
Artifacts:
- Uri: 's3://amzn-s3-demo-bucket/hello_world.zip'
Unarchive: ZIP
- Uri: 's3://amzn-s3-demo-bucket/hello_world_linux.py'
- Lifecycle:
install:
SkipIf: onpath git
Script: sudo apt-get install git
RequiresPrivilege: 'true'
Artifacts:
- Uri: 's3://amzn-s3-demo-bucket/hello_world.py'
```
------
# コンポーネントの環境変数リファレンス
AWS IoT Greengrass Core ソフトウェアは、コンポーネントのライフサイクルスクリプトを実行するときに環境変数を設定します。これらの環境変数をコンポーネントで取得して、モノの名前 AWS リージョン、および Greengrass nucleus バージョンを取得できます。また、このソフトウェアは、コンポーネントが[プロセス間通信 SDK](interprocess-communication.md) を使用し、[AWS サービスとやり取りする](interact-with-aws-services.md)ために必要な環境変数も設定します。
コンポーネントのライフサイクルスクリプトにカスタム環境変数を設定することもできます。詳細については「[Setenv](component-recipe-reference.md#lifecycle-setenv-definition)」を参照してください。
AWS IoT Greengrass Core ソフトウェアは、次の環境変数を設定します。
`AWS_IOT_THING_NAME`
この Greengrass コアデバイスを表す AWS IoT モノの名前。
`AWS_REGION`
この Greengrass コアデバイスが動作 AWS リージョン する 。
AWS SDKs環境変数を使用して、使用するデフォルトのリージョンを識別します。この変数は `AWS_DEFAULT_REGION` と同等です。
`AWS_DEFAULT_REGION`
この Greengrass コアデバイスが動作 AWS リージョン する 。
AWS CLI は、この環境変数を使用して、使用するデフォルトのリージョンを識別します。この変数は `AWS_REGION` と同等です。
`GGC_VERSION`
この Greengrass コアデバイスで実行される [Greengrass nucleus コンポーネント](greengrass-nucleus-component.md)のバージョン。
`GG_ROOT_CA_PATH`
この機能は、[Greengrass nucleus コンポーネント](greengrass-nucleus-component.md)の v2.5.5 以降に利用できます。
Greengrass nucleus が使用するルート認証局 (CA) 証明書へのパス。
`AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT`
Core ソフトウェアとの通信にコンポーネントが使用する IPC AWS IoT Greengrass ソケットへのパス。詳細については、「[を使用して AWS IoT Device SDK Greengrass nucleus、その他のコンポーネント、および と通信します。 AWS IoT CoreGreengrass nucleus、その他のコンポーネント、および と通信する AWS IoT Core](interprocess-communication.md)」を参照してください。
`SVCUID`
コンポーネントが IPC ソケットに接続し、 AWS IoT Greengrass Core ソフトウェアと通信するために使用するシークレットトークン。詳細については、「[を使用して AWS IoT Device SDK Greengrass nucleus、その他のコンポーネント、および と通信します。 AWS IoT CoreGreengrass nucleus、その他のコンポーネント、および と通信する AWS IoT Core](interprocess-communication.md)」を参照してください。
`AWS_CONTAINER_AUTHORIZATION_TOKEN`
コンポーネントが、[トークン交換サービスコンポーネント](token-exchange-service-component.md)から認証情報を取得するために使用するシークレットトークン。
`AWS_CONTAINER_CREDENTIALS_FULL_URI`
コンポーネントが、[トークン交換サービスコンポーネント](token-exchange-service-component.md)から認証情報を取得するためにリクエストする URI。