翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。
# AWS IoT Greengrass コアデバイスのセットアップ
Core AWS IoT Greengrass ソフトウェアをインストール、設定、実行するには、このセクションのタスクを完了します。
**注記**
このセクションでは、 AWS IoT Greengrass Core ソフトウェアの高度なインストールと設定について説明します。これらの手順は nucleus lite には適用されません。 を初めて使用する場合は AWS IoT Greengrass V2、まず[入門チュートリアル](getting-started.md)を完了してコアデバイスをセットアップし、 の機能を調べることをお勧めします AWS IoT Greengrass。
**Topics**
+ [サポートされているプラットフォーム](#supported-platforms)
+ [デバイスの要件](#device-requirements)
+ [Lambda 関数の要件](#greengrass-v2-lambda-requirements)
+ [のセットアップ AWS アカウント](#set-up-aws-account)
+ [AWS IoT Greengrass Core ソフトウェアをインストールします。](install-greengrass-core-v2.md)
+ [AWS IoT Greengrass Core ソフトウェアを実行する](run-greengrass-core-v2.md)
+ [Docker コンテナで AWS IoT Greengrass Core ソフトウェアを実行する](run-greengrass-docker.md)
+ [AWS IoT Greengrass Core ソフトウェアを設定する](configure-greengrass-core-v2.md)
+ [AWS IoT Greengrass Core ソフトウェア (OTA) の更新](update-greengrass-core-v2.md)
+ [AWS IoT Greengrass Core ソフトウェアをアンインストールする](uninstall-greengrass-core-v2.md)
## サポートされているプラットフォーム
+ [Greengrass nucleus がサポートするプラットフォーム](https://docs.aws.amazon.com/greengrass/v2/developerguide/greengrass-nucleus-component.html)
+ [Greengrass nucleus lite がサポートするプラットフォーム](https://docs.aws.amazon.com/greengrass/v2/developerguide/greengrass-nucleus-lite-component.html)
## デバイスの要件
+ [Greengrass nucleus のデバイス要件](https://docs.aws.amazon.com/greengrass/v2/developerguide/greengrass-nucleus-component.html)
+ [Greengrass nucleus lite のデバイス要件](https://docs.aws.amazon.com/greengrass/v2/developerguide/greengrass-nucleus-lite-component.html)
## Lambda 関数の要件
**重要**
Greengrass Lambda 関数は現在、Greengrass nucleus lite ではサポートされていません。
Lambda 関数を実行するには、デバイスが次の要件を満たしている必要があります。
+ Linux ベースのオペレーティングシステム。
+ デバイスには `mkfifo` シェルコマンドが必要です。
+ デバイスでは、Lambda 関数に必要なプログラミング言語ライブラリを実行する必要があります。必須ライブラリを、デバイスにインストールし、`PATH` 環境変数に追加する必要があります。Greengrass は、Lambda でサポートされるすべてのバージョンの Python、Node.js、Java ランタイムをサポートします。Greengrass は、非推奨となった Lambda ランタイムバージョンに追加の制限を適用しません。Lambda ランタイム AWS IoT Greengrass のサポートの詳細については、「」を参照してください[AWS Lambda 関数を実行する](run-lambda-functions.md)。
+ コンテナ化された Lambda 関数を実行するには、デバイスが次の要件を満たしている必要があります。
+ Linux kernel バージョン 4.4 以降。
+ カーネルは [cgroups](https://en.wikipedia.org/wiki/Cgroups) v1 をサポートしている必要があり、次の cgroups を有効にしてマウントする必要があります。
+ コンテナ化された Lambda 関数の*メモリ*制限を設定する AWS IoT Greengrass のメモリ cgroup。
+ コンテナ化された Lambda 関数がシステムデバイスまたはボリュームにアクセスするための*デバイス* cgroup。
AWS IoT Greengrass Core ソフトウェアは cgroups v2 をサポートしていません。
この要件を満たすには、次の Linux カーネルパラメータを使用してデバイスを起動します。
```
cgroup_enable=memory cgroup_memory=1 systemd.unified_cgroup_hierarchy=0
```
**ヒント**
Raspberry Pi で、`/boot/cmdline.txt` ファイルを編集して、デバイスのカーネルパラメータを設定します。
+ デバイスで次の Linux カーネル設定を有効にする必要があります。
+ 名前空間:
+ `CONFIG_IPC_NS`
+ `CONFIG_UTS_NS`
+ `CONFIG_USER_NS`
+ `CONFIG_PID_NS`
+ Cgroups:
+ `CONFIG_CGROUP_DEVICE`
+ `CONFIG_CGROUPS`
+ `CONFIG_MEMCG`
+ その他:
+ `CONFIG_POSIX_MQUEUE`
+ `CONFIG_OVERLAY_FS`
+ `CONFIG_HAVE_ARCH_SECCOMP_FILTER`
+ `CONFIG_SECCOMP_FILTER`
+ `CONFIG_KEYS`
+ `CONFIG_SECCOMP`
+ `CONFIG_SHMEM`
**ヒント**
Linux カーネルパラメータを検証して設定する方法については、Linux ディストリビューションのドキュメントを確認してください。 AWS IoT Device Tester の を使用して AWS IoT Greengrass 、デバイスがこれらの要件を満たしていることを確認することもできます。詳細については、「[AWS IoT Device Tester for AWS IoT Greengrass V2 を使用する](device-tester-for-greengrass-ug.md)」を参照してください。
## のセットアップ AWS アカウント
がない場合は AWS アカウント、次の手順を実行して作成します。
**にサインアップするには AWS アカウント**
1. [https://portal.aws.amazon.com/billing/signup](https://portal.aws.amazon.com/billing/signup) を開きます。
1. オンラインの手順に従います。
サインアップ手順の一環として、電話またはテキストメッセージを受け取り、電話キーパッドで検証コードを入力します。
にサインアップすると AWS アカウント、 *AWS アカウントのルートユーザー* が作成されます。ルートユーザーには、アカウントのすべての AWS のサービス とリソースへのアクセス権があります。セキュリティベストプラクティスとして、ユーザーに管理アクセス権を割り当て、[ルートユーザーアクセスが必要なタスク](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks)の実行にはルートユーザーのみを使用するようにしてください。
管理者ユーザーを作成するには、以下のいずれかのオプションを選択します。
****
| 管理者を管理する方法を 1 つ選択します | 目的 | 方法 | 以下の操作も可能 |
| --- | --- | --- | --- |
| IAM Identity Center 内 (推奨) | 短期の認証情報を使用して AWSにアクセスします。これはセキュリティのベストプラクティスと一致しています。ベストプラクティスの詳細については、「*IAM ユーザーガイド*」の「[IAM でのセキュリティのベストプラクティス](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#bp-users-federation-idp)」を参照してください。 | AWS IAM アイデンティティセンター ユーザーガイドの「[開始方法](https://docs.aws.amazon.com//singlesignon/latest/userguide/getting-started.html)」の手順に従います。 | AWS Command Line Interface ユーザーガイドの [を使用する AWS CLI ように を設定 AWS IAM アイデンティティセンター](https://docs.aws.amazon.com//cli/latest/userguide/cli-configure-sso.html)して、プログラムによるアクセスを設定します。 |
| IAM 内 (非推奨) | 長期認証情報を使用して AWSにアクセスする。 | IAM ユーザーガイドの「[緊急アクセス用の IAM ユーザーを作成する](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started-emergency-iam-user.html)」の手順に従います。 | IAM ユーザーガイドの「[IAM ユーザーのアクセスキーを管理する](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_credentials_access-keys.html)」の手順に従って、プログラムによるアクセスを設定します。 |
# AWS IoT Greengrass Core ソフトウェアをインストールします。
AWS IoT Greengrass は AWS をエッジデバイスに拡張します。これによりエッジデバイスは生成するデータに対してアクションを実行しながら、管理、分析、耐久性のあるストレージのために AWS クラウド を使用できます。AWS IoT Greengrass Core ソフトウェアをエッジデバイスにインストールして、AWS IoT Greengrass と AWS クラウド を統合します。
**重要**
AWS IoT Greengrass Core ソフトウェアをダウンロードしてインストールする前に、お使いのコアデバイスが AWS IoT Greengrass Core ソフトウェア v2.0 をインストールして実行するための[要件](greengrass-nucleus-component.md#greengrass-v2-requirements)を満たしていることを確認してください。
AWS IoT Greengrass Core ソフトウェアには、デバイスを Greengrass コアデバイスとして設定するインストーラが含まれています。インストーラを実行する際は、ルートフォルダや使用する AWS リージョン などのオプションを設定できます。必要な AWS IoT および IAM リソース作成をインストーラに作成させることも選択できます。また、ローカル開発ツールをデプロイして、カスタムコンポーネント開発に使用するデバイスを設定することもできます。
AWS IoT Greengrass Core ソフトウェアは、AWS クラウド への接続および操作を行うためには、以下の AWS IoT および IAM リソースを必要とします。
+ AWS IoT のモノ デバイスを AWS IoT モノとして登録するとき、そのデバイスはデジタル証明書を使用して AWS で認証できます。この証明書は、デバイスが AWS IoT と AWS IoT Greengrass と通信できるようにします。詳細については、「[AWS IoT Greengrassのデバイス認証と認可](device-auth.md)」を参照してください。
+ (オプション) AWS IoT モノグループ。モノグループを使用して Greengrass コアデバイスのフリートを管理します。ソフトウェアコンポーネントをデバイスにデプロイするとき、個々のデバイスまたはデバイスのグループのどちらにデプロイするのかを選択することができます。デバイスをモノグループに追加すると、そのモノグループのソフトウェアコンポーネントをデバイスにデプロイできます。詳細については、「[AWS IoT Greengrass コンポーネントをデバイスにデプロイする](manage-deployments.md)」を参照してください。
+ IAM ロール。Greengrass コアデバイスは、AWS IoT Core 認証情報プロバイダを使用して AWS サービスへの呼び出しを認可する際に、IAM ロールを使用します。このロールは、デバイスが AWS IoT とやり取りし、Amazon CloudWatch Logs にログを送信し、Amazon Simple Storage Service (Amazon S3) からカスタムコンポーネントのアーティファクトをダウンロードすることを可能にします。詳細については、「[コアデバイスが AWS サービスとやり取りできるように認可する](device-service-role.md)」を参照してください。
+ AWS IoT ロールエイリアス。Greengrass コアデバイスは、使用する IAM ロールの識別にロールエイリアスを使用します。ロールエイリアスを使用すると、IAM ロールを変更してもデバイス設定は同じ状態を保つことができます。詳細については、「AWS IoT Core デベロッパーガイド」の「[AWS サービスへの直接呼び出しを認証する](https://docs.aws.amazon.com/iot/latest/developerguide/authorizing-direct-aws.html)」を参照してください。
次のいずれかのオプションを選択して、デバイスに AWS IoT Greengrass Core ソフトウェアをインストールします。
+ **クイックインストール**
Greengrass コアデバイスをできるだけ少ないステップでセットアップするには、このオプションを選択します。必要な AWS IoT および IAM リソースはインストーラが作成します。このオプションでは、AWS アカウント でリソースを作成するために、インストーラに AWS 認証情報を提供する必要があります。
このオプションを使用して、ファイアウォールまたはネットワークプロキシの向こう側にインストールすることはできません。デバイスがファイアウォールまたはネットワークプロキシの向こう側にある場合は、[手動インストール](manual-installation.md)を検討してください。
詳細については、「[自動リソースプロビジョニングを使用して AWS IoT Greengrass Core ソフトウェアをインストールする](quick-installation.md)」を参照してください。
+ **手動インストール**
必要となる AWS リソースを手動で作成する場合、またはファイアウォールもしくはネットワークプロキシの向こう側にインストールを行う場合は、このオプションを選択します。手動でインストールすることで、インストーラに AWS アカウント でリソースを作成する権限を与える必要がなくなります。必要となる AWS IoT と IAM リソースはユーザーが作成するためです。また、ポート 443 で、またはネットワークプロキシ経由で接続するようにデバイスを設定することもできます。また、ハードウェアセキュリティモジュール (HSM)、トラステッドプラットフォームモジュール (TPM)、またはその他の暗号化要素にプライベートキーおよび証明書を保存して使用するように、AWS IoT Greengrass Core ソフトウェアを設定することもできます。
詳細については、「[手動リソースプロビジョニングを使用して AWS IoT Greengrass Core ソフトウェアをインストールする](manual-installation.md)」を参照してください。
+ **AWS IoT フリートプロビジョニングを使用したインストール**
AWS IoT フリートプロビジョニングテンプレートから必要な AWS リソースを作成するには、このオプションを選択します。このオプションは、フリート内で類似したデバイスを作成する場合や、車両やスマートホームデバイスなど、顧客が後でアクティブ化するデバイスを製造する場合に選択します。デバイスはクレーム証明書を使用して AWS リソースの認証とプロビジョニングを行います。これには、デバイスが通常のオペレーション用に AWS クラウド に接続するために使用する X.509 クライアント証明書などがあります。クレーム証明書は、製造時にデバイスのハードウェアに埋め込みまたはフラッシュできます。また同じクレーム証明書とキーを使用して、複数のデバイスをプロビジョニングできます。また、ポート 443 で、またはネットワークプロキシ経由で接続するようにデバイスを設定することもできます。
詳細については、「[AWS IoT フリートプロビジョニングを使用して AWS IoT Greengrass Core ソフトウェアをインストールする](fleet-provisioning.md)」を参照してください。
+ **カスタムプロビジョニングを使用したインストール**
必要な AWS リソースをプロビジョニングするカスタム Java アプリケーションを作成するには、このオプションを選択します。[独自の X.509 クライアント証明書を作成](https://docs.aws.amazon.com/iot/latest/developerguide/device-certs-your-own.html)する場合、またはプロビジョニングプロセスのより細かい制御が必要な場合は、このオプションを選択できます。AWS IoT Greengrass は、カスタムプロビジョニングアプリケーションと AWS IoT Greengrass Core ソフトウェアインストーラとの間の情報交換のために実装できるインターフェイスを提供します。
詳細については、「[カスタムリソースプロビジョニングを使用して AWS IoT Greengrass Core ソフトウェアをインストールする](custom-provisioning.md)」を参照してください。
AWS IoT Greengrass は、AWS IoT Greengrass Core ソフトウェアを実行するコンテナ化された環境も提供します。[Docker コンテナで AWS IoT Greengrass を実行](run-greengrass-docker.md)するには、Dockerfile を使用します。
**Topics**
+ [自動プロビジョニング使ってインストールする](quick-installation.md)
+ [手動プロビジョニングを使って をインストールする](manual-installation.md)
+ [フリートプロビジョニングを使って をインストールする](fleet-provisioning.md)
+ [カスタムプロビジョニングでインストールする](custom-provisioning.md)
+ [インストーラ引数](configure-installer.md)
# 自動リソースプロビジョニングを使用して AWS IoT Greengrass Core ソフトウェアをインストールする
AWS IoT Greengrass Core ソフトウェアには、デバイスを Greengrass コアデバイスとしてセットアップするインストーラが含まれています。デバイスをすばやくセットアップするために、インストーラはコアデバイスが動作するために必要な AWS IoT モノ、 AWS IoT モノのグループ、IAM ロール、および AWS IoT ロールエイリアスをプロビジョニングできます。インストーラは、ローカル開発ツールをコアデバイスにデプロイすることもできるため、デバイスを使用してカスタムソフトウェアコンポーネントを開発とテストできます。インストーラには、これらのリソースをプロビジョニングし、デプロイを作成するための AWS 認証情報が必要です。
デバイスに AWS 認証情報を提供できない場合は、コアデバイスが動作するために必要な AWS リソースをプロビジョニングできます。開発ツールをコアデバイスにデプロイして、開発デバイスとして使用することもできます。これにより、インストーラの実行時にデバイスに与える許可を減らすことができます。詳細については、「[手動リソースプロビジョニングを使用して AWS IoT Greengrass Core ソフトウェアをインストールする](manual-installation.md)」を参照してください。
**重要**
AWS IoT Greengrass Core ソフトウェアをダウンロードする前に、コアデバイスが AWS IoT Greengrass Core ソフトウェア v2.0 をインストールして実行する[要件を満た](greengrass-nucleus-component.md#greengrass-v2-requirements)していることを確認してください。
**Topics**
+ [デバイス環境をセットアップする](#set-up-device-environment)
+ [デバイスに AWS 認証情報を提供する](#provide-installer-aws-credentials)
+ [AWS IoT Greengrass Core ソフトウェアをダウンロードする](#download-greengrass-core-v2)
+ [AWS IoT Greengrass Core ソフトウェアのインストール](#run-greengrass-core-v2-installer)
## デバイス環境をセットアップする
このセクションのステップに従って、 AWS IoT Greengrass コアデバイスとして使用する Linux または Windows デバイスをセットアップします。
### Linux デバイスをセットアップする
**の Linux デバイスを設定するには AWS IoT Greengrass V2**
1. AWS IoT Greengrass Core ソフトウェアが実行する必要がある Java ランタイムをインストールします。[Amazon Corretto](https://aws.amazon.com/corretto/) または [OpenJDK](https://openjdk.java.net/) の長期サポートバージョンを使用することをお勧めします。バージョン 8 以降が必要です。次のコマンドは、デバイスに OpenJDK をインストールする方法を示しています。
+ Debian ベースまたは Ubuntu ベースのディストリビューションの場合:
```
sudo apt install default-jdk
```
+ Red Hat ベースのディストリビューションの場合:
```
sudo yum install java-11-openjdk-devel
```
+ 複数 Amazon Linux 2:
```
sudo amazon-linux-extras install java-openjdk11
```
+ 複数 Amazon Linux 2023:
```
sudo dnf install java-11-amazon-corretto -y
```
インストールが完了したら、次のコマンドを実行して Java が Linux デバイスで実行されていることを確認します。
```
java -version
```
このコマンドは、デバイス上で実行されている Java のバージョンを出力します。例えば、Debian ベースのディストリビューションでは、出力は次のサンプルのようになります。
```
openjdk version "11.0.9.1" 2020-11-04
OpenJDK Runtime Environment (build 11.0.9.1+1-post-Debian-1deb10u2)
OpenJDK 64-Bit Server VM (build 11.0.9.1+1-post-Debian-1deb10u2, mixed mode)
```
1. (オプション) デバイスにコンポーネントを実行するデフォルトのシステムユーザーおよびグループを作成します。`--component-default-user` インストーラ引数を使用して、インストール中に AWS IoT Greengrass Core ソフトウェアインストーラにこのユーザーとグループを作成させることもできます。詳細については、「[インストーラ引数](configure-installer.md)」を参照してください。
```
sudo useradd --system --create-home ggc_user
sudo groupadd --system ggc_group
```
1. AWS IoT Greengrass Core ソフトウェアを実行するユーザー (通常は `root`) に、任意のユーザーと任意のグループ`sudo`で を実行するアクセス許可があることを確認します。
1. `/etc/sudoers` ファイルを開くには、次のコマンドを実行します。
```
sudo visudo
```
1. ユーザーの権限が次の例のようになっていることを確認します。
```
root ALL=(ALL:ALL) ALL
```
1. (オプション) [コンテナ化された Lambda 関数を実行](run-lambda-functions.md)するには、[cgroups](https://en.wikipedia.org/wiki/Cgroups) v1 を有効にし、*メモリ*と*デバイス*の cgroups を有効にしてマウントする必要があります。コンテナ化された Lambda 関数を実行する予定がない場合、この手順を省略できます。
これらの cgroups オプションを有効にするには、次の Linux カーネルパラメータを使用してデバイスを起動します。
```
cgroup_enable=memory cgroup_memory=1 systemd.unified_cgroup_hierarchy=0
```
デバイスのカーネルパラメータを確認および設定するための情報については、オペレーティングシステムおよびブートローダーのドキュメントを参照してください。指示に従って、カーネルパラメータを永続的に設定します。
1. [デバイスの要件](greengrass-nucleus-component.md#greengrass-v2-requirements) にある要件リストで示されているように、その他の必要となる依存関係をすべてデバイスにインストールします。
### Windows デバイスをセットアップする
**注記**
この機能は、[Greengrass nucleus コンポーネント](greengrass-nucleus-component.md)の v2.5.0 以降に利用できます。
**の Windows デバイスを設定するには AWS IoT Greengrass V2**
1. AWS IoT Greengrass Core ソフトウェアが実行する必要がある Java ランタイムをインストールします。[Amazon Corretto](https://aws.amazon.com/corretto/) または [OpenJDK](https://openjdk.java.net/) の長期サポートバージョンを使用することをお勧めします。バージョン 8 以降が必要です。
1. [PATH](https://en.wikipedia.org/wiki/PATH_(variable)) システム変数で Java が使用可能か確認し、そうでない場合は追加します。LocalSystem アカウントは AWS IoT Greengrass Core ソフトウェアを実行するため、ユーザーの PATH ユーザー変数ではなく PATH システム変数に Java を追加する必要があります。以下の操作を実行します。
1. Windows キーを押してスタートメニューを開きます。
1. **environment variables** を入力して、スタートメニューからシステムオプションを検索します。
1. スタートメニューの検索結果から **[Edit the system environment variables]** (システム環境変数を編集) をクリックして、**[System properties]** (システムプロパティ) ウィンドウを開きます。
1. **[Environment variables...]** (環境変数...) を選択して、**[Environment Variables]** (環境可変) ウィンドウを開きます。
1. **[System variables]** (システム変数) で、**[Path]** (パス) 、**[Edit]** (編集) の順に選択します。**[Edit environment variable]** (環境変数の編集) ウィンドウでは、個別の行に各パスを表示できます。
1. Java インストールの `bin` フォルダへのパスが存在しているかを確認します。このパスは、次の例のように表示されます。
```
C:\\Program Files\\Amazon Corretto\\jdk11.0.13_8\\bin
```
1. **[Path]** (パス) で Java インストールの `bin` フォルダが で見つからない場合は、**[New]** (新規) を選択してこれを追加した上で、**[OK]** を選択します。
1. 管理者として Windows コマンドプロンプト `cmd.exe` を開きます。
1. Windows デバイスの LocalSystem アカウントにデフォルトユーザーを作成します。*パスワード*を安全なパスワードに置き換えます。
```
net user /add ggc_user password
```
**ヒント**
Windows の構成によっては、ユーザーのパスワードの期限切れが、将来の日付に設定されている場合があります。Greengrass アプリケーションの動作を継続させるためには、パスワードの有効期限を追跡し、その期限が切れる前に更新します。ユーザーのパスワードには、期限切れを起こさないような設定も可能です。
ユーザーとパスワードの有効期限を確認するには、次のコマンドを実行します。
```
net user ggc_user | findstr /C:expires
```
ユーザーのパスワードが期限切れにならないように設定するには、次のコマンドを実行します。
```
wmic UserAccount where "Name='ggc_user'" set PasswordExpires=False
```
[`wmic` コマンドが廃止されている](https://learn.microsoft.com/en-us/windows/win32/wmisdk/wmic) Windows 10 以降を使用している場合は、次の PowerShell コマンドを実行します。
```
Get-CimInstance -Query "SELECT * from Win32_UserAccount WHERE name = 'ggc_user'" | Set-CimInstance -Property @{PasswordExpires="False"}
```
1. [PsExec ユーティリティ](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec)を Microsoft からダウンロードしてデバイスにインストールします。
1. PsExec ユーティリティを使用して、デフォルトユーザーのユーザー名とパスワードを LocalSystem アカウントの認証情報マネージャーインスタンスに格納します。*パスワード*を以前に設定したユーザーのパスワードに置き換えます。
```
psexec -s cmd /c cmdkey /generic:ggc_user /user:ggc_user /pass:password
```
**PsExec License Agreement** が開いたら、**Accept** を選択し、ライセンスに同意してコマンドを実行します。
**注記**
Windows デバイスでは、LocalSystem アカウントによって Greengrass nucleus が実行され、PsExec ユーティリティを使用して LocalSystem アカウントにデフォルトのユーザー情報を保存する必要があります。認証情報マネージャーアプリケーションを使用すると、この情報は LocalSystem アカウントではなく、現在ログオンしているユーザーの Windows アカウントに保存されます。
## デバイスに AWS 認証情報を提供する
インストーラが必要な AWS リソースをプロビジョニングできるように、デバイスに AWS 認証情報を提供します。必要なアクセス許可の詳細については、「[インストーラがリソースをプロビジョニングするための最小限の IAM ポリシー](provision-minimal-iam-policy.md)」を参照してください。
**デバイスに AWS 認証情報を提供するには**
+ インストーラがコアデバイスの AWS IoT および IAM リソースをプロビジョニングできるように、デバイスに AWS 認証情報を提供します。セキュリティを強化するには、プロビジョニングに必要な最小限の許可のみを与える IAM ロールの一時的な認証情報を取得することをお勧めします。詳細については、「[インストーラがリソースをプロビジョニングするための最小限の IAM ポリシー](provision-minimal-iam-policy.md)」を参照してください。
**注記**
インストーラが認証情報を保存したり保管することはありません。
デバイスで、次のいずれかを実行して認証情報を取得し、 AWS IoT Greengrass Core ソフトウェアインストーラーで使用できるようにします。
+ (推奨) から一時的な認証情報を使用する AWS IAM アイデンティティセンター
1. 継承する IAM Identity Center から、アクセスキー ID、シークレットアクセスキー、セッショントークンを提供します。これらの方法の詳細については、IAM Identity Center ユーザーガイドの「[一時的な認証情報の取得と更新](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtogetcredentials.html#how-to-get-temp-credentials)」で「**認証情報の手動更新**」を参照してください。**
1. 次のコマンドを実行して、認証情報を AWS IoT Greengrass Core ソフトウェアに提供します。
------
#### [ Linux or Unix ]
```
export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
export AWS_SESSION_TOKEN=AQoDYXdzEJr1K...o5OytwEXAMPLE=
```
------
#### [ Windows Command Prompt (CMD) ]
```
set AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
set AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
set AWS_SESSION_TOKEN=AQoDYXdzEJr1K...o5OytwEXAMPLE=
```
------
#### [ PowerShell ]
```
$env:AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
$env:AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
$env:AWS_SESSION_TOKEN="AQoDYXdzEJr1K...o5OytwEXAMPLE="
```
------
+ IAM ロールから一時的なセキュリティ認証情報を使用します。
1. 継承する IAM ロールから、アクセスキー ID、シークレットアクセスキー、セッショントークンを提供します。これらの認証情報を取得する方法の詳細については、「*IAM ユーザーガイド*」の「[一時的なセキュリティ認証情報をリクエストする](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html)」を参照してください。
1. 次のコマンドを実行して、認証情報を AWS IoT Greengrass Core ソフトウェアに提供します。
------
#### [ Linux or Unix ]
```
export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
export AWS_SESSION_TOKEN=AQoDYXdzEJr1K...o5OytwEXAMPLE=
```
------
#### [ Windows Command Prompt (CMD) ]
```
set AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
set AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
set AWS_SESSION_TOKEN=AQoDYXdzEJr1K...o5OytwEXAMPLE=
```
------
#### [ PowerShell ]
```
$env:AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
$env:AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
$env:AWS_SESSION_TOKEN="AQoDYXdzEJr1K...o5OytwEXAMPLE="
```
------
+ IAM ユーザーからの長期的な認証情報を使用する:
1. IAM ユーザーのアクセスキー ID とシークレットアクセスキーを提供します。後で削除するプロビジョニング用の IAM ユーザーを作成できます。ユーザーに付与する IAM ポリシーについては、「[インストーラがリソースをプロビジョニングするための最小限の IAM ポリシー](provision-minimal-iam-policy.md)」を参照してください。長期認証情報を取得する方法の詳細については、「*IAM ユーザーガイド*」の「[IAM ユーザーのアクセスキーを管理します。](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html)」を参照してください。
1. 次のコマンドを実行して、認証情報を AWS IoT Greengrass Core ソフトウェアに提供します。
------
#### [ Linux or Unix ]
```
export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
```
------
#### [ Windows Command Prompt (CMD) ]
```
set AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
set AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
```
------
#### [ PowerShell ]
```
$env:AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
$env:AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
```
------
1. (オプション) Greengrass デバイスをプロビジョニングする IAM ユーザーを作成した場合は、ユーザーを削除します。
1. (オプション) 既存の IAM ユーザーのアクセスキー ID とシークレットアクセスキーを使用した場合は、そのユーザーのキーを更新して、そのキーが無効になるようにします。詳細については、「AWS Identity and Access Management ユーザーガイド」の「[アクセスキーの更新](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html#Using_RotateAccessKey)」を参照してください。**
## AWS IoT Greengrass Core ソフトウェアをダウンロードする
AWS IoT Greengrass Core ソフトウェアの最新バージョンは、次の場所からダウンロードできます。
+ [https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip](https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip)
**注記**
Core AWS IoT Greengrass ソフトウェアの特定のバージョンは、次の場所からダウンロードできます。*バージョン*をダウンロードするバージョンに置き換えます。
```
https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-version.zip
```
**AWS IoT Greengrass Core ソフトウェアをダウンロードするには**
1. コアデバイスで、 AWS IoT Greengrass Core ソフトウェアを という名前のファイルにダウンロードします`greengrass-nucleus-latest.zip`。
------
#### [ Linux or Unix ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
iwr -Uri https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip -OutFile greengrass-nucleus-latest.zip
```
------
このソフトウェアをダウンロードすると、[Greengrass Core ソフトウェアのライセンス契約](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf)に同意したものと見なされます。
1. (オプション) Greengrass nucleus ソフトウェア署名を確認するには
**注記**
この機能は、Greengrass nucleus バージョン 2.9.5 以降で使用できます。
1. 以下のコマンドを使用して、Greengrass nucleus アーティファクトの署名を確認します。
------
#### [ Linux or Unix ]
```
jarsigner -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
インストールする JDK のバージョンによって、ファイル名が異なる場合があります。インストールした JDK のバージョンに *`jdk17.0.6_10`* を置き換えてください。
```
"C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe" -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
インストールする JDK のバージョンによって、ファイル名が異なる場合があります。インストールした JDK のバージョンに *`jdk17.0.6_10`* を置き換えてください。
```
'C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe' -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
1. `jarsigner` が起動すると、検証結果を示す出力が得られます。
1. Greengrass nucleus の zip ファイルに署名されると、出力に以下のような文が表示されます：
```
jar verified.
```
1. Greengrass nucleus の zip ファイルに署名されないと、出力に以下のような文が表示されます：
```
jar is unsigned.
```
1. Jarsigner `-certs` を `-verify` と`-verbose` オプションと一緒に提供した場合、出力には署名者証明書の詳細情報も含まれます。
1. AWS IoT Greengrass Core ソフトウェアをデバイスのフォルダに解凍します。*GreengrassInstaller* を使用するフォルダに置き換えます。
------
#### [ Linux or Unix ]
```
unzip greengrass-nucleus-latest.zip -d GreengrassInstaller && rm greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
mkdir GreengrassInstaller && tar -xf greengrass-nucleus-latest.zip -C GreengrassInstaller && del greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
Expand-Archive -Path greengrass-nucleus-latest.zip -DestinationPath .\\GreengrassInstaller
rm greengrass-nucleus-latest.zip
```
------
1. (オプション) 次のコマンドを実行して、 AWS IoT Greengrass Core ソフトウェアのバージョンを確認します。
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
**重要**
v2.4.0 より前のバージョンの Greengrass nucleus をインストールした場合は、 AWS IoT Greengrass Core ソフトウェアをインストールした後にこのフォルダを削除しないでください。 AWS IoT Greengrass Core ソフトウェアは、このフォルダ内のファイルを使用して実行します。
ソフトウェアの最新バージョンをダウンロードした場合は、v2.4.0 以降をインストールし、 AWS IoT Greengrass Core ソフトウェアをインストールした後にこのフォルダを削除できます。
## AWS IoT Greengrass Core ソフトウェアのインストール
次のことを指定する引数を含んだインストーラを実行します。
+ コアデバイスが動作するために必要な AWS リソースを作成します。
+ コアデバイスでソフトウェアコンポーネントを実行するために `ggc_user` システムユーザーを使用するように指定します。Linux デバイスでは、このコマンドも `ggc_group` システムグループを使用するように指定し、さらにインストーラによってシステムユーザーとグループが、ユーザーに代わって作成されます。
+ Core AWS IoT Greengrass ソフトウェアを、起動時に実行されるシステムサービスとしてセットアップします。Linux デバイスでは、これは [Systemd](https://en.wikipedia.org/wiki/Systemd) init システムが必要です。
**重要**
Windows コアデバイスでは、 AWS IoT Greengrass Core ソフトウェアをシステムサービスとして設定する必要があります。
ローカル開発ツールで開発デバイスをセットアップするには、`--deploy-dev-tools true` 引数を指定します。インストール完了後、ローカル開発ツールのデプロイには最大 1 分かかることがあります。
指定できる引数の詳細については、「[インストーラ引数](configure-installer.md)」を参照してください。
**注記**
メモリが制限された AWS IoT Greengrass デバイスで実行している場合は、 AWS IoT Greengrass Core ソフトウェアが使用するメモリ量を制御できます。メモリ割り当てを制御するには、nucleus コンポーネントの `jvmOptions` 設定パラメータで JVM ヒープのサイズオプションを設定できます。詳細については、「[JVM オプションでメモリ割り当てを制御する](configure-greengrass-core-v2.md#jvm-tuning)」を参照してください。
**AWS IoT Greengrass Core ソフトウェアをインストールするには**
1. AWS IoT Greengrass Core インストーラを実行します。コマンドの引数値を次のように置き換えます。
**注記**
Windows では、パスの長さは 260 文字に制限されています。Windows を使用している場合は、`C:\greengrass\v2` や `D:\greengrass\v2` などのルートフォルダを使用して、Greengrass コンポーネントのパスを 260 文字の制限内に留めます。
1. `/greengrass/v2` または *C:\$1greengrass\$1v2*: AWS IoT Greengrass Core ソフトウェアのインストールに使用するルートフォルダへのパス。
1. *GreengrassInstaller*。 AWS IoT Greengrass Core ソフトウェアインストーラを解凍したフォルダへのパス。
1. *リージョン*。リソースを検索または作成する AWS リージョン 。
1. *MyGreengrassCore*。Greengrass コアデバイスの AWS IoT モノの名前。モノが存在しない場合、インストーラによって作成されます。インストーラは証明書をダウンロードして AWS IoT 、モノとして認証します。詳細については、「[AWS IoT Greengrassのデバイス認証と認可](device-auth.md)」を参照してください。
**注記**
モノの名前にコロン (`:`) 記号を含むことができません。
1. *MyGreengrassCoreGroup*。Greengrass コアデバイスの AWS IoT モノグループの名前。モノグループが存在しない場合、インストーラはそのグループを作成してモノを追加します。モノグループが存在してアクティブなデプロイがある場合、コアデバイスはデプロイで指定されたソフトウェアをダウンロードして実行します。
**注記**
モノグループ名にコロン (`:`) 記号を含めることはできません。
1. *GreengrassV2IoTThingPolicy*。Greengrass コアデバイスが AWS IoT および と通信することを許可する AWS IoT ポリシーの名前 AWS IoT Greengrass。ポリシーが存在しない場合 AWS IoT 、インストーラはこの名前で許可 AWS IoT ポリシーを作成します。ユースケースに合わせて、このポリシーのアクセス許可を制限することができます。詳細については、「[AWS IoT Greengrass V2 コアデバイスの最小 AWS IoT ポリシー](device-auth.md#greengrass-core-minimal-iot-policy)」を参照してください。
1. *GreengrassV2TokenExchangeRole*。Greengrass コアデバイスが一時的な AWS 認証情報を取得できるようにする IAM ロールの名前。ロールが存在しない場合、インストーラがロールを作成し、`GreengrassV2TokenExchangeRoleAccess` という名前のポリシーを作成してアタッチします。詳細については、「[コアデバイスが AWS サービスとやり取りできるように認可する](device-service-role.md)」を参照してください。
1. *GreengrassCoreTokenExchangeRoleAlias*。Greengrass コアデバイスが後で一時的な認証情報を取得できるようにする IAM ロールのエイリアス。ロールエイリアスが存在しない場合、インストーラがロールエイリアスを作成し、指定した IAM ロールを指します。詳細については、「[コアデバイスが AWS サービスとやり取りできるように認可する](device-service-role.md)」を参照してください。
------
#### [ Linux or Unix ]
```
sudo -E java -Droot="/greengrass/v2" -Dlog.store=FILE \
-jar ./GreengrassInstaller/lib/Greengrass.jar \
--aws-region region \
--thing-name MyGreengrassCore \
--thing-group-name MyGreengrassCoreGroup \
--thing-policy-name GreengrassV2IoTThingPolicy \
--tes-role-name GreengrassV2TokenExchangeRole \
--tes-role-alias-name GreengrassCoreTokenExchangeRoleAlias \
--component-default-user ggc_user:ggc_group \
--provision true \
--setup-system-service true
```
------
#### [ Windows Command Prompt (CMD) ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" ^
-jar ./GreengrassInstaller/lib/Greengrass.jar ^
--aws-region region ^
--thing-name MyGreengrassCore ^
--thing-group-name MyGreengrassCoreGroup ^
--thing-policy-name GreengrassV2IoTThingPolicy ^
--tes-role-name GreengrassV2TokenExchangeRole ^
--tes-role-alias-name GreengrassCoreTokenExchangeRoleAlias ^
--component-default-user ggc_user ^
--provision true ^
--setup-system-service true
```
------
#### [ PowerShell ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" `
-jar ./GreengrassInstaller/lib/Greengrass.jar `
--aws-region region `
--thing-name MyGreengrassCore `
--thing-group-name MyGreengrassCoreGroup `
--thing-policy-name GreengrassV2IoTThingPolicy `
--tes-role-name GreengrassV2TokenExchangeRole `
--tes-role-alias-name GreengrassCoreTokenExchangeRoleAlias `
--component-default-user ggc_user `
--provision true `
--setup-system-service true
```
------
**重要**
Windows コアデバイスでは、 を指定`--setup-system-service true`して AWS IoT Greengrass Core ソフトウェアをシステムサービスとしてセットアップする必要があります。
インストーラが正常に処理すると、次のメッセージを印刷します。
+ `--provision` を指定すると、インストーラがリソースに正しく設定した場合、`Successfully configured Nucleus with provisioned resource details` を印刷します。
+ `--deploy-dev-tools` を指定すると、インストーラがデプロイを正しく作成した場合、`Configured Nucleus to deploy aws.greengrass.Cli component` を印刷します。
+ `--setup-system-service true` を指定すると、インストーラがソフトウェアをサービスとして設定して実行した場合、`Successfully set up Nucleus as a system service` を印刷します。
+ `--setup-system-service true` を指定しないと、インストーラが正常に処理できてソフトウェアを実行した場合、`Launched Nucleus successfully` を印刷します。
1. [Greengrass nucleus](greengrass-nucleus-component.md) v2.0.4 以降をインストールした場合、この手順を省略できます。ソフトウェアの最新バージョンをダウンロード済みで、v2.0.4 以降をインストールしています。
次のコマンドを実行して、 AWS IoT Greengrass Core ソフトウェアルートフォルダに必要なファイルアクセス許可を設定します。`/greengrass/v2` をインストールコマンドで指定したルートフォルダに置き換えて、*/greengrass* をルートフォルダの親フォルダに置き換えます。
```
sudo chmod 755 /greengrass/v2 && sudo chmod 755 /greengrass
```
AWS IoT Greengrass Core ソフトウェアをシステムサービスとしてインストールした場合、インストーラはソフトウェアを実行します。それ以外の場合、ソフトウェアを手動で実行する必要があります。詳細については、「[AWS IoT Greengrass Core ソフトウェアを実行する](run-greengrass-core-v2.md)」を参照してください。
**注記**
デフォルトでは、インストーラが作成する IAM ロールは S3 バケットのコンポーネントアーティファクトへのアクセスを許可しません。Amazon S3 でアーティファクトを定義するカスタムコンポーネントをデプロイするには、コアデバイスがコンポーネントアーティファクトを取得できるようにする許可をロールに追加する必要があります。詳細については、「[コンポーネントのアーティファクトの S3 バケットへのアクセスを許可する](device-service-role.md#device-service-role-access-s3-bucket)」を参照してください。
コンポーネントアーティファクトに S3 バケットをまだ持っていない場合、バケットを作成した後でこれらのアクセス許可を追加できます。
**注記**
AWS IoT Greengrass Core ソフトウェアがクラウドに接続すると、デバイスは Core デバイスとして認識されます。
ソフトウェアと を設定および使用する方法の詳細については AWS IoT Greengrass、以下を参照してください。
+ [AWS IoT Greengrass Core ソフトウェアを設定する](configure-greengrass-core-v2.md)
+ [AWS IoT Greengrass コンポーネントを開発する](develop-greengrass-components.md)
+ [AWS IoT Greengrass コンポーネントをデバイスにデプロイする](manage-deployments.md)
+ [Greengrass コマンドラインインターフェイス](gg-cli.md)
# 手動リソースプロビジョニングを使用して AWS IoT Greengrass Core ソフトウェアをインストールする
AWS IoT Greengrass Core ソフトウェアには、デバイスを Greengrass コアデバイスとしてセットアップするインストーラが含まれています。デバイスを手動でセットアップするには、デバイスが使用するために必要な AWS IoT および IAM リソースを作成できます。これらのリソースを手動で作成する場合、インストーラに AWS 認証情報を提供する必要はありません。
AWS IoT Greengrass Core ソフトウェアを手動でインストールする場合、ネットワークプロキシを使用するか、ポート 443 AWS で に接続するようにデバイスを設定することもできます。例えば、デバイスがファイアウォールやネットワークプロキシの背後で稼働している場合、これらの設定オプションの指定が必要な場合があります。詳細については、「[ポート 443 での接続またはネットワークプロキシを通じた接続](configure-greengrass-core-v2.md#configure-alpn-network-proxy)」を参照してください。
[PKCS\$111 インターフェイス](https://en.wikipedia.org/wiki/PKCS_11)を介してハードウェアセキュリティモジュール (HSM) を使用するように AWS IoT Greengrass Core ソフトウェアを設定することもできます。この機能は、プライベートキーと証明書ファイルを安全に保存して、ソフトウェアで公開または複製されないようにします。プライベートキーと証明書を、HSM、Trusted Platform Module (TPM)、別の暗号化要素などのハードウェアモジュールに保存できます。この機能は、Linux デバイスでのみ利用できます。ハードウェアセキュリティとその使用要件の詳細については、「[ハードウェアセキュリティ統合](hardware-security.md)」を参照してください。
**重要**
AWS IoT Greengrass Core ソフトウェアをダウンロードする前に、コアデバイスが AWS IoT Greengrass Core ソフトウェア v2.0 をインストールして実行する[要件を満た](greengrass-nucleus-component.md#greengrass-v2-requirements)していることを確認してください。
**Topics**
+ [AWS IoT エンドポイントを取得する](#retrieve-iot-endpoints)
+ [AWS IoT モノを作成する](#create-iot-thing)
+ [モノの証明書を作成する](#create-thing-certificate)
+ [モノの証明書を設定する](#configure-thing-certificate)
+ [トークン交換ロールを作成する](#create-token-exchange-role)
+ [デバイスに証明書をダウンロードする](#download-thing-certificates)
+ [デバイス環境をセットアップする](#set-up-device-environment)
+ [AWS IoT Greengrass Core ソフトウェアをダウンロードする](#download-greengrass-core-v2)
+ [AWS IoT Greengrass Core ソフトウェアをインストールする](#run-greengrass-core-v2-installer-manual)
## AWS IoT エンドポイントを取得する
の AWS IoT エンドポイントを取得し AWS アカウント、後で使用するために保存します。デバイスはこれらのエンドポイントを使用して AWS IoTに接続します。以下の操作を実行します。
1. AWS IoT のデータエンドポイントを取得します AWS アカウント。
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS
```
要求が正常に処理された場合、レスポンスは次の例のようになります。
```
{
"endpointAddress": "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
}
```
1. の AWS IoT 認証情報エンドポイントを取得します AWS アカウント。
```
aws iot describe-endpoint --endpoint-type iot:CredentialProvider
```
要求が正常に処理された場合、レスポンスは次の例のようになります。
```
{
"endpointAddress": "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
}
```
## AWS IoT モノを作成する
AWS IoT *モノ*は、 に接続するデバイスと論理エンティティを表します AWS IoT。Greengrass コアデバイスは AWS IoT モノです。デバイスを AWS IoT モノとして登録すると、そのデバイスはデジタル証明書を使用して認証できます AWS。
このセクションでは、デバイスを表す AWS IoT モノを作成します。
**AWS IoT モノを作成するには**
1. デバイスの AWS IoT モノを作成します。開発用コンピュータに次のコマンドを実行します。
+ *MyGreengrassCore* を使用するモノの名前に置き換えます。この名前は Greengrass コアデバイスの名前でもあります。
**注記**
モノの名前にコロン (`:`) 記号を含むことができません。
```
aws iot create-thing --thing-name MyGreengrassCore
```
要求が正常に処理された場合、レスポンスは次の例のようになります。
```
{
"thingName": "MyGreengrassCore",
"thingArn": "arn:aws:iot:us-west-2:123456789012:thing/MyGreengrassCore",
"thingId": "8cb4b6cd-268e-495d-b5b9-1713d71dbf42"
}
```
1. (オプション) AWS IoT モノを新規または既存のモノグループに追加します。モノグループを使用して Greengrass コアデバイスのフリートを管理します。ソフトウェアコンポーネントをデバイスにデプロイするとき、個々のデバイスまたはデバイスのグループを対象にできます。アクティブな Greengrass デプロイを持つモノグループにデバイスを追加して、そのモノグループのソフトウェアコンポーネントをデバイスにデプロイできます。以下の操作を実行します。
1. (オプション) AWS IoT モノのグループを作成します。
+ *MyGreengrassCoreGroup* を作成するモノグループの名前に置き換えます。
**注記**
モノグループ名にコロン (`:`) 記号を含めることはできません。
```
aws iot create-thing-group --thing-group-name MyGreengrassCoreGroup
```
要求が正常に処理された場合、レスポンスは次の例のようになります。
```
{
"thingGroupName": "MyGreengrassCoreGroup",
"thingGroupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/MyGreengrassCoreGroup",
"thingGroupId": "4df721e1-ff9f-4f97-92dd-02db4e3f03aa"
}
```
1. AWS IoT モノをモノのグループに追加します。
+ *MyGreengrassCore* を AWS IoT モノの名前に置き換えます。
+ *MyGreengrassCoreGroup* をモノグループの名前に置き換えます。
```
aws iot add-thing-to-thing-group --thing-name MyGreengrassCore --thing-group-name MyGreengrassCoreGroup
```
要求が正常に処理された場合、コマンドは出力されません。
## モノの証明書を作成する
デバイスを AWS IoT モノとして登録すると、そのデバイスはデジタル証明書を使用して認証できます AWS。この証明書により、デバイスは AWS IoT および と通信できます AWS IoT Greengrass。
このセクションでは、デバイスが AWSに接続する際に使用できる証明書を作成してダウンロードします。
ハードウェアセキュリティモジュール (HSM) を使用してプライベートキーと証明書を安全に保存するように AWS IoT Greengrass Core ソフトウェアを設定する場合は、手順に従って HSM のプライベートキーから証明書を作成します。それ以外の場合は、手順に従って AWS IoT サービスに証明書とプライベートキーを作成します。ハードウェアセキュリティ機能は Linux デバイスでのみ利用できます。ハードウェアセキュリティとその使用要件の詳細については、「[ハードウェアセキュリティ統合](hardware-security.md)」を参照してください。
### AWS IoT サービスで証明書とプライベートキーを作成する
**モノの証明書を作成するには**
1. AWS IoT モノの証明書をダウンロードするフォルダを作成します。
```
mkdir greengrass-v2-certs
```
1. AWS IoT モノの証明書を作成してダウンロードします。
```
aws iot create-keys-and-certificate --set-as-active --certificate-pem-outfile greengrass-v2-certs/device.pem.crt --public-key-outfile greengrass-v2-certs/public.pem.key --private-key-outfile greengrass-v2-certs/private.pem.key
```
要求が正常に処理された場合、レスポンスは次の例のようになります。
```
{
"certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
"certificateId": "aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
"certificatePem": "-----BEGIN CERTIFICATE-----
MIICiTCCAfICCQD6m7oRw0uXOjANBgkqhkiG9w
0BAQUFADCBiDELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZ
WF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIw
EAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5
jb20wHhcNMTEwNDI1MjA0NTIxWhcNMTIwNDI0MjA0NTIxWjCBiDELMAkGA1UEBh
MCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBb
WF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMx
HzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5jb20wgZ8wDQYJKoZIhvcNAQE
BBQADgY0AMIGJAoGBAMaK0dn+a4GmWIWJ21uUSfwfEvySWtC2XADZ4nB+BLYgVI
k60CpiwsZ3G93vUEIO3IyNoH/f0wYK8m9TrDHudUZg3qX4waLG5M43q7Wgc/MbQ
ITxOUSQv7c7ugFFDzQGBzZswY6786m86gpEIbb3OhjZnzcvQAaRHhdlQWIMm2nr
AgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAtCu4nUhVVxYUntneD9+h8Mg9q6q+auN
KyExzyLwaxlAoo7TJHidbtS4J5iNmZgXL0FkbFFBjvSfpJIlJ00zbhNYS5f6Guo
EDmFJl0ZxBHjJnyp378OD8uTs7fLvjx79LjSTbNYiytVbZPQUQ5Yaxu2jXnimvw
3rrszlaEXAMPLE=
-----END CERTIFICATE-----",
"keyPair": {
"PublicKey": "-----BEGIN PUBLIC KEY-----\
MIIBIjANBgkqhkEXAMPLEQEFAAOCAQ8AMIIBCgKCAQEAEXAMPLE1nnyJwKSMHw4h\
MMEXAMPLEuuN/dMAS3fyce8DW/4+EXAMPLEyjmoF/YVF/gHr99VEEXAMPLE5VF13\
59VK7cEXAMPLE67GK+y+jikqXOgHh/xJTwo+sGpWEXAMPLEDz18xOd2ka4tCzuWEXAMPLEahJbYkCPUBSU8opVkR7qkEXAMPLE1DR6sx2HocliOOLtu6Fkw91swQWEXAMPLE\\GB3ZPrNh0PzQYvjUStZeccyNCx2EXAMPLEvp9mQOUXP6plfgxwKRX2fEXAMPLEDa\
hJLXkX3rHU2xbxJSq7D+XEXAMPLEcw+LyFhI5mgFRl88eGdsAEXAMPLElnI9EesG\
FQIDAQAB\
-----END PUBLIC KEY-----\
",
"PrivateKey": "-----BEGIN RSA PRIVATE KEY-----\
key omitted for security reasons\
-----END RSA PRIVATE KEY-----\
"
}
}
```
後で証明書を設定するために使用する証明書の Amazon リソースネーム (ARN) を保存します。
### HSM のプライベートキーから証明書の作成
**注記**
この機能は、[Greengrass nucleus コンポーネントの](greengrass-nucleus-component.md) v2.5.3 以降で使用できます。現在、この機能は Windows AWS IoT Greengrass コアデバイスでサポートされていません。
**モノの証明書を作成するには**
1. コアデバイスで、HSM 内に PKCS\$111 トークンを初期化してプライベートキーを生成します。プライベートキーは、RSA-2048 キーサイズ (またはそれ以上) の RSA キーまたは ECC キーである必要があります。
**注記**
ECC キーを備えたハードウェアセキュリティモジュールを使用するには、v2.5.6 以降の [Greengrass nucleus](greengrass-nucleus-component.md) を使用する必要があります。
ハードウェアセキュリティモジュールと[シークレットマネージャー](secret-manager-component.md)を使用するには、RSA キーを備えたハードウェアセキュリティモジュールを使用する必要があります。
トークンを初期化してプライベートキーを生成する方法については、HSM のマニュアルを参照してください。HSM がオブジェクト ID をサポートしている場合、プライベートキーの生成時にオブジェクト ID を指定してください。トークンの初期化とプライベートキーの生成時に指定するスロット ID、ユーザー PIN、オブジェクトラベル、オブジェクト ID (HSM が使用する場合) を保存します。これらの値は、後でモノの証明書を HSM にインポートし、 AWS IoT Greengrass Core ソフトウェアを設定するときに使用します。
1. プライベートキーから証明書署名リクエスト (CSR) を作成します。 はこの CSR AWS IoT を使用して、HSM で生成したプライベートキーのモノの証明書を作成します。プライベートキーで CSR を作成する方法については、HSM のマニュアルを参照してください。CSR は `iotdevicekey.csr` などのようなファイルです。
1. CSR をデバイスから開発用コンピュータにコピーします。開発用コンピュータとデバイスで SSH と SCP が有効になっている場合、開発用コンピュータで `scp` コマンドを使用して CSR を転送できます。*device-ip-address* をデバイスの IP アドレスに置き換えて、*\$1/iotdevicekey.csr* をデバイスの CSR ファイルへのパスに置き換えます。
```
scp device-ip-address:~/iotdevicekey.csr iotdevicekey.csr
```
1. 開発用コンピュータで、 AWS IoT モノの証明書をダウンロードするフォルダを作成します。
```
mkdir greengrass-v2-certs
```
1. CSR ファイルを使用して、 AWS IoT モノの証明書を作成し、開発用コンピュータにダウンロードします。
```
aws iot create-certificate-from-csr --set-as-active --certificate-signing-request=file://iotdevicekey.csr --certificate-pem-outfile greengrass-v2-certs/device.pem.crt
```
要求が正常に処理された場合、レスポンスは次の例のようになります。
```
{
"certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
"certificateId": "aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
"certificatePem": "-----BEGIN CERTIFICATE-----
MIICiTCCAfICCQD6m7oRw0uXOjANBgkqhkiG9w
0BAQUFADCBiDELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZ
WF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIw
EAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5
jb20wHhcNMTEwNDI1MjA0NTIxWhcNMTIwNDI0MjA0NTIxWjCBiDELMAkGA1UEBh
MCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBb
WF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMx
HzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5jb20wgZ8wDQYJKoZIhvcNAQE
BBQADgY0AMIGJAoGBAMaK0dn+a4GmWIWJ21uUSfwfEvySWtC2XADZ4nB+BLYgVI
k60CpiwsZ3G93vUEIO3IyNoH/f0wYK8m9TrDHudUZg3qX4waLG5M43q7Wgc/MbQ
ITxOUSQv7c7ugFFDzQGBzZswY6786m86gpEIbb3OhjZnzcvQAaRHhdlQWIMm2nr
AgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAtCu4nUhVVxYUntneD9+h8Mg9q6q+auN
KyExzyLwaxlAoo7TJHidbtS4J5iNmZgXL0FkbFFBjvSfpJIlJ00zbhNYS5f6Guo
EDmFJl0ZxBHjJnyp378OD8uTs7fLvjx79LjSTbNYiytVbZPQUQ5Yaxu2jXnimvw
3rrszlaEXAMPLE=
-----END CERTIFICATE-----"
}
```
証明書の ARN を保存して後で証明書を設定するために使用します。
## モノの証明書を設定する
先ほど作成した AWS IoT モノにモノの証明書をアタッチし、証明書に AWS IoT ポリシーを追加して、コアデバイスの AWS IoT アクセス許可を定義します。
**モノの証明書を設定するには**
1. 証明書を AWS IoT モノにアタッチします。
+ *MyGreengrassCore* を AWS IoT モノの名前に置き換えます。
+ 証明書 Amazon リソースネーム (ARN) を、前のステップで作成した証明書の ARN に置き換えます。
```
aws iot attach-thing-principal --thing-name MyGreengrassCore --principal arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4
```
要求が正常に処理された場合、コマンドは出力されません。
1. Greengrass コアデバイスの AWS IoT アクセス許可を定義する AWS IoT ポリシーを作成してアタッチします。次のポリシーは、すべての MQTT トピックと Greengrass 操作へのアクセスを許可するため、デバイスがカスタムアプリケーションや新しい Greengrass 操作を必要とする今後の変更でも動作するようになります。ユースケースに基づいてこのポリシーを制限できます。詳細については、「[AWS IoT Greengrass V2 コアデバイスの最小 AWS IoT ポリシー](device-auth.md#greengrass-core-minimal-iot-policy)」を参照してください。
Greengrass コアデバイスを以前にセットアップしたことがある場合は、新しいポリシーを作成する代わりに、その AWS IoT ポリシーをアタッチできます。
以下の操作を実行します。
1. Greengrass コアデバイスが必要とする AWS IoT ポリシードキュメントを含むファイルを作成します。
例えば、Linux ベースのシステムでは、次のコマンドを実行し、GNU nano を使用してファイルを作成できます。
```
nano greengrass-v2-iot-policy.json
```
次の JSON をファイルにコピーします。
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Publish",
"iot:Subscribe",
"iot:Receive",
"iot:Connect",
"greengrass:*"
],
"Resource": [
"*"
]
}
]
}
```
1. AWS IoT ポリシードキュメントから ポリシーを作成します。
+ *GreengrassV2IoTThingPolicy* を作成するポリシーの名前に置き換えます。
```
aws iot create-policy --policy-name GreengrassV2IoTThingPolicy --policy-document file://greengrass-v2-iot-policy.json
```
要求が正常に処理された場合、レスポンスは次の例のようになります。
```
{
"policyName": "GreengrassV2IoTThingPolicy",
"policyArn": "arn:aws:iot:us-west-2:123456789012:policy/GreengrassV2IoTThingPolicy",
"policyDocument": "{
\\"Version\\": \\"2012-10-17 \\",
\\"Statement\\": [
{
\\"Effect\\": \\"Allow\\",
\\"Action\\": [
\\"iot:Publish\\",
\\"iot:Subscribe\\",
\\"iot:Receive\\",
\\"iot:Connect\\",
\\"greengrass:*\\"
],
\\"Resource\\": [
\\"*\\"
]
}
]
}",
"policyVersionId": "1"
}
```
1. AWS IoT モノの証明書に AWS IoT ポリシーをアタッチします。
+ *GreengrassV2IoTThingPolicy* をアタッチするポリシーの名前に置き換えます。
+ ターゲット ARN を AWS IoT モノの証明書の ARN に置き換えます。
```
aws iot attach-policy --policy-name GreengrassV2IoTThingPolicy --target arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4
```
要求が正常に処理された場合、コマンドは出力されません。
## トークン交換ロールを作成する
Greengrass コアデバイスは、*トークン交換ロールと呼ばれる IAM サービスロール*を使用して、 AWS サービスへの呼び出しを承認します。デバイスは認証情報 AWS IoT プロバイダーを使用して、このロールの一時的な AWS 認証情報を取得します。これにより、デバイスは Amazon CloudWatch Logs とやり取りしたり AWS IoT、Amazon CloudWatch Logs にログを送信したり、Amazon S3 からカスタムコンポーネントアーティファクトをダウンロードしたりできます。 Amazon CloudWatch 詳細については、「[コアデバイスが AWS サービスとやり取りできるように認可する](device-service-role.md)」を参照してください。
AWS IoT *ロールエイリアス*を使用して、Greengrass コアデバイスのトークン交換ロールを設定します。ロールエイリアスは、デバイスのトークン交換ロールを変更できるようにしますが、デバイス設定は同じ内容に保たれます。詳細については、「*AWS IoT Core デベロッパーガイド*」の「[Authorizing direct calls to AWS services](https://docs.aws.amazon.com/iot/latest/developerguide/authorizing-direct-aws.html)」を参照してください。
このセクションでは、トークン交換 IAM ロールと AWS IoT 、ロールを指すロールエイリアスを作成します。Greengrass コアデバイスを既に設定している場合、新しく作成せず、トークン交換ロールとロールエイリアスを使用できます。次に、デバイスの AWS IoT モノを設定してそのロールとエイリアスを使用します。
**トークン交換 IAM ロールを作成するには**
1. デバイスがトークン交換ロールとして使用できる IAM ロールを作成します。以下の操作を実行します。
1. トークン交換ロールが必要とする、信頼できるポリシードキュメントが含まれるファイルを作成します。
例えば、Linux ベースのシステムでは、次のコマンドを実行し、GNU nano を使用してファイルを作成できます。
```
nano device-role-trust-policy.json
```
次の JSON をファイルにコピーします。
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
1. 信頼ポリシードキュメントでトークン交換ロールを作成します。
+ *GreengrassV2TokenExchangeRole* を、作成する IAM ロールの名前に置き換えます。
```
aws iam create-role --role-name GreengrassV2TokenExchangeRole --assume-role-policy-document file://device-role-trust-policy.json
```
要求が正常に処理された場合、レスポンスは次の例のようになります。
```
{
"Role": {
"Path": "/",
"RoleName": "GreengrassV2TokenExchangeRole",
"RoleId": "AROAZ2YMUHYHK5OKM77FB",
"Arn": "arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole",
"CreateDate": "2021-02-06T00:13:29+00:00",
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
}
```
1. トークン交換ロールが必要なアクセスポリシードキュメントを含むファイルを作成します。
例えば、Linux ベースのシステムでは、次のコマンドを実行し、GNU nano を使用してファイルを作成できます。
```
nano device-role-access-policy.json
```
次の JSON をファイルにコピーします。
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents",
"logs:DescribeLogStreams",
"s3:GetBucketLocation"
],
"Resource": "*"
}
]
}
```
**注記**
このアクセスポリシーでは、S3 バケットのコンポーネントアーティファクトへのアクセスが許可されていません。Amazon S3 でアーティファクトを定義するカスタムコンポーネントをデプロイするには、コアデバイスがコンポーネントアーティファクトを取得できるようにする許可をロールに追加する必要があります。詳細については、「[コンポーネントのアーティファクトの S3 バケットへのアクセスを許可する](device-service-role.md#device-service-role-access-s3-bucket)」を参照してください。
コンポーネントアーティファクトに S3 バケットをまだ持っていない場合、バケットを作成した後でこれらのアクセス許可を追加できます。
1. ポリシードキュメントから IAM ポリシーを作成します。
+ *GreengrassV2TokenExchangeRoleAccess* を作成する IAM ポリシーの名前に置き換えます。
```
aws iam create-policy --policy-name GreengrassV2TokenExchangeRoleAccess --policy-document file://device-role-access-policy.json
```
要求が正常に処理された場合、レスポンスは次の例のようになります。
```
{
"Policy": {
"PolicyName": "GreengrassV2TokenExchangeRoleAccess",
"PolicyId": "ANPAZ2YMUHYHACI7C5Z66",
"Arn": "arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess",
"Path": "/",
"DefaultVersionId": "v1",
"AttachmentCount": 0,
"PermissionsBoundaryUsageCount": 0,
"IsAttachable": true,
"CreateDate": "2021-02-06T00:37:17+00:00",
"UpdateDate": "2021-02-06T00:37:17+00:00"
}
}
```
1. IAM ポリシーをトークン交換ロールにアタッチします。
+ *GreengrassV2TokenExchangeRole* を、IAM ロールの名前に置き換えます。
+ ポリシー ARN を前のステップで作成した IAM ポリシーの ARN に置き換えます。
```
aws iam attach-role-policy --role-name GreengrassV2TokenExchangeRole --policy-arn arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess
```
要求が正常に処理された場合、コマンドは出力されません。
1. トークン交換 AWS IoT ロールを指すロールエイリアスを作成します。
+ *GreengrassCoreTokenExchangeRoleAlias* を作成するロールエイリアスの名前に置き換えます。
+ ロール ARN を前のステップで作成した IAM ロールの ARN に置き換えます。
```
aws iot create-role-alias --role-alias GreengrassCoreTokenExchangeRoleAlias --role-arn arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole
```
要求が正常に処理された場合、レスポンスは次の例のようになります。
```
{
"roleAlias": "GreengrassCoreTokenExchangeRoleAlias",
"roleAliasArn": "arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
```
**注記**
ロールエイリアスを作成するには、トークン交換 IAM ロールを AWS IoTに渡す許可が必要です。ロールエイリアスを作成しようとしたときにエラーメッセージが表示された場合は、 AWS ユーザーにこのアクセス許可があることを確認してください。詳細については、「 *AWS Identity and Access Management ユーザーガイド*[」の「 AWS サービスにロールを渡すアクセス許可をユーザーに付与](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_passrole.html)する」を参照してください。
1. Greengrass コアデバイスがロールエイリアスを使用してトークン交換ロールを引き受けることを許可する AWS IoT ポリシーを作成してアタッチします。Greengrass コアデバイスを以前にセットアップしたことがある場合は、新しいロールエイリアスポリシーを作成する代わりに、そのロールエイリアス AWS IoT ポリシーをアタッチできます。以下の操作を実行します。
1. (オプション) ロールエイリアスに必要な AWS IoT ポリシードキュメントを含むファイルを作成します。
例えば、Linux ベースのシステムでは、次のコマンドを実行し、GNU nano を使用してファイルを作成できます。
```
nano greengrass-v2-iot-role-alias-policy.json
```
次の JSON をファイルにコピーします。
+ リソース ARN をロールエイリアスの ARN に置き換えます。
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iot:AssumeRoleWithCertificate",
"Resource": "arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
]
}
```
1. AWS IoT ポリシードキュメントから ポリシーを作成します。
+ *GreengrassCoreTokenExchangeRoleAliasPolicy* を、作成する AWS IoT ポリシーの名前に置き換えます。
```
aws iot create-policy --policy-name GreengrassCoreTokenExchangeRoleAliasPolicy --policy-document file://greengrass-v2-iot-role-alias-policy.json
```
要求が正常に処理された場合、レスポンスは次の例のようになります。
```
{
"policyName": "GreengrassCoreTokenExchangeRoleAliasPolicy",
"policyArn": "arn:aws:iot:us-west-2:123456789012:policy/GreengrassCoreTokenExchangeRoleAliasPolicy",
"policyDocument": "{
\\"Version\\":\\"2012-10-17 \\",
\\"Statement\\": [
{
\\"Effect\\": \\"Allow\\",
\\"Action\\": \\"iot:AssumeRoleWithCertificate\\",
\\"Resource\\": \\"arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias\\"
}
]
}",
"policyVersionId": "1"
}
```
1. AWS IoT モノの証明書に AWS IoT ポリシーをアタッチします。
+ *GreengrassCoreTokenExchangeRoleAliasPolicy* をロールエイリアス AWS IoT ポリシーの名前に置き換えます。
+ ターゲット ARN を AWS IoT モノの証明書の ARN に置き換えます。
```
aws iot attach-policy --policy-name GreengrassCoreTokenExchangeRoleAliasPolicy --target arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4
```
要求が正常に処理された場合、コマンドは出力されません。
## デバイスに証明書をダウンロードする
以前に、デバイスの証明書を開発用コンピュータにダウンロードしました。このセクションでは、コアデバイスに証明書をコピーして、 AWS IoTに接続するために使用する証明書でデバイスをセットアップします。Amazon ルート認証機関 (CA) の証明書もダウンロードします。HSM を使用する場合、このセクションの HSM に証明書ファイルもインポートします。
+ 以前に AWS IoT サービスでモノの証明書とプライベートキーを作成した場合は、手順に従ってプライベートキーと証明書ファイルを含む証明書をダウンロードします。
+ 以前にハードウェアセキュリティモジュール (HSM) のプライベートキーからモノ証明書を作成した場合、手順に従って HSM のプライベートキーと証明書で証明書をダウンロードします。
### プライベートキーと証明書ファイルで証明書をダウンロード
**証明書をデバイスにダウンロードするには**
1. モノの AWS IoT 証明書を開発用コンピュータからデバイスにコピーします。開発用コンピュータとデバイスで SSH と SCP が有効になっている場合、開発用コンピュータの `scp` コマンドを実行して、証明書を転送できます。*device-ip-address* をデバイスの IP アドレスに置き換えます。
```
scp -r greengrass-v2-certs/ device-ip-address:~
```
1. デバイスに Greengrass ルートフォルダを作成します。後で AWS IoT Greengrass Core ソフトウェアをこのフォルダにインストールします。
**注記**
Windows では、パスの長さは 260 文字に制限されています。Windows を使用している場合は、`C:\greengrass\v2` や `D:\greengrass\v2` などのルートフォルダを使用して、Greengrass コンポーネントのパスを 260 文字の制限内に留めます。
------
#### [ Linux or Unix ]
+ `/greengrass/v2` を使用するフォルダに置き換えます。
```
sudo mkdir -p /greengrass/v2
```
------
#### [ Windows Command Prompt ]
+ *C:\$1greengrass\$1v2* を使用するフォルダに置き換えます。
```
mkdir C:\greengrass\v2
```
------
#### [ PowerShell ]
+ *C:\$1greengrass\$1v2* を使用するフォルダに置き換えます。
```
mkdir C:\greengrass\v2
```
------
1. (Linux のみ) Greengrass ルートフォルダの親の許可を設定します。
+ */greengrass* をルートフォルダへの親に置き換えます。
```
sudo chmod 755 /greengrass
```
1. AWS IoT モノの証明書を Greengrass ルートフォルダにコピーします。
------
#### [ Linux or Unix ]
+ `/greengrass/v2` を Greengrass のルートフォルダに置き換えます。
```
sudo cp -R ~/greengrass-v2-certs/* /greengrass/v2
```
------
#### [ Windows Command Prompt ]
+ *C:\$1greengrass\$1v2* を使用するフォルダに置き換えます。
```
robocopy %USERPROFILE%\greengrass-v2-certs C:\greengrass\v2 /E
```
------
#### [ PowerShell ]
+ *C:\$1greengrass\$1v2* を使用するフォルダに置き換えます。
```
cp -Path ~\greengrass-v2-certs\* -Destination C:\greengrass\v2
```
------
1. Amazon ルート認証局 (CA) 証明書をダウンロードします。 AWS IoT 証明書は、デフォルトで Amazon のルート CA 証明書に関連付けられています。
------
#### [ Linux or Unix ]
```
sudo curl -o /greengrass/v2/AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -o C:\greengrass\v2\\AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ PowerShell ]
```
iwr -Uri https://www.amazontrust.com/repository/AmazonRootCA1.pem -OutFile C:\greengrass\v2\\AmazonRootCA1.pem
```
------
### HSM にプライベートキーと証明書を含む証明書をダウンロード
**注記**
この機能は、[Greengrass nucleus コンポーネントの](greengrass-nucleus-component.md) v2.5.3 以降で使用できます。現在、この機能は Windows AWS IoT Greengrass コアデバイスでサポートされていません。
**証明書をデバイスにダウンロードするには**
1. モノの AWS IoT 証明書を開発用コンピュータからデバイスにコピーします。開発用コンピュータとデバイスで SSH と SCP が有効になっている場合、開発用コンピュータの `scp` コマンドを実行して、証明書を転送できます。*device-ip-address* をデバイスの IP アドレスに置き換えます。
```
scp -r greengrass-v2-certs/ device-ip-address:~
```
1. デバイスに Greengrass ルートフォルダを作成します。後で AWS IoT Greengrass Core ソフトウェアをこのフォルダにインストールします。
**注記**
Windows では、パスの長さは 260 文字に制限されています。Windows を使用している場合は、`C:\greengrass\v2` や `D:\greengrass\v2` などのルートフォルダを使用して、Greengrass コンポーネントのパスを 260 文字の制限内に留めます。
------
#### [ Linux or Unix ]
+ `/greengrass/v2` を使用するフォルダに置き換えます。
```
sudo mkdir -p /greengrass/v2
```
------
#### [ Windows Command Prompt ]
+ *C:\$1greengrass\$1v2* を使用するフォルダに置き換えます。
```
mkdir C:\greengrass\v2
```
------
#### [ PowerShell ]
+ *C:\$1greengrass\$1v2* を使用するフォルダに置き換えます。
```
mkdir C:\greengrass\v2
```
------
1. (Linux のみ) Greengrass ルートフォルダの親の許可を設定します。
+ */greengrass* をルートフォルダへの親に置き換えます。
```
sudo chmod 755 /greengrass
```
1. モノの証明書ファイルである `~/greengrass-v2-certs/device.pem.crt` を HSM にインポートします。証明書をインポートする方法については、HSM のマニュアルを参照してください。以前に HSM でプライベートキーを生成したときと同じトークン、スロット ID、ユーザー PIN、オブジェクトラベル、オブジェクト ID (HSM が使用している場合) を使用して証明書をインポートします。
**注記**
以前にオブジェクト ID なしでプライベートキーを生成し、かつ証明書にオブジェクト ID がある場合、プライベートキーのオブジェクト ID を証明書と同じ値に設定します。プライベートキーオブジェクトのオブジェクト ID を設定する方法については、HSM のマニュアルを参照してください。
1. (オプション) モノ証明書のファイルを削除して、HSM にのみ存在するようにします。
```
rm ~/greengrass-v2-certs/device.pem.crt
```
1. Amazon ルート認証局 (CA) 証明書をダウンロードします。 AWS IoT 証明書は、デフォルトで Amazon のルート CA 証明書に関連付けられています。
------
#### [ Linux or Unix ]
```
sudo curl -o /greengrass/v2/AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -o C:\greengrass\v2\\AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ PowerShell ]
```
iwr -Uri https://www.amazontrust.com/repository/AmazonRootCA1.pem -OutFile C:\greengrass\v2\\AmazonRootCA1.pem
```
------
## デバイス環境をセットアップする
このセクションのステップに従って、 AWS IoT Greengrass コアデバイスとして使用する Linux または Windows デバイスをセットアップします。
### Linux デバイスをセットアップする
**の Linux デバイスを設定するには AWS IoT Greengrass V2**
1. AWS IoT Greengrass Core ソフトウェアが実行する必要がある Java ランタイムをインストールします。[Amazon Corretto](https://aws.amazon.com/corretto/) または [OpenJDK](https://openjdk.java.net/) の長期サポートバージョンを使用することをお勧めします。バージョン 8 以降が必要です。次のコマンドは、デバイスに OpenJDK をインストールする方法を示しています。
+ Debian ベースまたは Ubuntu ベースのディストリビューションの場合:
```
sudo apt install default-jdk
```
+ Red Hat ベースのディストリビューションの場合:
```
sudo yum install java-11-openjdk-devel
```
+ 複数 Amazon Linux 2:
```
sudo amazon-linux-extras install java-openjdk11
```
+ 複数 Amazon Linux 2023:
```
sudo dnf install java-11-amazon-corretto -y
```
インストールが完了したら、次のコマンドを実行して Java が Linux デバイスで実行されていることを確認します。
```
java -version
```
このコマンドは、デバイス上で実行されている Java のバージョンを出力します。例えば、Debian ベースのディストリビューションでは、出力は次のサンプルのようになります。
```
openjdk version "11.0.9.1" 2020-11-04
OpenJDK Runtime Environment (build 11.0.9.1+1-post-Debian-1deb10u2)
OpenJDK 64-Bit Server VM (build 11.0.9.1+1-post-Debian-1deb10u2, mixed mode)
```
1. (オプション) デバイスにコンポーネントを実行するデフォルトのシステムユーザーおよびグループを作成します。`--component-default-user` インストーラ引数を使用して、インストール中に AWS IoT Greengrass Core ソフトウェアインストーラにこのユーザーとグループを作成させることもできます。詳細については、「[インストーラ引数](configure-installer.md)」を参照してください。
```
sudo useradd --system --create-home ggc_user
sudo groupadd --system ggc_group
```
1. AWS IoT Greengrass Core ソフトウェアを実行するユーザー (通常は `root`) に、任意のユーザーと任意のグループ`sudo`で を実行するアクセス許可があることを確認します。
1. `/etc/sudoers` ファイルを開くには、次のコマンドを実行します。
```
sudo visudo
```
1. ユーザーの権限が次の例のようになっていることを確認します。
```
root ALL=(ALL:ALL) ALL
```
1. (オプション) [コンテナ化された Lambda 関数を実行](run-lambda-functions.md)するには、[cgroups](https://en.wikipedia.org/wiki/Cgroups) v1 を有効にし、*メモリ*と*デバイス*の cgroups を有効にしてマウントする必要があります。コンテナ化された Lambda 関数を実行する予定がない場合、この手順を省略できます。
これらの cgroups オプションを有効にするには、次の Linux カーネルパラメータを使用してデバイスを起動します。
```
cgroup_enable=memory cgroup_memory=1 systemd.unified_cgroup_hierarchy=0
```
デバイスのカーネルパラメータを確認および設定するための情報については、オペレーティングシステムおよびブートローダーのドキュメントを参照してください。指示に従って、カーネルパラメータを永続的に設定します。
1. [デバイスの要件](greengrass-nucleus-component.md#greengrass-v2-requirements) にある要件リストで示されているように、その他の必要となる依存関係をすべてデバイスにインストールします。
### Windows デバイスをセットアップする
**注記**
この機能は、[Greengrass nucleus コンポーネント](greengrass-nucleus-component.md)の v2.5.0 以降に利用できます。
**の Windows デバイスを設定するには AWS IoT Greengrass V2**
1. AWS IoT Greengrass Core ソフトウェアが実行する必要がある Java ランタイムをインストールします。[Amazon Corretto](https://aws.amazon.com/corretto/) または [OpenJDK](https://openjdk.java.net/) の長期サポートバージョンを使用することをお勧めします。バージョン 8 以降が必要です。
1. [PATH](https://en.wikipedia.org/wiki/PATH_(variable)) システム変数で Java が使用可能か確認し、そうでない場合は追加します。LocalSystem アカウントは AWS IoT Greengrass Core ソフトウェアを実行するため、ユーザーの PATH ユーザー変数ではなく PATH システム変数に Java を追加する必要があります。以下の操作を実行します。
1. Windows キーを押してスタートメニューを開きます。
1. **environment variables** を入力して、スタートメニューからシステムオプションを検索します。
1. スタートメニューの検索結果から **[Edit the system environment variables]** (システム環境変数を編集) をクリックして、**[System properties]** (システムプロパティ) ウィンドウを開きます。
1. **[Environment variables...]** (環境変数...) を選択して、**[Environment Variables]** (環境可変) ウィンドウを開きます。
1. **[System variables]** (システム変数) で、**[Path]** (パス) 、**[Edit]** (編集) の順に選択します。**[Edit environment variable]** (環境変数の編集) ウィンドウでは、個別の行に各パスを表示できます。
1. Java インストールの `bin` フォルダへのパスが存在しているかを確認します。このパスは、次の例のように表示されます。
```
C:\\Program Files\\Amazon Corretto\\jdk11.0.13_8\\bin
```
1. **[Path]** (パス) で Java インストールの `bin` フォルダが で見つからない場合は、**[New]** (新規) を選択してこれを追加した上で、**[OK]** を選択します。
1. 管理者として Windows コマンドプロンプト `cmd.exe` を開きます。
1. Windows デバイスの LocalSystem アカウントにデフォルトユーザーを作成します。*パスワード*を安全なパスワードに置き換えます。
```
net user /add ggc_user password
```
**ヒント**
Windows の構成によっては、ユーザーのパスワードの期限切れが、将来の日付に設定されている場合があります。Greengrass アプリケーションの動作を継続させるためには、パスワードの有効期限を追跡し、その期限が切れる前に更新します。ユーザーのパスワードには、期限切れを起こさないような設定も可能です。
ユーザーとパスワードの有効期限を確認するには、次のコマンドを実行します。
```
net user ggc_user | findstr /C:expires
```
ユーザーのパスワードが期限切れにならないように設定するには、次のコマンドを実行します。
```
wmic UserAccount where "Name='ggc_user'" set PasswordExpires=False
```
[`wmic` コマンドが廃止されている](https://learn.microsoft.com/en-us/windows/win32/wmisdk/wmic) Windows 10 以降を使用している場合は、次の PowerShell コマンドを実行します。
```
Get-CimInstance -Query "SELECT * from Win32_UserAccount WHERE name = 'ggc_user'" | Set-CimInstance -Property @{PasswordExpires="False"}
```
1. [PsExec ユーティリティ](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec)を Microsoft からダウンロードしてデバイスにインストールします。
1. PsExec ユーティリティを使用して、デフォルトユーザーのユーザー名とパスワードを LocalSystem アカウントの認証情報マネージャーインスタンスに格納します。*パスワード*を以前に設定したユーザーのパスワードに置き換えます。
```
psexec -s cmd /c cmdkey /generic:ggc_user /user:ggc_user /pass:password
```
**PsExec License Agreement** が開いたら、**Accept** を選択し、ライセンスに同意してコマンドを実行します。
**注記**
Windows デバイスでは、LocalSystem アカウントによって Greengrass nucleus が実行され、PsExec ユーティリティを使用して LocalSystem アカウントにデフォルトのユーザー情報を保存する必要があります。認証情報マネージャーアプリケーションを使用すると、この情報は LocalSystem アカウントではなく、現在ログオンしているユーザーの Windows アカウントに保存されます。
## AWS IoT Greengrass Core ソフトウェアをダウンロードする
AWS IoT Greengrass Core ソフトウェアの最新バージョンは、次の場所からダウンロードできます。
+ [https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip](https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip)
**注記**
AWS IoT Greengrass Core ソフトウェアの特定のバージョンは、次の場所からダウンロードできます。*バージョン*をダウンロードするバージョンに置き換えます。
```
https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-version.zip
```
**AWS IoT Greengrass Core ソフトウェアをダウンロードするには**
1. コアデバイスで、 AWS IoT Greengrass Core ソフトウェアを という名前のファイルにダウンロードします`greengrass-nucleus-latest.zip`。
------
#### [ Linux or Unix ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
iwr -Uri https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip -OutFile greengrass-nucleus-latest.zip
```
------
このソフトウェアをダウンロードすると、[Greengrass Core ソフトウェアのライセンス契約](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf)に同意したものと見なされます。
1. (オプション) Greengrass nucleus ソフトウェア署名を確認するには
**注記**
この機能は、Greengrass nucleus バージョン 2.9.5 以降で使用できます。
1. 以下のコマンドを使用して、Greengrass nucleus アーティファクトの署名を確認します。
------
#### [ Linux or Unix ]
```
jarsigner -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
インストールする JDK のバージョンによって、ファイル名が異なる場合があります。インストールした JDK のバージョンに *`jdk17.0.6_10`* を置き換えてください。
```
"C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe" -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
インストールする JDK のバージョンによって、ファイル名が異なる場合があります。インストールした JDK のバージョンに *`jdk17.0.6_10`* を置き換えてください。
```
'C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe' -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
1. `jarsigner` が起動すると、検証結果を示す出力が得られます。
1. Greengrass nucleus の zip ファイルに署名されると、出力に以下のような文が表示されます：
```
jar verified.
```
1. Greengrass nucleus の zip ファイルに署名されないと、出力に以下のような文が表示されます：
```
jar is unsigned.
```
1. Jarsigner `-certs` を `-verify` と`-verbose` オプションと一緒に提供した場合、出力には署名者証明書の詳細情報も含まれます。
1. AWS IoT Greengrass Core ソフトウェアをデバイスのフォルダに解凍します。*GreengrassInstaller* を使用するフォルダに置き換えます。
------
#### [ Linux or Unix ]
```
unzip greengrass-nucleus-latest.zip -d GreengrassInstaller && rm greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
mkdir GreengrassInstaller && tar -xf greengrass-nucleus-latest.zip -C GreengrassInstaller && del greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
Expand-Archive -Path greengrass-nucleus-latest.zip -DestinationPath .\\GreengrassInstaller
rm greengrass-nucleus-latest.zip
```
------
1. (オプション) 次のコマンドを実行して、 AWS IoT Greengrass Core ソフトウェアのバージョンを確認します。
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
**重要**
v2.4.0 より前のバージョンの Greengrass nucleus をインストールした場合は、 AWS IoT Greengrass Core ソフトウェアをインストールした後にこのフォルダを削除しないでください。 AWS IoT Greengrass Core ソフトウェアは、このフォルダ内のファイルを使用して実行します。
ソフトウェアの最新バージョンをダウンロードした場合は、v2.4.0 以降をインストールし、 AWS IoT Greengrass Core ソフトウェアをインストールした後にこのフォルダを削除できます。
## AWS IoT Greengrass Core ソフトウェアをインストールする
次のアクションを指定する引数を含むインストーラを実行します。
+ 以前に作成した AWS リソースと証明書を使用するように を指定する部分的な設定ファイルから をインストールします。 AWS IoT Greengrass Core ソフトウェアは、デバイス上のすべての Greengrass コンポーネントの設定を指定する設定ファイルを使用します。インストーラは、提供する部分設定ファイルで完全な設定ファイルを作成します。
+ コアデバイスでソフトウェアコンポーネントを実行するために `ggc_user` システムユーザーを使用するように指定します。Linux デバイスでは、このコマンドも `ggc_group` システムグループを使用するように指定し、さらにインストーラによってシステムユーザーとグループが、ユーザーに代わって作成されます。
+ Core AWS IoT Greengrass ソフトウェアを、起動時に実行されるシステムサービスとしてセットアップします。Linux デバイスでは、これは [Systemd](https://en.wikipedia.org/wiki/Systemd) init システムが必要です。
**重要**
Windows コアデバイスでは、 AWS IoT Greengrass Core ソフトウェアをシステムサービスとして設定する必要があります。
指定できる引数の詳細については、「[インストーラ引数](configure-installer.md)」を参照してください。
**注記**
メモリが制限された AWS IoT Greengrass デバイスで実行している場合は、 AWS IoT Greengrass Core ソフトウェアが使用するメモリ量を制御できます。メモリ割り当てを制御するには、nucleus コンポーネントの `jvmOptions` 設定パラメータで JVM ヒープのサイズオプションを設定できます。詳細については、「[JVM オプションでメモリ割り当てを制御する](configure-greengrass-core-v2.md#jvm-tuning)」を参照してください。
+ 以前に AWS IoT サービスでモノの証明書とプライベートキーを作成した場合は、手順に従ってプライベートキーと証明書ファイルを含む AWS IoT Greengrass Core ソフトウェアをインストールします。
+ 以前にハードウェアセキュリティモジュール (HSM) のプライベートキーからモノの証明書を作成した場合は、手順に従ってプライベートキーと証明書を含む AWS IoT Greengrass Core ソフトウェアを HSM にインストールします。
### プライベートキーと証明書ファイルを使用して AWS IoT Greengrass Core ソフトウェアをインストールする
**AWS IoT Greengrass Core ソフトウェアをインストールするには**
1. AWS IoT Greengrass Core ソフトウェアのバージョンを確認します。
+ *GreengrassInstaller* を、ソフトウェアが含まれるフォルダへのパスに置き換えます。
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
1. テキストエディタを使用し、`config.yaml` という名前の設定ファイルを作成してインストーラに提供します。
例えば、Linux ベースのシステムでは、次のコマンドを実行し、GNU nano を使用してファイルを作成できます。
```
nano GreengrassInstaller/config.yaml
```
次の YAML コンテンツをファイルにコピーします。この部分設定ファイルは、システムパラメータと Greengrass nucleus パラメータを指定します。
```
---
system:
certificateFilePath: "/greengrass/v2/device.pem.crt"
privateKeyPath: "/greengrass/v2/private.pem.key"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
rootpath: "/greengrass/v2"
thingName: "MyGreengrassCore"
services:
aws.greengrass.Nucleus:
componentType: "NUCLEUS"
version: "2.16.1"
configuration:
awsRegion: "us-west-2"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
```
次に、以下の操作を実行します。
+ `/greengrass/v2` の各インスタンスを Greengrass のルートフォルダに置き換えます。
+ *MyGreengrassCore* を AWS IoT モノの名前に置き換えます。
+ *2.16.1* を AWS IoT Greengrass Core ソフトウェアのバージョンに置き換えます。
+ *us-west-2* を、リソースを作成した AWS リージョン に置き換えます。
+ *GreengrassCoreTokenExchangeRoleAlias* をトークン交換ロールエイリアスの名前に置き換えます。
+ を AWS IoT データエンドポイント`iotDataEndpoint`に置き換えます。
+ を AWS IoT 認証情報エンドポイント`iotCredEndpoint`に置き換えます。
**注記**
この設定ファイルでは、使用するポートやネットワークプロキシなど、次の例で示すように、他の nucleus の設定オプションをカスタマイズできます。詳細については、[Greengrass nucleus 設定](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration)を参照してください。
```
---
system:
certificateFilePath: "/greengrass/v2/device.pem.crt"
privateKeyPath: "/greengrass/v2/private.pem.key"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
rootpath: "/greengrass/v2"
thingName: "MyGreengrassCore"
services:
aws.greengrass.Nucleus:
componentType: "NUCLEUS"
version: "2.16.1"
configuration:
awsRegion: "us-west-2"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
iotCredEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
mqtt:
port: 443
greengrassDataPlanePort: 443
networkProxy:
noProxyAddresses: "http://192.168.0.1,www.example.com"
proxy:
url: "https://my-proxy-server:1100"
username: "Mary_Major"
password: "pass@word1357"
```
1. インストーラを実行して、設定ファイルを提供するように、`--init-config` に対して指定します。
+ `/greengrass/v2` または *C:\$1greengrass\$1v2* を Greengrass ルートフォルダに置き換えます。
+ *GreengrassInstaller* の各インスタンスをインストーラを解凍したフォルダに置き換えます。
------
#### [ Linux or Unix ]
```
sudo -E java -Droot="/greengrass/v2" -Dlog.store=FILE \
-jar ./GreengrassInstaller/lib/Greengrass.jar \
--init-config ./GreengrassInstaller/config.yaml \
--component-default-user ggc_user:ggc_group \
--setup-system-service true
```
------
#### [ Windows Command Prompt (CMD) ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" ^
-jar ./GreengrassInstaller/lib/Greengrass.jar ^
--init-config ./GreengrassInstaller/config.yaml ^
--component-default-user ggc_user ^
--setup-system-service true
```
------
#### [ PowerShell ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" `
-jar ./GreengrassInstaller/lib/Greengrass.jar `
--init-config ./GreengrassInstaller/config.yaml `
--component-default-user ggc_user `
--setup-system-service true
```
------
**重要**
Windows コアデバイスでは、 を指定`--setup-system-service true`して AWS IoT Greengrass Core ソフトウェアをシステムサービスとしてセットアップする必要があります。
`--setup-system-service true` を指定する場合、ソフトウェアをシステムサービスとしてセットアップして実行したら、インストーラは `Successfully set up Nucleus as a system service` を出力します。それ以外の場合、正常にソフトウェアがインストールされていれば、インストーラはメッセージを出力しません。
**注記**
`--provision true` 引数なしでインストーラを実行するとき、ローカル開発ツールをデプロイするために `deploy-dev-tools` 引数を使用できません。Greengrass CLI をデバイスに直接デプロイする方法の情報については、「[Greengrass コマンドラインインターフェイス](gg-cli.md)」を参照してください。
1. ルートフォルダのファイルを確認して、インストールを確認します。
------
#### [ Linux or Unix ]
```
ls /greengrass/v2
```
------
#### [ Windows Command Prompt (CMD) ]
```
dir C:\greengrass\v2
```
------
#### [ PowerShell ]
```
ls C:\greengrass\v2
```
------
インストールが正常に処理された場合、ルートフォルダには `config`、`packages`、`logs` などの複数のフォルダが含まれます。
### HSM にプライベートキーと証明書を使用して AWS IoT Greengrass Core ソフトウェアをインストールする
**注記**
この機能は、[Greengrass nucleus コンポーネントの](greengrass-nucleus-component.md) v2.5.3 以降で使用できます。現在、この機能は Windows AWS IoT Greengrass コアデバイスでサポートされていません。
**AWS IoT Greengrass Core ソフトウェアをインストールするには**
1. AWS IoT Greengrass Core ソフトウェアのバージョンを確認します。
+ *GreengrassInstaller* を、ソフトウェアが含まれるフォルダへのパスに置き換えます。
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
1. AWS IoT Greengrass Core ソフトウェアが HSM でプライベートキーと証明書を使用できるようにするには、 AWS IoT Greengrass Core ソフトウェアをインストールするときに [PKCS\$111 プロバイダーコンポーネント](pkcs11-provider-component.md)をインストールします。PKCS\$111 プロバイダコンポーネントは、インストール時に設定できるプラグインです。PKCS\$111 プロバイダコンポーネントの最新バージョンを次の場所からダウンロードできます。
+ [https://d2s8p88vqu9w66.cloudfront.net/releases/Pkcs11Provider/aws.greengrass.crypto.Pkcs11Provider-latest.jar](https://d2s8p88vqu9w66.cloudfront.net/releases/Pkcs11Provider/aws.greengrass.crypto.Pkcs11Provider-latest.jar)
PKCS\$111 プロバイダプラグインを `aws.greengrass.crypto.Pkcs11Provider.jar` という名前のファイルにダウンロードします。*GreengrassInstaller* を使用するフォルダに置き換えます。
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/Pkcs11Provider/aws.greengrass.crypto.Pkcs11Provider-latest.jar > GreengrassInstaller/aws.greengrass.crypto.Pkcs11Provider.jar
```
このソフトウェアをダウンロードすると、[Greengrass Core ソフトウェアのライセンス契約](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf)に同意したものと見なされます。
1. テキストエディタを使用し、`config.yaml` という名前の設定ファイルを作成してインストーラに提供します。
例えば、Linux ベースのシステムでは、次のコマンドを実行し、GNU nano を使用してファイルを作成できます。
```
nano GreengrassInstaller/config.yaml
```
次の YAML コンテンツをファイルにコピーします。この部分設定ファイルは、システムパラメータ、Greengrass nucleus パラメータ、PKCS\$111 プロバイダパラメータを指定します。
```
---
system:
certificateFilePath: "pkcs11:object=iotdevicekey;type=cert"
privateKeyPath: "pkcs11:object=iotdevicekey;type=private"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
rootpath: "/greengrass/v2"
thingName: "MyGreengrassCore"
services:
aws.greengrass.Nucleus:
componentType: "NUCLEUS"
version: "2.16.1"
configuration:
awsRegion: "us-west-2"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
aws.greengrass.crypto.Pkcs11Provider:
configuration:
name: "softhsm_pkcs11"
library: "/usr/local/Cellar/softhsm/2.6.1/lib/softhsm/libsofthsm2.so"
slot: 1
userPin: "1234"
```
次に、以下の操作を実行します。
+ PKCS\$111 URI の *iotdevicekey* の各インスタンスを、プライベートキーを作成して証明書をインポートしたオブジェクトラベルに置き換えます。
+ `/greengrass/v2` の各インスタンスを Greengrass のルートフォルダに置き換えます。
+ *MyGreengrassCore* を AWS IoT モノの名前に置き換えます。
+ *2.16.1* を AWS IoT Greengrass Core ソフトウェアのバージョンに置き換えます。
+ *us-west-2* を、リソースを作成した AWS リージョン に置き換えます。
+ *GreengrassCoreTokenExchangeRoleAlias* をトークン交換ロールエイリアスの名前に置き換えます。
+ を AWS IoT データエンドポイント`iotDataEndpoint`に置き換えます。
+ を AWS IoT 認証情報エンドポイント`iotCredEndpoint`に置き換えます。
+ `aws.greengrass.crypto.Pkcs11Provider` コンポーネントの設定パラメータを、コアデバイスの HSM 設定の値に置き換えます。
**注記**
この設定ファイルでは、使用するポートやネットワークプロキシなど、次の例で示すように、他の nucleus の設定オプションをカスタマイズできます。詳細については、[Greengrass nucleus 設定](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration)を参照してください。
```
---
system:
certificateFilePath: "pkcs11:object=iotdevicekey;type=cert"
privateKeyPath: "pkcs11:object=iotdevicekey;type=private"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
rootpath: "/greengrass/v2"
thingName: "MyGreengrassCore"
services:
aws.greengrass.Nucleus:
componentType: "NUCLEUS"
version: "2.16.1"
configuration:
awsRegion: "us-west-2"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
mqtt:
port: 443
greengrassDataPlanePort: 443
networkProxy:
noProxyAddresses: "http://192.168.0.1,www.example.com"
proxy:
url: "https://my-proxy-server:1100"
username: "Mary_Major"
password: "pass@word1357"
aws.greengrass.crypto.Pkcs11Provider:
configuration:
name: "softhsm_pkcs11"
library: "/usr/local/Cellar/softhsm/2.6.1/lib/softhsm/libsofthsm2.so"
slot: 1
userPin: "1234"
```
1. インストーラを実行して、設定ファイルを提供するように、`--init-config` に対して指定します。
+ `/greengrass/v2` を Greengrass のルートフォルダに置き換えます。
+ *GreengrassInstaller* の各インスタンスをインストーラを解凍したフォルダに置き換えます。
```
sudo -E java -Droot="/greengrass/v2" -Dlog.store=FILE \
-jar ./GreengrassInstaller/lib/Greengrass.jar \
--trusted-plugin ./GreengrassInstaller/aws.greengrass.crypto.Pkcs11Provider.jar \
--init-config ./GreengrassInstaller/config.yaml \
--component-default-user ggc_user:ggc_group \
--setup-system-service true
```
**重要**
Windows コアデバイスでは、 を指定`--setup-system-service true`して AWS IoT Greengrass Core ソフトウェアをシステムサービスとしてセットアップする必要があります。
`--setup-system-service true` を指定する場合、ソフトウェアをシステムサービスとしてセットアップして実行したら、インストーラは `Successfully set up Nucleus as a system service` を出力します。それ以外の場合、正常にソフトウェアがインストールされていれば、インストーラはメッセージを出力しません。
**注記**
`--provision true` 引数なしでインストーラを実行するとき、ローカル開発ツールをデプロイするために `deploy-dev-tools` 引数を使用できません。Greengrass CLI をデバイスに直接デプロイする方法の情報については、「[Greengrass コマンドラインインターフェイス](gg-cli.md)」を参照してください。
1. ルートフォルダのファイルを確認して、インストールを確認します。
------
#### [ Linux or Unix ]
```
ls /greengrass/v2
```
------
#### [ Windows Command Prompt (CMD) ]
```
dir C:\greengrass\v2
```
------
#### [ PowerShell ]
```
ls C:\greengrass\v2
```
------
インストールが正常に処理された場合、ルートフォルダには `config`、`packages`、`logs` などの複数のフォルダが含まれます。
AWS IoT Greengrass Core ソフトウェアをシステムサービスとしてインストールした場合、インストーラはソフトウェアを実行します。それ以外の場合、ソフトウェアを手動で実行する必要があります。詳細については、「[AWS IoT Greengrass Core ソフトウェアを実行する](run-greengrass-core-v2.md)」を参照してください。
**注記**
AWS IoT Greengrass Core ソフトウェアがクラウドに接続すると、デバイスは Core デバイスとして認識されます。
ソフトウェアと を設定して使用する方法の詳細については AWS IoT Greengrass、以下を参照してください。
+ [AWS IoT Greengrass Core ソフトウェアを設定する](configure-greengrass-core-v2.md)
+ [AWS IoT Greengrass コンポーネントを開発する](develop-greengrass-components.md)
+ [AWS IoT Greengrass コンポーネントをデバイスにデプロイする](manage-deployments.md)
+ [Greengrass コマンドラインインターフェイス](gg-cli.md)
# AWS IoT フリートプロビジョニングを使用して AWS IoT Greengrass Core ソフトウェアをインストールする
この機能は、[Greengrass nucleus コンポーネント](greengrass-nucleus-component.md)の v2.4.0 以降に利用できます。
AWS IoT フリートプロビジョニングを使用すると、初めて に接続するときに、X.509 デバイス証明書とプライベートキーを生成してデバイスに安全に配信 AWS IoT するように を設定できます AWS IoT 。 は、Amazon ルート認証局 (CA) によって署名されたクライアント証明書 AWS IoT を提供します。フリートプロビジョニングでプロビジョニングする Greengrass コアデバイスのモノのグループ、モノのタイプ、アクセス許可を指定する AWS IoT ように を設定することもできます。*プロビジョニングテンプレート*を定義して、 が各デバイスを AWS IoT プロビジョニングする方法を定義します。プロビジョニングテンプレートは、プロビジョニング時にデバイス用に作成するもの、ポリシー、および証明書リソースを指定します。詳細については、「AWS IoT Core デベロッパーガイド」の「[プロビジョニングテンプレート](https://docs.aws.amazon.com/iot/latest/developerguide/provision-template.html)」を参照してください。
AWS IoT Greengrass には、 AWS IoT フリートプロビジョニングによって作成された AWS リソースを使用して AWS IoT Greengrass Core ソフトウェアをインストールするために使用できる AWS IoT フリートプロビジョニングプラグインが用意されています。フリートプロビジョニングプラグインはクレームによるプロビジョニングを使用します。デバイスは、プロビジョニングクレーム証明書とプライベートキーを使用して、通常の操作に使用できる一意の X.509 デバイス証明書とプライベートキーを取得します。製造中に各デバイスにクレーム証明書とシークレットキーを埋め込むことができるので、お客様は後で各デバイスがオンラインになったときにデバイスをアクティブにできます。複数のデバイスに対して同じクレーム証明書とプライベートキーを使用することができます。詳細については、「AWS IoT Core デベロッパーガイド」の「[クレームによるプロビジョニング](https://docs.aws.amazon.com/iot/latest/developerguide/provision-wo-cert.html#claim-based)」を参照してください。
**注記**
フリートプロビジョニングプラグインは、現在、ハードウェアセキュリティモジュール (HSM) へのプライベートキーと証明書ファイルの保存をサポートしていません。HSM を使用するには、[手動プロビジョニングで AWS IoT Greengrass Core ソフトウェアをインストールします](manual-installation.md)。
AWS IoT フリートプロビジョニングを使用して AWS IoT Greengrass Core ソフトウェアをインストールするには、 AWS アカウント が Greengrass コアデバイスのプロビジョニング AWS IoT に使用するリソースを にセットアップする必要があります。これらのリソースには、プロビジョニングテンプレート、クレーム証明書、および[トークン交換 IAM ロール](device-service-role.md)が含まれます。これらのリソースを作成した後、これらのリソースを再利用して、フリート内の複数のコアデバイスをプロビジョニングできます。詳細については、「[Greengrass コアデバイスの AWS IoT フリートプロビジョニングを設定する](fleet-provisioning-setup.md)」を参照してください。
**重要**
AWS IoT Greengrass Core ソフトウェアをダウンロードする前に、コアデバイスが AWS IoT Greengrass Core ソフトウェア v2.0 をインストールして実行する[要件を満た](greengrass-nucleus-component.md#greengrass-v2-requirements)していることを確認してください。
**Topics**
+ [前提条件](#fleet-provisioning-prerequisites)
+ [AWS IoT エンドポイントを取得する](#retrieve-iot-endpoints)
+ [デバイスに証明書をダウンロードする](#download-claim-certificates)
+ [デバイス環境をセットアップする](#set-up-device-environment)
+ [AWS IoT Greengrass Core ソフトウェアをダウンロードする](#download-greengrass-core-v2)
+ [AWS IoT フリートプロビジョニングプラグインをダウンロードする](#download-fleet-provisioning-plugin)
+ [AWS IoT Greengrass Core ソフトウェアをインストールする](#run-greengrass-core-v2-installer-fleet)
+ [Greengrass コアデバイスの AWS IoT フリートプロビジョニングを設定する](fleet-provisioning-setup.md)
+ [AWS IoT フリートプロビジョニングプラグインを設定する](fleet-provisioning-configuration.md)
+ [AWS IoT フリートプロビジョニングプラグインの変更ログ](fleet-provisioning-changelog.md)
## 前提条件
AWS IoT フリートプロビジョニングを使用して AWS IoT Greengrass Core ソフトウェアをインストールするには、まず [Greengrass コアデバイスの AWS IoT フリートプロビジョニングを設定](fleet-provisioning-setup.md)する必要があります。これらのステップを 1 回完了すると、フリートプロビジョニングを使用して AWS IoT Greengrass Core ソフトウェアを任意の数のデバイスにインストールできます。
## AWS IoT エンドポイントを取得する
の AWS IoT エンドポイントを取得し AWS アカウント、後で使用するために保存します。デバイスはこれらのエンドポイントを使用して AWS IoTに接続します。以下の操作を実行します。
1. AWS IoT のデータエンドポイントを取得します AWS アカウント。
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS
```
要求が正常に処理された場合、レスポンスは次の例のようになります。
```
{
"endpointAddress": "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
}
```
1. の AWS IoT 認証情報エンドポイントを取得します AWS アカウント。
```
aws iot describe-endpoint --endpoint-type iot:CredentialProvider
```
要求が正常に処理された場合、レスポンスは次の例のようになります。
```
{
"endpointAddress": "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
}
```
## デバイスに証明書をダウンロードする
デバイスは、クレーム証明書とプライベートキーを使用して、 AWS リソースをプロビジョニングし、X.509 デバイス証明書を取得するリクエストを認証します。クレーム証明書とプライベートキーは製造時にデバイスに埋め込むか、 インストール時に証明書とキーをデバイスにコピーすることができます。このセクションでは、クレーム証明書とプライベートキーをデバイスにコピーします。また、デバイスに Amazon ルート認証局 (CA) 証明書もダウンロードします。
**重要**
プロビジョニングクレームプライベートキーは、Greengrass コアデバイス上にある場合を含め、常に保護する必要があります。Amazon CloudWatch メトリクスとログを使用して、デバイスをプロビジョニングするクレーム証明書の不正使用などの悪用の兆候がないか監視することをお勧めします。悪用を検出した場合は、プロビジョニングクレーム証明書を無効にして、デバイスのプロビジョニングに使用できないようにします。詳細については、「AWS IoT Core デベロッパーガイド」の「[AWS IoTのモニタリング](https://docs.aws.amazon.com/iot/latest/developerguide/monitoring_overview.html)」を参照してください。**
に登録するデバイスの数とデバイスをより適切に管理できるように AWS アカウント、フリートプロビジョニングテンプレートを作成するときに事前プロビジョニングフックを指定できます。事前プロビジョニングフックは、デバイスが登録時に提供するテンプレートパラメータを検証する AWS Lambda 関数です。例えば、デバイス ID をデータベースと照合して、デバイスにプロビジョニングする権限があることを確認する事前プロビジョニングフックを作成することができます。詳細については、「*AWS IoT Core デベロッパーガイド*」の「[Pre-provisioning hooks](https://docs.aws.amazon.com/iot/latest/developerguide/pre-provisioning-hook.html)」を参照してください。
**デバイスにクレーム証明書をダウンロードする**
1. クレーム証明書とプライベートキーをデバイスにコピーします。開発用コンピュータとデバイスで SSH と SCP が有効になっている場合、開発用コンピュータで `scp` コマンドを使用してクレーム証明書とプライベートキーを転送できます。次のコマンド例では、これらのファイルを開発用コンピュータ上の `claim-certs` という名のフォルダからデバイスに転送します。*device-ip-address* をデバイスの IP アドレスに置き換えます。
```
scp -r claim-certs/ device-ip-address:~
```
1. デバイスに Greengrass ルートフォルダを作成します。後で AWS IoT Greengrass Core ソフトウェアをこのフォルダにインストールします。
**注記**
Windows では、パスの長さは 260 文字に制限されています。Windows を使用している場合は、`C:\greengrass\v2` や `D:\greengrass\v2` などのルートフォルダを使用して、Greengrass コンポーネントのパスを 260 文字の制限内に留めます。
------
#### [ Linux or Unix ]
+ `/greengrass/v2` を使用するフォルダに置き換えます。
```
sudo mkdir -p /greengrass/v2
```
------
#### [ Windows Command Prompt ]
+ *C:\$1greengrass\$1v2* を使用するフォルダに置き換えます。
```
mkdir C:\greengrass\v2
```
------
#### [ PowerShell ]
+ *C:\$1greengrass\$1v2* を使用するフォルダに置き換えます。
```
mkdir C:\greengrass\v2
```
------
1. (Linux のみ) Greengrass ルートフォルダの親の許可を設定します。
+ */greengrass* をルートフォルダへの親に置き換えます。
```
sudo chmod 755 /greengrass
```
1. クレーム証明書を Greengrass ルートフォルダに移動します。
+ `/greengrass/v2` または *C:\$1greengrass\$1v2* を Greengrass ルートフォルダに置き換えます。
------
#### [ Linux or Unix ]
```
sudo mv ~/claim-certs /greengrass/v2
```
------
#### [ Windows Command Prompt (CMD) ]
```
move %USERPROFILE%\claim-certs C:\greengrass\v2
```
------
#### [ PowerShell ]
```
mv -Path ~\claim-certs -Destination C:\greengrass\v2
```
------
1. Amazon ルート認証局 (CA) 証明書をダウンロードします。 AWS IoT 証明書は、デフォルトで Amazon のルート CA 証明書に関連付けられています。
------
#### [ Linux or Unix ]
```
sudo curl -o /greengrass/v2/AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -o C:\greengrass\v2\\AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ PowerShell ]
```
iwr -Uri https://www.amazontrust.com/repository/AmazonRootCA1.pem -OutFile C:\greengrass\v2\\AmazonRootCA1.pem
```
------
## デバイス環境をセットアップする
このセクションのステップに従って、 AWS IoT Greengrass コアデバイスとして使用する Linux または Windows デバイスをセットアップします。
### Linux デバイスをセットアップする
**の Linux デバイスを設定するには AWS IoT Greengrass V2**
1. AWS IoT Greengrass Core ソフトウェアが実行する必要がある Java ランタイムをインストールします。[Amazon Corretto](https://aws.amazon.com/corretto/) または [OpenJDK](https://openjdk.java.net/) の長期サポートバージョンを使用することをお勧めします。バージョン 8 以降が必要です。次のコマンドは、デバイスに OpenJDK をインストールする方法を示しています。
+ Debian ベースまたは Ubuntu ベースのディストリビューションの場合:
```
sudo apt install default-jdk
```
+ Red Hat ベースのディストリビューションの場合:
```
sudo yum install java-11-openjdk-devel
```
+ 複数 Amazon Linux 2:
```
sudo amazon-linux-extras install java-openjdk11
```
+ 複数 Amazon Linux 2023:
```
sudo dnf install java-11-amazon-corretto -y
```
インストールが完了したら、次のコマンドを実行して Java が Linux デバイスで実行されていることを確認します。
```
java -version
```
このコマンドは、デバイス上で実行されている Java のバージョンを出力します。例えば、Debian ベースのディストリビューションでは、出力は次のサンプルのようになります。
```
openjdk version "11.0.9.1" 2020-11-04
OpenJDK Runtime Environment (build 11.0.9.1+1-post-Debian-1deb10u2)
OpenJDK 64-Bit Server VM (build 11.0.9.1+1-post-Debian-1deb10u2, mixed mode)
```
1. (オプション) デバイスにコンポーネントを実行するデフォルトのシステムユーザーおよびグループを作成します。`--component-default-user` インストーラ引数を使用して、インストール中に AWS IoT Greengrass Core ソフトウェアインストーラにこのユーザーとグループを作成させることもできます。詳細については、「[インストーラ引数](configure-installer.md)」を参照してください。
```
sudo useradd --system --create-home ggc_user
sudo groupadd --system ggc_group
```
1. AWS IoT Greengrass Core ソフトウェアを実行するユーザー (通常は `root`) に、任意のユーザーと任意のグループ`sudo`で を実行するアクセス許可があることを確認します。
1. `/etc/sudoers` ファイルを開くには、次のコマンドを実行します。
```
sudo visudo
```
1. ユーザーの権限が次の例のようになっていることを確認します。
```
root ALL=(ALL:ALL) ALL
```
1. (オプション) [コンテナ化された Lambda 関数を実行](run-lambda-functions.md)するには、[cgroups](https://en.wikipedia.org/wiki/Cgroups) v1 を有効にし、*メモリ*と*デバイス*の cgroups を有効にしてマウントする必要があります。コンテナ化された Lambda 関数を実行する予定がない場合、この手順を省略できます。
これらの cgroups オプションを有効にするには、次の Linux カーネルパラメータを使用してデバイスを起動します。
```
cgroup_enable=memory cgroup_memory=1 systemd.unified_cgroup_hierarchy=0
```
デバイスのカーネルパラメータを確認および設定するための情報については、オペレーティングシステムおよびブートローダーのドキュメントを参照してください。指示に従って、カーネルパラメータを永続的に設定します。
1. [デバイスの要件](greengrass-nucleus-component.md#greengrass-v2-requirements) にある要件リストで示されているように、その他の必要となる依存関係をすべてデバイスにインストールします。
### Windows デバイスをセットアップする
**注記**
この機能は、[Greengrass nucleus コンポーネント](greengrass-nucleus-component.md)の v2.5.0 以降に利用できます。
**の Windows デバイスを設定するには AWS IoT Greengrass V2**
1. AWS IoT Greengrass Core ソフトウェアが実行する必要がある Java ランタイムをインストールします。[Amazon Corretto](https://aws.amazon.com/corretto/) または [OpenJDK](https://openjdk.java.net/) の長期サポートバージョンを使用することをお勧めします。バージョン 8 以降が必要です。
1. [PATH](https://en.wikipedia.org/wiki/PATH_(variable)) システム変数で Java が使用可能か確認し、そうでない場合は追加します。LocalSystem アカウントは AWS IoT Greengrass Core ソフトウェアを実行するため、ユーザーの PATH ユーザー変数ではなく PATH システム変数に Java を追加する必要があります。以下の操作を実行します。
1. Windows キーを押してスタートメニューを開きます。
1. **environment variables** を入力して、スタートメニューからシステムオプションを検索します。
1. スタートメニューの検索結果から **[Edit the system environment variables]** (システム環境変数を編集) をクリックして、**[System properties]** (システムプロパティ) ウィンドウを開きます。
1. **[Environment variables...]** (環境変数...) を選択して、**[Environment Variables]** (環境可変) ウィンドウを開きます。
1. **[System variables]** (システム変数) で、**[Path]** (パス) 、**[Edit]** (編集) の順に選択します。**[Edit environment variable]** (環境変数の編集) ウィンドウでは、個別の行に各パスを表示できます。
1. Java インストールの `bin` フォルダへのパスが存在しているかを確認します。このパスは、次の例のように表示されます。
```
C:\\Program Files\\Amazon Corretto\\jdk11.0.13_8\\bin
```
1. **[Path]** (パス) で Java インストールの `bin` フォルダが で見つからない場合は、**[New]** (新規) を選択してこれを追加した上で、**[OK]** を選択します。
1. 管理者として Windows コマンドプロンプト `cmd.exe` を開きます。
1. Windows デバイスの LocalSystem アカウントにデフォルトユーザーを作成します。*パスワード*を安全なパスワードに置き換えます。
```
net user /add ggc_user password
```
**ヒント**
Windows の構成によっては、ユーザーのパスワードの期限切れが、将来の日付に設定されている場合があります。Greengrass アプリケーションの動作を継続させるためには、パスワードの有効期限を追跡し、その期限が切れる前に更新します。ユーザーのパスワードには、期限切れを起こさないような設定も可能です。
ユーザーとパスワードの有効期限を確認するには、次のコマンドを実行します。
```
net user ggc_user | findstr /C:expires
```
ユーザーのパスワードが期限切れにならないように設定するには、次のコマンドを実行します。
```
wmic UserAccount where "Name='ggc_user'" set PasswordExpires=False
```
[`wmic` コマンドが廃止されている](https://learn.microsoft.com/en-us/windows/win32/wmisdk/wmic) Windows 10 以降を使用している場合は、次の PowerShell コマンドを実行します。
```
Get-CimInstance -Query "SELECT * from Win32_UserAccount WHERE name = 'ggc_user'" | Set-CimInstance -Property @{PasswordExpires="False"}
```
1. [PsExec ユーティリティ](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec)を Microsoft からダウンロードしてデバイスにインストールします。
1. PsExec ユーティリティを使用して、デフォルトユーザーのユーザー名とパスワードを LocalSystem アカウントの認証情報マネージャーインスタンスに格納します。*パスワード*を以前に設定したユーザーのパスワードに置き換えます。
```
psexec -s cmd /c cmdkey /generic:ggc_user /user:ggc_user /pass:password
```
**PsExec License Agreement** が開いたら、**Accept** を選択し、ライセンスに同意してコマンドを実行します。
**注記**
Windows デバイスでは、LocalSystem アカウントによって Greengrass nucleus が実行され、PsExec ユーティリティを使用して LocalSystem アカウントにデフォルトのユーザー情報を保存する必要があります。認証情報マネージャーアプリケーションを使用すると、この情報は LocalSystem アカウントではなく、現在ログオンしているユーザーの Windows アカウントに保存されます。
## AWS IoT Greengrass Core ソフトウェアをダウンロードする
AWS IoT Greengrass Core ソフトウェアの最新バージョンは、次の場所からダウンロードできます。
+ [https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip](https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip)
**注記**
AWS IoT Greengrass Core ソフトウェアの特定のバージョンは、次の場所からダウンロードできます。*バージョン*をダウンロードするバージョンに置き換えます。
```
https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-version.zip
```
**AWS IoT Greengrass Core ソフトウェアをダウンロードするには**
1. コアデバイスで、 AWS IoT Greengrass Core ソフトウェアを という名前のファイルにダウンロードします`greengrass-nucleus-latest.zip`。
------
#### [ Linux or Unix ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
iwr -Uri https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip -OutFile greengrass-nucleus-latest.zip
```
------
このソフトウェアをダウンロードすると、[Greengrass Core ソフトウェアのライセンス契約](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf)に同意したものと見なされます。
1. (オプション) Greengrass nucleus ソフトウェア署名を確認するには
**注記**
この機能は、Greengrass nucleus バージョン 2.9.5 以降で使用できます。
1. 以下のコマンドを使用して、Greengrass nucleus アーティファクトの署名を確認します。
------
#### [ Linux or Unix ]
```
jarsigner -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
インストールする JDK のバージョンによって、ファイル名が異なる場合があります。インストールした JDK のバージョンに *`jdk17.0.6_10`* を置き換えてください。
```
"C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe" -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
インストールする JDK のバージョンによって、ファイル名が異なる場合があります。インストールした JDK のバージョンに *`jdk17.0.6_10`* を置き換えてください。
```
'C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe' -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
1. `jarsigner` が起動すると、検証結果を示す出力が得られます。
1. Greengrass nucleus の zip ファイルに署名されると、出力に以下のような文が表示されます：
```
jar verified.
```
1. Greengrass nucleus の zip ファイルに署名されないと、出力に以下のような文が表示されます：
```
jar is unsigned.
```
1. Jarsigner `-certs` を `-verify` と`-verbose` オプションと一緒に提供した場合、出力には署名者証明書の詳細情報も含まれます。
1. AWS IoT Greengrass Core ソフトウェアをデバイスのフォルダに解凍します。*GreengrassInstaller* を使用するフォルダに置き換えます。
------
#### [ Linux or Unix ]
```
unzip greengrass-nucleus-latest.zip -d GreengrassInstaller && rm greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
mkdir GreengrassInstaller && tar -xf greengrass-nucleus-latest.zip -C GreengrassInstaller && del greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
Expand-Archive -Path greengrass-nucleus-latest.zip -DestinationPath .\\GreengrassInstaller
rm greengrass-nucleus-latest.zip
```
------
1. (オプション) 次のコマンドを実行して、 AWS IoT Greengrass Core ソフトウェアのバージョンを確認します。
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
**重要**
v2.4.0 より前のバージョンの Greengrass nucleus をインストールした場合は、 AWS IoT Greengrass Core ソフトウェアをインストールした後にこのフォルダを削除しないでください。 AWS IoT Greengrass Core ソフトウェアは、このフォルダ内のファイルを使用して実行します。
ソフトウェアの最新バージョンをダウンロードした場合は、v2.4.0 以降をインストールし、 AWS IoT Greengrass Core ソフトウェアをインストールした後にこのフォルダを削除できます。
## AWS IoT フリートプロビジョニングプラグインをダウンロードする
フリー AWS IoT トプロビジョニングプラグインの最新バージョンは、次の場所からダウンロードできます。
+ [https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-latest.jar](https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-latest.jar)
**注記**
フリー AWS IoT トプロビジョニングプラグインの特定のバージョンは、次の場所からダウンロードできます。*バージョン*をダウンロードするバージョンに置き換えます。フリートプロビジョニングプラグインの各バージョンの詳細については、「[AWS IoT フリートプロビジョニングプラグインの変更ログ](fleet-provisioning-changelog.md)」を参照してください。
```
https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-version.jar
```
フリートプロビジョニングプラグインはオープンソースです。ソースコードを確認する場合は、GitHub 上の「[AWS IoT フリートプロビジョニングプラグイン](https://github.com/aws-greengrass/aws-greengrass-fleet-provisioning-by-claim)」を参照してください。
**AWS IoT フリートプロビジョニングプラグインをダウンロードするには**
+ デバイスで、 AWS IoT フリートプロビジョニングプラグインを という名前のファイルにダウンロードします`aws.greengrass.FleetProvisioningByClaim.jar`。*GreengrassInstaller* を使用するフォルダに置き換えます。
------
#### [ Linux or Unix ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-latest.jar > GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-latest.jar > GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar
```
------
#### [ PowerShell ]
```
iwr -Uri https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-latest.jar -OutFile GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar
```
------
このソフトウェアをダウンロードすると、[Greengrass Core ソフトウェアのライセンス契約](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf)に同意したものと見なされます。
## AWS IoT Greengrass Core ソフトウェアをインストールする
次のアクションを指定する引数を含むインストーラを実行します。
+ フリートプロビジョニングプラグインを使用して AWS リソースをプロビジョニングするように指定する部分的な設定ファイルから をインストールします。 AWS IoT Greengrass Core ソフトウェアは、デバイス上のすべての Greengrass コンポーネントの設定を指定する設定ファイルを使用します。インストーラは、提供される部分設定ファイルと、フリートプロビジョニングプラグインが作成する AWS リソースから、完全な設定ファイルを作成します。
+ コアデバイスでソフトウェアコンポーネントを実行するために `ggc_user` システムユーザーを使用するように指定します。Linux デバイスでは、このコマンドも `ggc_group` システムグループを使用するように指定し、さらにインストーラによってシステムユーザーとグループが、ユーザーに代わって作成されます。
+ Core AWS IoT Greengrass ソフトウェアを、起動時に実行されるシステムサービスとしてセットアップします。Linux デバイスでは、これは [Systemd](https://en.wikipedia.org/wiki/Systemd) init システムが必要です。
**重要**
Windows コアデバイスでは、 AWS IoT Greengrass Core ソフトウェアをシステムサービスとして設定する必要があります。
指定できる引数の詳細については、「[インストーラ引数](configure-installer.md)」を参照してください。
**注記**
メモリが制限された AWS IoT Greengrass デバイスで実行している場合は、 AWS IoT Greengrass Core ソフトウェアが使用するメモリ量を制御できます。メモリ割り当てを制御するには、nucleus コンポーネントの `jvmOptions` 設定パラメータで JVM ヒープのサイズオプションを設定できます。詳細については、「[JVM オプションでメモリ割り当てを制御する](configure-greengrass-core-v2.md#jvm-tuning)」を参照してください。
**AWS IoT Greengrass Core ソフトウェアをインストールするには**
1. AWS IoT Greengrass Core ソフトウェアのバージョンを確認します。
+ *GreengrassInstaller* を、ソフトウェアが含まれるフォルダへのパスに置き換えます。
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
1. テキストエディタを使用し、`config.yaml` という名前の設定ファイルを作成してインストーラに提供します。
例えば、Linux ベースのシステムでは、次のコマンドを実行し、GNU nano を使用してファイルを作成できます。
```
nano GreengrassInstaller/config.yaml
```
次の YAML コンテンツをファイルにコピーします。この部分設定ファイルは、フリートプロビジョニングプラグインのパラメータを指定します。指定できるオプションの詳細については、「[AWS IoT フリートプロビジョニングプラグインを設定する](fleet-provisioning-configuration.md)」を参照してください。
------
#### [ Linux or Unix ]
```
---
services:
aws.greengrass.Nucleus:
version: "2.16.1"
aws.greengrass.FleetProvisioningByClaim:
configuration:
rootPath: "/greengrass/v2"
awsRegion: "us-west-2"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredentialEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
provisioningTemplate: "GreengrassFleetProvisioningTemplate"
claimCertificatePath: "/greengrass/v2/claim-certs/claim.pem.crt"
claimCertificatePrivateKeyPath: "/greengrass/v2/claim-certs/claim.private.pem.key"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
templateParameters:
ThingName: "MyGreengrassCore"
ThingGroupName: "MyGreengrassCoreGroup"
```
------
#### [ Windows ]
```
---
services:
aws.greengrass.Nucleus:
version: "2.16.1"
aws.greengrass.FleetProvisioningByClaim:
configuration:
rootPath: "C:\\greengrass\\v2"
awsRegion: "us-west-2"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredentialEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
provisioningTemplate: "GreengrassFleetProvisioningTemplate"
claimCertificatePath: "C:\\greengrass\\v2\\claim-certs\\claim.pem.crt"
claimCertificatePrivateKeyPath: "C:\\greengrass\\v2\\claim-certs\\claim.private.pem.key"
rootCaPath: "C:\\greengrass\\v2\\AmazonRootCA1.pem"
templateParameters:
ThingName: "MyGreengrassCore"
ThingGroupName: "MyGreengrassCoreGroup"
```
------
次に、以下の操作を実行します。
+ *2.16.1* を AWS IoT Greengrass Core ソフトウェアのバージョンに置き換えます。
+ `/greengrass/v2` または *C:\$1greengrass\$1v2* の各インスタンスを Greengrass ルートフォルダに置き換えます。
**注記**
Windows デバイスでは、パスセパレータは二重バックスラッシュ (`\\`) で指定する必要があります (例: `C:\\greengrass\\v2`)。
+ *us-west-2* を、プロビジョニングテンプレートやその他のリソースを作成した AWS リージョンに置き換えます。
+ を AWS IoT データエンドポイント`iotDataEndpoint`に置き換えます。
+ を AWS IoT 認証情報エンドポイント`iotCredentialEndpoint`に置き換えます。
+ *GreengrassCoreTokenExchangeRoleAlias* をトークン交換ロールエイリアスの名前に置き換えます。
+ *GreengrassFleetProvisioningTemplate* を、フリートプロビジョニングテンプレートの名前に置き換えます。
+ `claimCertificatePath` をデバイス上のクレーム証明書へのパスに置き換えます。
+ `claimCertificatePrivateKeyPath` をデバイス上のクレーム証明書のプライベートキーへのパスに置き換えます。
+ テンプレートパラメータ (`templateParameters`) を、デバイスのプロビジョニングに使用する値に置き換えます。この例は、`ThingName` および `ThingGroupName` パラメータを定義する[テンプレート例](fleet-provisioning-setup.md#example-fleet-provisioning-template)を参照しています。
**注記**
この設定ファイルでは、使用するポートやネットワークプロキシなど、次の例で示すように、他の設定オプションをカスタマイズすることができます。詳細については、[Greengrass nucleus 設定](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration)を参照してください。
```
---
services:
aws.greengrass.Nucleus:
version: "2.16.1"
configuration:
mqtt:
port: 443
greengrassDataPlanePort: 443
networkProxy:
noProxyAddresses: "http://192.168.0.1,www.example.com"
proxy:
url: "http://my-proxy-server:1100"
username: "Mary_Major"
password: "pass@word1357"
aws.greengrass.FleetProvisioningByClaim:
configuration:
rootPath: "/greengrass/v2"
awsRegion: "us-west-2"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredentialEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
provisioningTemplate: "GreengrassFleetProvisioningTemplate"
claimCertificatePath: "/greengrass/v2/claim-certs/claim.pem.crt"
claimCertificatePrivateKeyPath: "/greengrass/v2/claim-certs/claim.private.pem.key"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
templateParameters:
ThingName: "MyGreengrassCore"
ThingGroupName: "MyGreengrassCoreGroup"
mqttPort: 443
proxyUrl: "http://my-proxy-server:1100"
proxyUserName: "Mary_Major"
proxyPassword: "pass@word1357"
```
```
---
services:
aws.greengrass.Nucleus:
version: "2.16.1"
configuration:
mqtt:
port: 443
greengrassDataPlanePort: 443
networkProxy:
noProxyAddresses: "http://192.168.0.1,www.example.com"
proxy:
url: "http://my-proxy-server:1100"
username: "Mary_Major"
password: "pass@word1357"
aws.greengrass.FleetProvisioningByClaim:
configuration:
rootPath: "C:\\greengrass\\v2"
awsRegion: "us-west-2"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredentialEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
provisioningTemplate: "GreengrassFleetProvisioningTemplate"
claimCertificatePath: "C:\\greengrass\\v2\\claim-certs\\claim.pem.crt"
claimCertificatePrivateKeyPath: "C:\\greengrass\\v2\\claim-certs\\claim.private.pem.key"
rootCaPath: "C:\\greengrass\\v2\\AmazonRootCA1.pem"
templateParameters:
ThingName: "MyGreengrassCore"
ThingGroupName: "MyGreengrassCoreGroup"
mqttPort: 443
proxyUrl: "http://my-proxy-server:1100"
proxyUserName: "Mary_Major"
proxyPassword: "pass@word1357"
```
HTTPS プロキシを使用するには、フリートプロビジョニングプラグインのバージョン 1.1.0 以降を使用する必要があります。次の例に示すように、さらに、`system` にある `rootCaPath` も指定する必要があります。
```
---
system:
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
services:
...
```
```
---
system:
rootCaPath: "C:\\greengrass\\v2\\AmazonRootCA1.pem"
services:
...
```
1. インストーラーを実行します。`--trusted-plugin` を指定してフリートプロビジョニングプラグインを提供し、`--init-config` を指定して設定ファイルを提供します。
+ `/greengrass/v2` を Greengrass のルートフォルダに置き換えます。
+ *GreengrassInstaller* の各インスタンスをインストーラを解凍したフォルダに置き換えます。
------
#### [ Linux or Unix ]
```
sudo -E java -Droot="/greengrass/v2" -Dlog.store=FILE \
-jar ./GreengrassInstaller/lib/Greengrass.jar \
--trusted-plugin ./GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar \
--init-config ./GreengrassInstaller/config.yaml \
--component-default-user ggc_user:ggc_group \
--setup-system-service true
```
------
#### [ Windows Command Prompt (CMD) ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" ^
-jar ./GreengrassInstaller/lib/Greengrass.jar ^
--trusted-plugin ./GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar ^
--init-config ./GreengrassInstaller/config.yaml ^
--component-default-user ggc_user ^
--setup-system-service true
```
------
#### [ PowerShell ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" `
-jar ./GreengrassInstaller/lib/Greengrass.jar `
--trusted-plugin ./GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar `
--init-config ./GreengrassInstaller/config.yaml `
--component-default-user ggc_user `
--setup-system-service true
```
------
**重要**
Windows コアデバイスでは、 を指定`--setup-system-service true`して AWS IoT Greengrass Core ソフトウェアをシステムサービスとしてセットアップする必要があります。
`--setup-system-service true` を指定する場合、ソフトウェアをシステムサービスとしてセットアップして実行したら、インストーラは `Successfully set up Nucleus as a system service` を出力します。それ以外の場合、正常にソフトウェアがインストールされていれば、インストーラはメッセージを出力しません。
**注記**
`--provision true` 引数なしでインストーラを実行するとき、ローカル開発ツールをデプロイするために `deploy-dev-tools` 引数を使用できません。Greengrass CLI をデバイスに直接デプロイする方法の情報については、「[Greengrass コマンドラインインターフェイス](gg-cli.md)」を参照してください。
1. ルートフォルダのファイルを確認して、インストールを確認します。
------
#### [ Linux or Unix ]
```
ls /greengrass/v2
```
------
#### [ Windows Command Prompt (CMD) ]
```
dir C:\greengrass\v2
```
------
#### [ PowerShell ]
```
ls C:\greengrass\v2
```
------
インストールが正常に処理された場合、ルートフォルダには `config`、`packages`、`logs` などの複数のフォルダが含まれます。
AWS IoT Greengrass Core ソフトウェアをシステムサービスとしてインストールした場合、インストーラはソフトウェアを実行します。それ以外の場合、ソフトウェアを手動で実行する必要があります。詳細については、「[AWS IoT Greengrass Core ソフトウェアを実行する](run-greengrass-core-v2.md)」を参照してください。
ソフトウェアと を設定および使用する方法の詳細については AWS IoT Greengrass、以下を参照してください。
+ [AWS IoT Greengrass Core ソフトウェアを設定する](configure-greengrass-core-v2.md)
+ [AWS IoT Greengrass コンポーネントを開発する](develop-greengrass-components.md)
+ [AWS IoT Greengrass コンポーネントをデバイスにデプロイする](manage-deployments.md)
+ [Greengrass コマンドラインインターフェイス](gg-cli.md)
# Greengrass コアデバイスの AWS IoT フリートプロビジョニングを設定する
[フリートプロビジョニングを使用して AWS IoT Greengrass Core ソフトウェアをインストールする](fleet-provisioning.md)には、まず で次のリソースを設定する必要があります AWS アカウント。これらのリソースにより、デバイスは に登録 AWS IoT され、Greengrass コアデバイスとして動作できます。このセクションの手順を一度実行して、これらのリソースを AWS アカウントで設定してください。
+ トークン交換 IAM ロールは、コアデバイスが AWS サービスへの呼び出しを認可するために使用します。
+ トークン交換 AWS IoT ロールを指すロールエイリアス。
+ (オプション) コアデバイスが AWS IoT および AWS IoT Greengrass サービスへの呼び出しを承認するために使用する AWS IoT ポリシー。この AWS IoT ポリシーは、トークン交換 AWS IoT ロールを指すロールエイリアスの`iot:AssumeRoleWithCertificate`アクセス許可を許可する必要があります。
フリート内のすべてのコアデバイスに 1 つの AWS IoT ポリシーを使用することも、各コアデバイスに AWS IoT ポリシーを作成するようにフリートプロビジョニングテンプレートを設定することもできます。
+ AWS IoT フリートプロビジョニングテンプレート。このテンプレートでは、以下を指定する必要があります。
+ AWS IoT モノのリソース。既存のモノのグループのリストを指定して、オンラインになったときに各デバイスにコンポーネントをデプロイできます。
+ AWS IoT ポリシーリソース。このリソースは、次のいずれかのプロパティを定義できます。
+ 既存の AWS IoT ポリシーの名前。このオプションを選択すると、このテンプレートから作成したコアデバイスは同じ AWS IoT ポリシーを使用し、フリートとしてアクセス許可を管理できます。
+ AWS IoT ポリシードキュメント。このオプションを選択すると、このテンプレートから作成する各コアデバイスは一意の AWS IoT ポリシーを使用し、個々のコアデバイスのアクセス許可を管理できます。
+ AWS IoT 証明書リソース。この証明書リソースでは、`AWS::IoT::Certificate::Id` パラメータを使用して、証明書をコアデバイスにアタッチする必要があります。詳細については、「AWS IoT デベロッパーガイド」の「[ジャストインタイムプロビジョニング](https://docs.aws.amazon.com/iot/latest/developerguide/jit-provisioning.html)」を参照してください。
+ フリート AWS IoT プロビジョニングテンプレートのプロビジョニングクレーム証明書とプライベートキー。製造中にこの証明書とプライベートキーをデバイスに埋め込むことができます。埋め込むと、デバイスはオンライン状態になったときにデバイスを登録してプロビジョニングすることができます。
**重要**
プロビジョニングクレームプライベートキーは、Greengrass コアデバイス上にある場合を含め、常に保護する必要があります。Amazon CloudWatch メトリクスとログを使用して、デバイスをプロビジョニングするクレーム証明書の不正使用などの悪用の兆候がないか監視することをお勧めします。悪用を検出した場合は、プロビジョニングクレーム証明書を無効にして、デバイスのプロビジョニングに使用できないようにします。詳細については、「AWS IoT Core デベロッパーガイド」の「[AWS IoTのモニタリング](https://docs.aws.amazon.com/iot/latest/developerguide/monitoring_overview.html)」を参照してください。**
に登録するデバイスの数とデバイスをより適切に管理できるように AWS アカウント、フリートプロビジョニングテンプレートを作成するときに事前プロビジョニングフックを指定できます。事前プロビジョニングフックは、デバイスが登録時に提供するテンプレートパラメータを検証する AWS Lambda 関数です。例えば、デバイス ID をデータベースと照合して、デバイスにプロビジョニングする権限があることを確認する事前プロビジョニングフックを作成することができます。詳細については、「*AWS IoT Core デベロッパーガイド*」の「[Pre-provisioning hooks](https://docs.aws.amazon.com/iot/latest/developerguide/pre-provisioning-hook.html)」を参照してください。
+ デバイスがフリートプロビジョニングテンプレートを登録して使用できるように、プロビジョニングクレーム証明書にアタッチする AWS IoT ポリシー。
**Topics**
+ [トークン交換ロールを作成する](#create-token-exchange-role)
+ [AWS IoT ポリシーを作成する](#create-iot-policy)
+ [フリートプロビジョニングテンプレートを作成する](#create-provisioning-template)
+ [プロビジョニングクレーム証明書とプライベートキーを作成する](#create-claim-certificates)
## トークン交換ロールを作成する
Greengrass コアデバイスは、*トークン交換ロールと呼ばれる IAM サービスロール*を使用して、 AWS サービスへの呼び出しを承認します。デバイスは認証情報 AWS IoT プロバイダーを使用して、このロールの一時的な AWS 認証情報を取得します。これにより、デバイスは Amazon CloudWatch Logs とやり取りしたり AWS IoT、Amazon CloudWatch Logs にログを送信したり、Amazon S3 からカスタムコンポーネントアーティファクトをダウンロードしたりできます。 Amazon CloudWatch 詳細については、「[コアデバイスが AWS サービスとやり取りできるように認可する](device-service-role.md)」を参照してください。
AWS IoT *ロールエイリアス*を使用して、Greengrass コアデバイスのトークン交換ロールを設定します。ロールエイリアスは、デバイスのトークン交換ロールを変更できるようにしますが、デバイス設定は同じ内容に保たれます。詳細については、「*AWS IoT Core デベロッパーガイド*」の「[Authorizing direct calls to AWS services](https://docs.aws.amazon.com/iot/latest/developerguide/authorizing-direct-aws.html)」を参照してください。
このセクションでは、トークン交換 IAM ロールと AWS IoT 、ロールを指すロールエイリアスを作成します。Greengrass コアデバイスを既に設定している場合、新しく作成せず、トークン交換ロールとロールエイリアスを使用できます。
**トークン交換 IAM ロールを作成するには**
1. デバイスがトークン交換ロールとして使用できる IAM ロールを作成します。以下の操作を実行します。
1. トークン交換ロールが必要とする、信頼できるポリシードキュメントが含まれるファイルを作成します。
例えば、Linux ベースのシステムでは、次のコマンドを実行し、GNU nano を使用してファイルを作成できます。
```
nano device-role-trust-policy.json
```
次の JSON をファイルにコピーします。
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
1. 信頼ポリシードキュメントでトークン交換ロールを作成します。
+ *GreengrassV2TokenExchangeRole* を、作成する IAM ロールの名前に置き換えます。
```
aws iam create-role --role-name GreengrassV2TokenExchangeRole --assume-role-policy-document file://device-role-trust-policy.json
```
要求が正常に処理された場合、レスポンスは次の例のようになります。
```
{
"Role": {
"Path": "/",
"RoleName": "GreengrassV2TokenExchangeRole",
"RoleId": "AROAZ2YMUHYHK5OKM77FB",
"Arn": "arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole",
"CreateDate": "2021-02-06T00:13:29+00:00",
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
}
```
1. トークン交換ロールが必要なアクセスポリシードキュメントを含むファイルを作成します。
例えば、Linux ベースのシステムでは、次のコマンドを実行し、GNU nano を使用してファイルを作成できます。
```
nano device-role-access-policy.json
```
次の JSON をファイルにコピーします。
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents",
"logs:DescribeLogStreams",
"s3:GetBucketLocation"
],
"Resource": "*"
}
]
}
```
**注記**
このアクセスポリシーでは、S3 バケットのコンポーネントアーティファクトへのアクセスが許可されていません。Amazon S3 でアーティファクトを定義するカスタムコンポーネントをデプロイするには、コアデバイスがコンポーネントアーティファクトを取得できるようにする許可をロールに追加する必要があります。詳細については、「[コンポーネントのアーティファクトの S3 バケットへのアクセスを許可する](device-service-role.md#device-service-role-access-s3-bucket)」を参照してください。
コンポーネントアーティファクトに S3 バケットをまだ持っていない場合、バケットを作成した後でこれらのアクセス許可を追加できます。
1. ポリシードキュメントから IAM ポリシーを作成します。
+ *GreengrassV2TokenExchangeRoleAccess* を作成する IAM ポリシーの名前に置き換えます。
```
aws iam create-policy --policy-name GreengrassV2TokenExchangeRoleAccess --policy-document file://device-role-access-policy.json
```
要求が正常に処理された場合、レスポンスは次の例のようになります。
```
{
"Policy": {
"PolicyName": "GreengrassV2TokenExchangeRoleAccess",
"PolicyId": "ANPAZ2YMUHYHACI7C5Z66",
"Arn": "arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess",
"Path": "/",
"DefaultVersionId": "v1",
"AttachmentCount": 0,
"PermissionsBoundaryUsageCount": 0,
"IsAttachable": true,
"CreateDate": "2021-02-06T00:37:17+00:00",
"UpdateDate": "2021-02-06T00:37:17+00:00"
}
}
```
1. IAM ポリシーをトークン交換ロールにアタッチします。
+ *GreengrassV2TokenExchangeRole* を、IAM ロールの名前に置き換えます。
+ ポリシー ARN を前のステップで作成した IAM ポリシーの ARN に置き換えます。
```
aws iam attach-role-policy --role-name GreengrassV2TokenExchangeRole --policy-arn arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess
```
要求が正常に処理された場合、コマンドは出力されません。
1. トークン交換 AWS IoT ロールを指すロールエイリアスを作成します。
+ *GreengrassCoreTokenExchangeRoleAlias* を作成するロールエイリアスの名前に置き換えます。
+ ロール ARN を前のステップで作成した IAM ロールの ARN に置き換えます。
```
aws iot create-role-alias --role-alias GreengrassCoreTokenExchangeRoleAlias --role-arn arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole
```
要求が正常に処理された場合、レスポンスは次の例のようになります。
```
{
"roleAlias": "GreengrassCoreTokenExchangeRoleAlias",
"roleAliasArn": "arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
```
**注記**
ロールエイリアスを作成するには、トークン交換 IAM ロールを AWS IoTに渡す許可が必要です。ロールエイリアスを作成しようとしたときにエラーメッセージが表示された場合は、 AWS ユーザーにこのアクセス許可があることを確認してください。詳細については、「 *AWS Identity and Access Management ユーザーガイド*[」の「 AWS サービスにロールを渡すアクセス許可をユーザーに付与](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_passrole.html)する」を参照してください。
## AWS IoT ポリシーを作成する
デバイスを AWS IoT モノとして登録すると、そのデバイスはデジタル証明書を使用して認証できます AWS。この証明書には、デバイスが証明書で使用できるアクセス許可を定義する 1 つ以上の AWS IoT ポリシーが含まれています。これらのポリシーにより、デバイスは AWS IoT および と通信できます AWS IoT Greengrass。
AWS IoT フリートプロビジョニングでは、デバイスは に接続 AWS IoT してデバイス証明書を作成およびダウンロードします。次のセクションで作成するフリートプロビジョニングテンプレートで、 がすべてのデバイスの証明書に同じ AWS IoT ポリシーを AWS IoT アタッチするか、デバイスごとに新しいポリシーを作成するかを指定できます。
このセクションでは、すべてのデバイスの証明書にア AWS IoT タッチする AWS IoT ポリシーを作成します。この方法では、すべてのデバイスの権限をフリートとして管理できます。デバイスごとに新しい AWS IoT ポリシーを作成する場合は、このセクションをスキップして、フリートテンプレートを定義するときにその中のポリシーを参照できます。
**AWS IoT ポリシーを作成するには**
+ Greengrass コアデバイスのフリートの AWS IoT アクセス許可を定義する AWS IoT ポリシーを作成します。次のポリシーは、すべての MQTT トピックと Greengrass 操作へのアクセスを許可するため、デバイスがカスタムアプリケーションや新しい Greengrass 操作を必要とする今後の変更でも動作するようになります。このポリシーは `iot:AssumeRoleWithCertificate` アクセス許可を付与するため、デバイスで前のセクションで作成したトークン交換ロールを使用できるようになります。ユースケースに基づいてこのポリシーを制限できます。詳細については、「[AWS IoT Greengrass V2 コアデバイスの最小 AWS IoT ポリシー](device-auth.md#greengrass-core-minimal-iot-policy)」を参照してください。
以下の操作を実行します。
1. Greengrass コアデバイスが必要とする AWS IoT ポリシードキュメントを含むファイルを作成します。
例えば、Linux ベースのシステムでは、次のコマンドを実行し、GNU nano を使用してファイルを作成できます。
```
nano greengrass-v2-iot-policy.json
```
次の JSON をファイルにコピーします。
+ `iot:AssumeRoleWithCertificate` リソースを、前のセクションで作成した AWS IoT ロールエイリアスの ARN に置き換えます。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Publish",
"iot:Subscribe",
"iot:Receive",
"iot:Connect",
"greengrass:*"
],
"Resource": [
"*"
]
},
{
"Effect": "Allow",
"Action": "iot:AssumeRoleWithCertificate",
"Resource": "arn:aws:iot:us-east-1:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
]
}
```
------
1. AWS IoT ポリシードキュメントから ポリシーを作成します。
+ *GreengrassV2IoTThingPolicy* を作成するポリシーの名前に置き換えます。
```
aws iot create-policy --policy-name GreengrassV2IoTThingPolicy --policy-document file://greengrass-v2-iot-policy.json
```
要求が正常に処理された場合、レスポンスは次の例のようになります。
------
#### [ JSON ]
****
```
{
"policyName": "GreengrassV2IoTThingPolicy",
"policyArn": "arn:aws:iot:us-west-2:123456789012:policy/GreengrassV2IoTThingPolicy",
"policyDocument": "{
\"Version\": \"2012-10-17\",
\"Statement\": [
{
\"Effect\": \"Allow\",
\"Action\": [
\"iot:Publish\",
\"iot:Subscribe\",
\"iot:Receive\",
\"iot:Connect\",
\"greengrass:*\"
],
\"Resource\": [
\"*\"
]
},
{
\"Effect\": \"Allow\",
\"Action\": \"iot:AssumeRoleWithCertificate\",
\"Resource\": \"arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias\"
}
]
}",
"policyVersionId": "1"
}
```
------
## フリートプロビジョニングテンプレートを作成する
AWS IoT フリートプロビジョニングテンプレートは、 AWS IoT モノ、ポリシー、証明書をプロビジョニングする方法を定義します。フリートプロビジョニングプラグインを使用して Greengrass コアデバイスをプロビジョニングするには、次の事項を指定するテンプレートを作成する必要があります。
+ AWS IoT モノのリソース。既存のモノのグループのリストを指定して、オンラインになったときに各デバイスにコンポーネントをデプロイできます。
+ AWS IoT ポリシーリソース。このリソースは、次のいずれかのプロパティを定義できます。
+ 既存の AWS IoT ポリシーの名前。このオプションを選択すると、このテンプレートから作成したコアデバイスは同じ AWS IoT ポリシーを使用し、フリートとしてアクセス許可を管理できます。
+ AWS IoT ポリシードキュメント。このオプションを選択すると、このテンプレートから作成する各コアデバイスは一意の AWS IoT ポリシーを使用し、個々のコアデバイスのアクセス許可を管理できます。
+ AWS IoT 証明書リソース。この証明書リソースでは、`AWS::IoT::Certificate::Id` パラメータを使用して、証明書をコアデバイスにアタッチする必要があります。詳細については、「AWS IoT デベロッパーガイド」の「[ジャストインタイムプロビジョニング](https://docs.aws.amazon.com/iot/latest/developerguide/jit-provisioning.html)」を参照してください。
テンプレートでは、 を指定して、既存の AWS IoT モノグループのリストにモノを追加できます。コアデバイスが AWS IoT Greengrass 初めて に接続すると、メンバーであるモノグループごとに Greengrass デプロイを受け取ります。モノグループを使用して、最新のソフトウェアがオンラインになり次第、各デバイスにデプロイすることができます。詳細については、「[AWS IoT Greengrass コンポーネントをデバイスにデプロイする](manage-deployments.md)」を参照してください。
この AWS IoT サービスには、デバイスのプロビジョニング AWS アカウント 時に で AWS IoT リソースを作成および更新するためのアクセス許可が必要です。 AWS IoT サービスアクセスを許可するには、IAM ロールを作成し、テンプレートの作成時に指定します。 は、デバイスのプロビジョニング時に が AWS IoT 使用するすべてのアクセス許可へのアクセスを許可する マネージドポリシー [AWSIoTThingsRegistration](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/service-role/AWSIoTThingsRegistration) AWS IoT を提供します。このマネージドポリシーを使用するか、ユースケースのマネージドポリシーのアクセス許可に範囲を絞り込んだカスタムポリシーを作成することができます。
このセクションでは、 がデバイスのリソース AWS IoT をプロビジョニングできるようにする IAM ロールを作成し、その IAM ロールを使用するフリートプロビジョニングテンプレートを作成します。
**フリートプロビジョニングテンプレートを作成するには**
1. でリソースをプロビジョニングするために が引き受け AWS IoT ることができる IAM ロールを作成します AWS アカウント。以下の操作を実行します。
1. がロールを引き受けること AWS IoT を許可する信頼ポリシードキュメントを含むファイルを作成します。
例えば、Linux ベースのシステムでは、次のコマンドを実行し、GNU nano を使用してファイルを作成できます。
```
nano aws-iot-trust-policy.json
```
次の JSON をファイルにコピーします。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. 信頼できるポリシードキュメントを使用して IAM ロールを作成します。
+ *GreengrassFleetProvisioningRole* を、作成する IAM ロールの名前に置き換えます。
```
aws iam create-role --role-name GreengrassFleetProvisioningRole --assume-role-policy-document file://aws-iot-trust-policy.json
```
要求が正常に処理された場合、レスポンスは次の例のようになります。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Connect",
"iot:Publish",
"iot:Subscribe",
"iot:Receive"
],
"Resource": "*"
}
]
}
```
------
1. [AWSIoTThingsRegistration](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/service-role/AWSIoTThingsRegistration) ポリシーを確認してください。これにより、デバイスのプロビジョニング時に が AWS IoT 使用するすべてのアクセス許可へのアクセスが許可されます。このマネージドポリシーを使用するか、ユースケースのアクセス許可に範囲を絞り込んだカスタムポリシーを作成することができます。カスタムポリシーを作成する場合は、ここで作成します。
1. IAM ポリシーをフリートプロビジョニングロールにアタッチします。
+ *GreengrassFleetProvisioningRole* を、IAM ロールの名前に置き換えます。
+ 前のステップでカスタムポリシーを作成した場合は、ポリシー ARN を使用する IAM ポリシーの ARN に置き換えます。
```
aws iam attach-role-policy --role-name GreengrassFleetProvisioningRole --policy-arn arn:aws:iam::aws:policy/service-role/AWSIoTThingsRegistration
```
要求が正常に処理された場合、コマンドは出力されません。
1. (オプション) 事前プロビジョニングフックを作成します。これは、デバイスが登録時に提供するテンプレートパラメータを検証する AWS Lambda 関数です。事前プロビジョニングフックを使用することで、 AWS アカウントアカウントに搭載するデバイスの種類と台数をより細かく制御することができます。詳細については、「AWS IoT Core デベロッパーガイド」の「[事前プロビジョニングフック](https://docs.aws.amazon.com/iot/latest/developerguide/pre-provisioning-hook.html)」を参照してください。
1. フリートプロビジョニングテンプレートを作成します。以下の操作を実行します。
1. プロビジョニングテンプレートドキュメントを含めるファイルを作成します。
例えば、Linux ベースのシステムでは、次のコマンドを実行し、GNU nano を使用してファイルを作成できます。
```
nano greengrass-fleet-provisioning-template.json
```
プロビジョニングテンプレートドキュメントを記述します。次のプロビジョニングテンプレートの例から開始できます。このテンプレートでは、次のプロパティを持つ AWS IoT モノを作成するように を指定します。
+ モノの名前は、`ThingName` テンプレートパラメータで指定した値です。
+ モノは、`ThingGroupName` テンプレートパラメータで指定したモノグループのメンバーです。モノのグループは に存在する必要があります AWS アカウント。
+ モノの証明書には、 という名前の AWS IoT ポリシーがア`GreengrassV2IoTThingPolicy`タッチされています。
詳細については、「AWS IoT Core デベロッパーガイド」の「[プロビジョニングテンプレート](https://docs.aws.amazon.com/iot/latest/developerguide/provision-template.html)」を参照してください。
```
{
"Parameters": {
"ThingName": {
"Type": "String"
},
"ThingGroupName": {
"Type": "String"
},
"AWS::IoT::Certificate::Id": {
"Type": "String"
}
},
"Resources": {
"MyThing": {
"OverrideSettings": {
"AttributePayload": "REPLACE",
"ThingGroups": "REPLACE",
"ThingTypeName": "REPLACE"
},
"Properties": {
"AttributePayload": {},
"ThingGroups": [
{
"Ref": "ThingGroupName"
}
],
"ThingName": {
"Ref": "ThingName"
}
},
"Type": "AWS::IoT::Thing"
},
"MyPolicy": {
"Properties": {
"PolicyName": "GreengrassV2IoTThingPolicy"
},
"Type": "AWS::IoT::Policy"
},
"MyCertificate": {
"Properties": {
"CertificateId": {
"Ref": "AWS::IoT::Certificate::Id"
},
"Status": "Active"
},
"Type": "AWS::IoT::Certificate"
}
}
}
```
**注記**
*MyThing*、*MyPolicy*、*MyCertificate* は、フリートプロビジョニングテンプレートの各リソース仕様を識別する任意の名前です。 テンプレートから作成するリソースでは、これらの名前を使用し AWS IoT ません。これらの名前を使用するか、テンプレート内の各リソースを識別するのに役立つ値に置き換えることができます。
1. プロビジョニングテンプレートドキュメントからフリートプロビジョニングテンプレートを作成します。
+ *GreengrassFleetProvisioningTemplate* を、作成するテンプレートの名前に置き換えます。
+ テンプレートの説明を作成するテンプレートの説明に置き換えます。
+ プロビジョニングロールの ARN を、先程作成したロールの ARN に置き換えます。
------
#### [ Linux or Unix ]
```
aws iot create-provisioning-template \
--template-name GreengrassFleetProvisioningTemplate \
--description "A provisioning template for Greengrass core devices." \
--provisioning-role-arn "arn:aws:iam::123456789012:role/GreengrassFleetProvisioningRole" \
--template-body file://greengrass-fleet-provisioning-template.json \
--enabled
```
------
#### [ Windows Command Prompt (CMD) ]
```
aws iot create-provisioning-template ^
--template-name GreengrassFleetProvisioningTemplate ^
--description "A provisioning template for Greengrass core devices." ^
--provisioning-role-arn "arn:aws:iam::123456789012:role/GreengrassFleetProvisioningRole" ^
--template-body file://greengrass-fleet-provisioning-template.json ^
--enabled
```
------
#### [ PowerShell ]
```
aws iot create-provisioning-template `
--template-name GreengrassFleetProvisioningTemplate `
--description "A provisioning template for Greengrass core devices." `
--provisioning-role-arn "arn:aws:iam::123456789012:role/GreengrassFleetProvisioningRole" `
--template-body file://greengrass-fleet-provisioning-template.json `
--enabled
```
------
**注記**
事前プロビジョニングフックを作成した場合は、事前プロビジョニングフックの Lambda 関数の ARN を `--pre-provisioning-hook` 引数で指定します。
```
--pre-provisioning-hook targetArn=arn:aws:lambda:us-west-2:123456789012:function:GreengrassPreProvisioningHook
```
要求が正常に処理された場合、レスポンスは次の例のようになります。
```
{
"templateArn": "arn:aws:iot:us-west-2:123456789012:provisioningtemplate/GreengrassFleetProvisioningTemplate",
"templateName": "GreengrassFleetProvisioningTemplate",
"defaultVersionId": 1
}
```
## プロビジョニングクレーム証明書とプライベートキーを作成する
クレーム証明書は、デバイスが AWS IoT モノとして登録し、通常のオペレーションに使用する一意の X.509 デバイス証明書を取得できるようにする X.509 証明書です。クレーム証明書を作成したら、デバイスがそれを使用して一意のデバイス証明書を作成し、フリートプロビジョニングテンプレートでプロビジョニングできるようにする AWS IoT ポリシーをアタッチします。クレーム証明書を持つデバイスは、 AWS IoT ポリシーで許可したプロビジョニングテンプレートを使用してのみプロビジョニングできます。
このセクションでは、クレーム証明書を作成し、前のセクションで作成したフリートプロビジョニングテンプレートで使用するデバイス用に設定します。
**重要**
プロビジョニングクレームプライベートキーは、Greengrass コアデバイス上にある場合を含め、常に保護する必要があります。Amazon CloudWatch メトリクスとログを使用して、デバイスをプロビジョニングするクレーム証明書の不正使用などの悪用の兆候がないか監視することをお勧めします。悪用を検出した場合は、プロビジョニングクレーム証明書を無効にして、デバイスのプロビジョニングに使用できないようにします。詳細については、「AWS IoT Core デベロッパーガイド」の「[AWS IoTのモニタリング](https://docs.aws.amazon.com/iot/latest/developerguide/monitoring_overview.html)」を参照してください。**
に登録するデバイスの数とデバイスをより適切に管理できるように AWS アカウント、フリートプロビジョニングテンプレートを作成するときに事前プロビジョニングフックを指定できます。事前プロビジョニングフックは、デバイスが登録時に提供するテンプレートパラメータを検証する AWS Lambda 関数です。例えば、デバイス ID をデータベースと照合して、デバイスにプロビジョニングする権限があることを確認する事前プロビジョニングフックを作成することができます。詳細については、「AWS IoT Core デベロッパーガイド」の「[事前プロビジョニングフック](https://docs.aws.amazon.com/iot/latest/developerguide/pre-provisioning-hook.html)」を参照してください。
**プロビジョニングクレーム証明書とプライベートキーを作成するには**
1. クレーム証明書とプライベートキーをダウンロードするフォルダを作成します。
```
mkdir claim-certs
```
1. プロビジョニングに使用する証明書とプライベートキーを作成して保存します。Amazon ルート認証局 (CA) によって署名されたクライアント証明書 AWS IoT を提供します。
------
#### [ Linux or Unix ]
```
aws iot create-keys-and-certificate \
--certificate-pem-outfile "claim-certs/claim.pem.crt" \
--public-key-outfile "claim-certs/claim.public.pem.key" \
--private-key-outfile "claim-certs/claim.private.pem.key" \
--set-as-active
```
------
#### [ Windows Command Prompt (CMD) ]
```
aws iot create-keys-and-certificate ^
--certificate-pem-outfile "claim-certs/claim.pem.crt" ^
--public-key-outfile "claim-certs/claim.public.pem.key" ^
--private-key-outfile "claim-certs/claim.private.pem.key" ^
--set-as-active
```
------
#### [ PowerShell ]
```
aws iot create-keys-and-certificate `
--certificate-pem-outfile "claim-certs/claim.pem.crt" `
--public-key-outfile "claim-certs/claim.public.pem.key" `
--private-key-outfile "claim-certs/claim.private.pem.key" `
--set-as-active
```
------
リクエストが成功した場合、レスポンスには証明書に関する情報が含まれます。証明書の ARN は、後で使用できるように書き留めておきます。
1. デバイスが証明書を使用して一意のデバイス証明書を作成し、フリートプロビジョニングテンプレートでプロビジョニングできるようにする AWS IoT ポリシーを作成してアタッチします。次のポリシーは、デバイスプロビジョニング MQTT API へのアクセスを許可します。詳細については、「AWS IoT Core デベロッパーガイド」の「[デバイスプロビジョニング MQTT API](https://docs.aws.amazon.com/iot/latest/developerguide/fleet-provision-api.html)」を参照してください。
以下の操作を実行します。
1. Greengrass コアデバイスが必要とする AWS IoT ポリシードキュメントを含むファイルを作成します。
例えば、Linux ベースのシステムでは、次のコマンドを実行し、GNU nano を使用してファイルを作成できます。
```
nano greengrass-provisioning-claim-iot-policy.json
```
次の JSON をファイルにコピーします。
+ *リージョン*の各インスタンスを、フリートプロビジョニングをセットアップ AWS リージョン した に置き換えます。
+ *account-id* の各インスタンスを、 AWS アカウント ID に置き換えます。
+ *GreengrassFleetProvisioningTemplate* の各インスタンスを、前のセクションで作成したフリートプロビジョニングテンプレートの名前に置き換えます。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iot:Connect",
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"iot:Publish",
"iot:Receive"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/$aws/certificates/create/*",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/provisioning-templates/GreengrassFleetProvisioningTemplate/provision/*"
]
},
{
"Effect": "Allow",
"Action": "iot:Subscribe",
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/certificates/create/*",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/provisioning-templates/GreengrassFleetProvisioningTemplate/provision/*"
]
}
]
}
```
------
1. AWS IoT ポリシードキュメントから ポリシーを作成します。
+ *GreengrassProvisioningClaimPolicy* を作成するポリシーの名前に置き換えます。
```
aws iot create-policy --policy-name GreengrassProvisioningClaimPolicy --policy-document file://greengrass-provisioning-claim-iot-policy.json
```
要求が正常に処理された場合、レスポンスは次の例のようになります。
------
#### [ JSON ]
****
```
{
"policyName": "GreengrassProvisioningClaimPolicy",
"policyArn": "arn:aws:iot:us-west-2:123456789012:policy/GreengrassProvisioningClaimPolicy",
"policyDocument": "{
\"Version\": \"2012-10-17\",
\"Statement\": [
{
\"Effect\": \"Allow\",
\"Action\": \"iot:Connect\",
\"Resource\": \"*\"
},
{
\"Effect\": \"Allow\",
\"Action\": [
\"iot:Publish\",
\"iot:Receive\"
],
\"Resource\": [
\"arn:aws:iot:us-east-1:123456789012:topic/$aws/certificates/create/*\",
\"arn:aws:iot:us-east-1:123456789012:topic/$aws/provisioning-templates/GreengrassFleetProvisioningTemplate/provision/*\"
]
},
{
\"Effect\": \"Allow\",
\"Action\": \"iot:Subscribe\",
\"Resource\": [
\"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/certificates/create/*\",
\"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/provisioning-templates/GreengrassFleetProvisioningTemplate/provision/*\"
]
}
]
}",
"policyVersionId": "1"
}
```
------
1. プロビジョニングクレーム証明書に AWS IoT ポリシーをアタッチします。
+ *GreengrassProvisioningClaimPolicy* を、アタッチするポリシーの名前に置き換えます。
+ ターゲット ARN をプロビジョニングクレーム証明書の ARN に置き換えます。
```
aws iot attach-policy --policy-name GreengrassProvisioningClaimPolicy --target arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4
```
要求が正常に処理された場合、コマンドは出力されません。
これで、デバイスが Greengrass コアデバイスに登録してプロビジョニングするために使用できるプロビジョニングクレーム証明書 AWS IoT とプライベートキーができました。Core AWS IoT Greengrass ソフトウェアをインストールする前に、製造中にクレーム証明書とプライベートキーをデバイスに埋め込むか、証明書とキーをデバイスにコピーできます。詳細については、「[AWS IoT フリートプロビジョニングを使用して AWS IoT Greengrass Core ソフトウェアをインストールする](fleet-provisioning.md)」を参照してください。
# AWS IoT フリートプロビジョニングプラグインを設定する
AWS IoT フリートプロビジョニングプラグインには、[フリートプロビジョニングで AWS IoT Greengrass Core ソフトウェアをインストールする](fleet-provisioning.md)ときにカスタマイズできる以下の設定パラメータが用意されています。
`rootPath`
AWS IoT Greengrass Core ソフトウェアのルートとして使用するフォルダへのパス。
`awsRegion`
フリートプロビジョニングプラグイン AWS リージョン がリソースのプロビジョニング AWS に使用する 。
`iotDataEndpoint`
AWS IoT のデータエンドポイント AWS アカウント。
`iotCredentialEndpoint`
の AWS IoT 認証情報エンドポイント AWS アカウント。
`iotRoleAlias`
トークン交換 IAM AWS IoT ロールを指すロールエイリアス。 AWS IoT 認証情報プロバイダーはこのロールを引き受け、Greengrass コアデバイスが AWS サービスとやり取りできるようにします。詳細については、「[コアデバイスが AWS サービスとやり取りできるように認可する](device-service-role.md)」を参照してください。
`provisioningTemplate`
AWS リソースのプロビジョニングに使用する AWS IoT フリートプロビジョニングテンプレート。このテンプレートでは、以下を指定する必要があります。
+ AWS IoT モノのリソース。既存のモノのグループのリストを指定して、オンラインになったときに各デバイスにコンポーネントをデプロイできます。
+ AWS IoT ポリシーリソース。このリソースは、次のいずれかのプロパティを定義できます。
+ 既存の AWS IoT ポリシーの名前。このオプションを選択すると、このテンプレートから作成したコアデバイスは同じ AWS IoT ポリシーを使用し、フリートとしてアクセス許可を管理できます。
+ AWS IoT ポリシードキュメント。このオプションを選択すると、このテンプレートから作成する各コアデバイスは一意の AWS IoT ポリシーを使用し、個々のコアデバイスのアクセス許可を管理できます。
+ AWS IoT 証明書リソース。この証明書リソースでは、`AWS::IoT::Certificate::Id` パラメータを使用して、証明書をコアデバイスにアタッチする必要があります。詳細については、「AWS IoT デベロッパーガイド」の「[ジャストインタイムプロビジョニング](https://docs.aws.amazon.com/iot/latest/developerguide/jit-provisioning.html)」を参照してください。
詳細については、「AWS IoT Core デベロッパーガイド」の「[プロビジョニングテンプレート](https://docs.aws.amazon.com/iot/latest/developerguide/provision-template.html)」を参照してください。
`claimCertificatePath`
`provisioningTemplate` で指定したプロビジョニングテンプレートのプロビジョニングクレーム証明書へのパス。詳細については、「AWS IoT Core API リファレンス」の「[CreateProvisioningClaim](https://docs.aws.amazon.com/iot/latest/apireference/API_CreateProvisioningClaim.html)」を参照してください。
`claimCertificatePrivateKeyPath`
`provisioningTemplate` で指定したプロビジョニングテンプレートのプロビジョニングクレーム証明書プライベートキーへのパス。詳細については、「AWS IoT Core API リファレンス」の「[CreateProvisioningClaim](https://docs.aws.amazon.com/iot/latest/apireference/API_CreateProvisioningClaim.html)」を参照してください。
プロビジョニングクレームプライベートキーは、Greengrass コアデバイス上にある場合を含め、常に保護する必要があります。Amazon CloudWatch メトリクスとログを使用して、デバイスをプロビジョニングするクレーム証明書の不正使用などの悪用の兆候がないか監視することをお勧めします。悪用を検出した場合は、プロビジョニングクレーム証明書を無効にして、デバイスのプロビジョニングに使用できないようにします。詳細については、「AWS IoT Core デベロッパーガイド」の「[AWS IoTのモニタリング](https://docs.aws.amazon.com/iot/latest/developerguide/monitoring_overview.html)」を参照してください。**
に登録するデバイスの数とデバイスをより適切に管理できるように AWS アカウント、フリートプロビジョニングテンプレートを作成するときに事前プロビジョニングフックを指定できます。事前プロビジョニングフックは、デバイスが登録時に提供するテンプレートパラメータを検証する AWS Lambda 関数です。例えば、デバイス ID をデータベースと照合して、デバイスにプロビジョニングする権限があることを確認する事前プロビジョニングフックを作成することができます。詳細については、「AWS IoT Core デベロッパーガイド」の「[事前プロビジョニングフック](https://docs.aws.amazon.com/iot/latest/developerguide/pre-provisioning-hook.html)」を参照してください。
`rootCaPath`
Amazon ルート認証局 (CA) 証明書へのパス。
`templateParameters`
(オプション) フリートプロビジョニングテンプレートに提供するパラメータのマップ。詳細については、「AWS IoT Core デベロッパーガイド」の「[プロビジョニングテンプレートのパラメータセクション](https://docs.aws.amazon.com/iot/latest/developerguide/provision-template.html#parameters-section)」を参照してください。
`deviceId`
(オプション) フリートプロビジョニングプラグインが AWS IoTへの MQTT 接続を作成するときに、クライアント ID として使用するデバイス識別子。
デフォルト: ランダム値の UUID。
`mqttPort`
(オプション) MQTT 接続に使用するポート。
デフォルト: `8883`
`proxyUrl`
(オプション) プロキシサーバーの URL (`scheme://userinfo@host:port` 形式)。HTTPS プロキシを使用するには、フリートプロビジョニングプラグインのバージョン 1.1.0 以降を使用する必要があります。
+ `scheme` - スキーム。`http` または `https` である必要があります。
**重要**
HTTPS プロキシを使用するには、Greengrass コアデバイスで [Greengrass nucleus ](greengrass-nucleus-component.md) v2.5.0 以降を実行している必要があります。
HTTPS プロキシを設定する場合は、コアデバイスの Amazon ルート CA 証明書にプロキシサーバー CA 証明書を追加する必要があります。詳細については、「[コアデバイスが HTTPS プロキシを信頼できるようにする](configure-greengrass-core-v2.md#https-proxy-certificate-trust)」を参照してください。
+ `userinfo` - (オプション) ユーザー名とパスワードの情報。この情報を `url` で指定する場合、Greengrass コアデバイスは `username` および `password` フィールドを無視します。
+ `host` – プロキシサーバーのホスト名または IP アドレス。
+ `port` - (オプション) ポート番号。ポートを指定しない場合、Greengrass コアデバイスは次のデフォルト値を使用します。
+ `http` – 80
+ `https` – 443
`proxyUserName`
(オプション) プロキシサーバーを認証するユーザー名です。
`proxyPassword`
(オプション) プロキシサーバーを認証するユーザー名です。
csrPath
(オプション) CSR からデバイス証明書を作成するために使用する、証明書署名要求 (CSR) ファイルへのパスです。詳細については、「 AWS IoT Core デベロッパーガイド」の「[クレームによるプロビジョニング](https://docs.aws.amazon.com/iot/latest/developerguide/provision-wo-cert.html#claim-based)」を参照してください。
csrPrivateKeyPath
(オプション、`csrPath` 宣言されている場合は必須) CSR の生成に使用されるプライベートキーへのパスです。CSR の生成は、プライベートキーを使用して行われている必要があります。詳細については、「AWS IoT Core デベロッパーガイド」の「[クレームによるプロビジョニング](https://docs.aws.amazon.com/iot/latest/developerguide/provision-wo-cert.html#claim-based)」を参照してください。
certificatePath
(オプション) ダウンロードしたデバイス証明書を保存するために使用するパス。
privateKeyPath
(オプション) ダウンロードしたデバイスのプライベートキーを保存するために使用するパス。
# AWS IoT フリートプロビジョニングプラグインの変更ログ
次の表は、クレームプラグイン (`aws.greengrass.FleetProvisioningByClaim`) による AWS IoT フリートプロビジョニングの各バージョンの変更を説明したものです。
| バージョン | 変更 |
| --- | --- |
| 1.2.2 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/greengrass/v2/developerguide/fleet-provisioning-changelog.html) |
| 1.2.1 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/greengrass/v2/developerguide/fleet-provisioning-changelog.html) |
| 1.2.0 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/greengrass/v2/developerguide/fleet-provisioning-changelog.html) |
| 1.1.0 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/greengrass/v2/developerguide/fleet-provisioning-changelog.html) |
| 1.0.0 | 当初のバージョン |
# カスタムリソースプロビジョニングを使用して AWS IoT Greengrass Core ソフトウェアをインストールする
この機能は、[Greengrass nucleus コンポーネント](greengrass-nucleus-component.md)の v2.4.0 以降に利用できます。
AWS IoT Greengrass Core ソフトウェアインストーラは、必要な AWS リソースをプロビジョニングするカスタムプラグインに実装できる Java インターフェイスを提供します。プロビジョニングプラグインを開発して、カスタム X.509 クライアント証明書を使用するか、他のインストールプロセスでサポートされていない複雑なプロビジョニング手順を実行することができます。詳細については、「AWS IoT Core デベロッパーガイド」の「[独自のクライアント証明書を作成する](https://docs.aws.amazon.com/iot/latest/developerguide/device-certs-your-own.html)」を参照してください。
AWS IoT Greengrass Core ソフトウェアのインストール時にカスタムプロビジョニングプラグインを実行するには、インストーラに提供する JAR ファイルを作成します。インストーラはプラグインを実行し、プラグインは Greengrass コアデバイスの AWS リソースを定義するプロビジョニング設定を返します。インストーラはこの情報を使用して、デバイスで AWS IoT Greengrass Core ソフトウェアを設定します。詳細については、「[カスタムプロビジョニングプラグインを開発する](develop-custom-provisioning-plugins.md)」を参照してください。
**重要**
AWS IoT Greengrass Core ソフトウェアをダウンロードする前に、コアデバイスが AWS IoT Greengrass Core ソフトウェア v2.0 をインストールして実行する[要件を満た](greengrass-nucleus-component.md#greengrass-v2-requirements)していることを確認してください。
**Topics**
+ [前提条件](#custom-provisioning-prerequisites)
+ [デバイス環境をセットアップする](#set-up-device-environment)
+ [AWS IoT Greengrass Core ソフトウェアをダウンロードする](#download-greengrass-core-v2)
+ [AWS IoT Greengrass Core ソフトウェアのインストール](#run-greengrass-core-v2-installer-custom)
+ [カスタムプロビジョニングプラグインを開発する](develop-custom-provisioning-plugins.md)
## 前提条件
カスタムプロビジョニングで AWS IoT Greengrass Core ソフトウェアをインストールするには、以下が必要です。
+ `DeviceIdentityInterface` を実装するカスタムプロビジョニングプラグインの JAR ファイル。カスタムプロビジョニングプラグインは、各システムに対する値と nucleus 設定パラメータを返す必要があります。これらの値が返されない場合には、インストール時に設定ファイルでこれらの値を提供する必要があります。詳細については、「[カスタムプロビジョニングプラグインを開発する](develop-custom-provisioning-plugins.md)」を参照してください。
## デバイス環境をセットアップする
このセクションのステップに従って、 AWS IoT Greengrass コアデバイスとして使用する Linux または Windows デバイスをセットアップします。
### Linux デバイスをセットアップする
**の Linux デバイスを設定するには AWS IoT Greengrass V2**
1. AWS IoT Greengrass Core ソフトウェアが実行する必要がある Java ランタイムをインストールします。[Amazon Corretto](https://aws.amazon.com/corretto/) または [OpenJDK](https://openjdk.java.net/) の長期サポートバージョンを使用することをお勧めします。バージョン 8 以降が必要です。次のコマンドは、デバイスに OpenJDK をインストールする方法を示しています。
+ Debian ベースまたは Ubuntu ベースのディストリビューションの場合:
```
sudo apt install default-jdk
```
+ Red Hat ベースのディストリビューションの場合:
```
sudo yum install java-11-openjdk-devel
```
+ 複数 Amazon Linux 2:
```
sudo amazon-linux-extras install java-openjdk11
```
+ 複数 Amazon Linux 2023:
```
sudo dnf install java-11-amazon-corretto -y
```
インストールが完了したら、次のコマンドを実行して Java が Linux デバイスで実行されていることを確認します。
```
java -version
```
このコマンドは、デバイス上で実行されている Java のバージョンを出力します。例えば、Debian ベースのディストリビューションでは、出力は次のサンプルのようになります。
```
openjdk version "11.0.9.1" 2020-11-04
OpenJDK Runtime Environment (build 11.0.9.1+1-post-Debian-1deb10u2)
OpenJDK 64-Bit Server VM (build 11.0.9.1+1-post-Debian-1deb10u2, mixed mode)
```
1. (オプション) デバイスにコンポーネントを実行するデフォルトのシステムユーザーおよびグループを作成します。`--component-default-user` インストーラ引数を使用して、インストール中に AWS IoT Greengrass Core ソフトウェアインストーラにこのユーザーとグループを作成させることもできます。詳細については、「[インストーラ引数](configure-installer.md)」を参照してください。
```
sudo useradd --system --create-home ggc_user
sudo groupadd --system ggc_group
```
1. AWS IoT Greengrass Core ソフトウェアを実行するユーザー (通常は `root`) に、任意のユーザーと任意のグループ`sudo`で を実行するアクセス許可があることを確認します。
1. `/etc/sudoers` ファイルを開くには、次のコマンドを実行します。
```
sudo visudo
```
1. ユーザーの権限が次の例のようになっていることを確認します。
```
root ALL=(ALL:ALL) ALL
```
1. (オプション) [コンテナ化された Lambda 関数を実行](run-lambda-functions.md)するには、[cgroups](https://en.wikipedia.org/wiki/Cgroups) v1 を有効にし、*メモリ*と*デバイス*の cgroups を有効にしてマウントする必要があります。コンテナ化された Lambda 関数を実行する予定がない場合、この手順を省略できます。
これらの cgroups オプションを有効にするには、次の Linux カーネルパラメータを使用してデバイスを起動します。
```
cgroup_enable=memory cgroup_memory=1 systemd.unified_cgroup_hierarchy=0
```
デバイスのカーネルパラメータを確認および設定するための情報については、オペレーティングシステムおよびブートローダーのドキュメントを参照してください。指示に従って、カーネルパラメータを永続的に設定します。
1. [デバイスの要件](greengrass-nucleus-component.md#greengrass-v2-requirements) にある要件リストで示されているように、その他の必要となる依存関係をすべてデバイスにインストールします。
### Windows デバイスをセットアップする
**注記**
この機能は、[Greengrass nucleus コンポーネント](greengrass-nucleus-component.md)の v2.5.0 以降に利用できます。
**の Windows デバイスを設定するには AWS IoT Greengrass V2**
1. AWS IoT Greengrass Core ソフトウェアが実行する必要がある Java ランタイムをインストールします。[Amazon Corretto](https://aws.amazon.com/corretto/) または [OpenJDK](https://openjdk.java.net/) の長期サポートバージョンを使用することをお勧めします。バージョン 8 以降が必要です。
1. [PATH](https://en.wikipedia.org/wiki/PATH_(variable)) システム変数で Java が使用可能か確認し、そうでない場合は追加します。LocalSystem アカウントは AWS IoT Greengrass Core ソフトウェアを実行するため、ユーザーの PATH ユーザー変数ではなく PATH システム変数に Java を追加する必要があります。以下の操作を実行します。
1. Windows キーを押してスタートメニューを開きます。
1. **environment variables** を入力して、スタートメニューからシステムオプションを検索します。
1. スタートメニューの検索結果から **[Edit the system environment variables]** (システム環境変数を編集) をクリックして、**[System properties]** (システムプロパティ) ウィンドウを開きます。
1. **[Environment variables...]** (環境変数...) を選択して、**[Environment Variables]** (環境可変) ウィンドウを開きます。
1. **[System variables]** (システム変数) で、**[Path]** (パス) 、**[Edit]** (編集) の順に選択します。**[Edit environment variable]** (環境変数の編集) ウィンドウでは、個別の行に各パスを表示できます。
1. Java インストールの `bin` フォルダへのパスが存在しているかを確認します。このパスは、次の例のように表示されます。
```
C:\\Program Files\\Amazon Corretto\\jdk11.0.13_8\\bin
```
1. **[Path]** (パス) で Java インストールの `bin` フォルダが で見つからない場合は、**[New]** (新規) を選択してこれを追加した上で、**[OK]** を選択します。
1. 管理者として Windows コマンドプロンプト `cmd.exe` を開きます。
1. Windows デバイスの LocalSystem アカウントにデフォルトユーザーを作成します。*パスワード*を安全なパスワードに置き換えます。
```
net user /add ggc_user password
```
**ヒント**
Windows の構成によっては、ユーザーのパスワードの期限切れが、将来の日付に設定されている場合があります。Greengrass アプリケーションの動作を継続させるためには、パスワードの有効期限を追跡し、その期限が切れる前に更新します。ユーザーのパスワードには、期限切れを起こさないような設定も可能です。
ユーザーとパスワードの有効期限を確認するには、次のコマンドを実行します。
```
net user ggc_user | findstr /C:expires
```
ユーザーのパスワードが期限切れにならないように設定するには、次のコマンドを実行します。
```
wmic UserAccount where "Name='ggc_user'" set PasswordExpires=False
```
[`wmic` コマンドが廃止されている](https://learn.microsoft.com/en-us/windows/win32/wmisdk/wmic) Windows 10 以降を使用している場合は、次の PowerShell コマンドを実行します。
```
Get-CimInstance -Query "SELECT * from Win32_UserAccount WHERE name = 'ggc_user'" | Set-CimInstance -Property @{PasswordExpires="False"}
```
1. [PsExec ユーティリティ](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec)を Microsoft からダウンロードしてデバイスにインストールします。
1. PsExec ユーティリティを使用して、デフォルトユーザーのユーザー名とパスワードを LocalSystem アカウントの認証情報マネージャーインスタンスに格納します。*パスワード*を以前に設定したユーザーのパスワードに置き換えます。
```
psexec -s cmd /c cmdkey /generic:ggc_user /user:ggc_user /pass:password
```
**PsExec License Agreement** が開いたら、**Accept** を選択し、ライセンスに同意してコマンドを実行します。
**注記**
Windows デバイスでは、LocalSystem アカウントによって Greengrass nucleus が実行され、PsExec ユーティリティを使用して LocalSystem アカウントにデフォルトのユーザー情報を保存する必要があります。認証情報マネージャーアプリケーションを使用すると、この情報は LocalSystem アカウントではなく、現在ログオンしているユーザーの Windows アカウントに保存されます。
## AWS IoT Greengrass Core ソフトウェアをダウンロードする
AWS IoT Greengrass Core ソフトウェアの最新バージョンは、次の場所からダウンロードできます。
+ [https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip](https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip)
**注記**
Core AWS IoT Greengrass ソフトウェアの特定のバージョンは、次の場所からダウンロードできます。*バージョン*をダウンロードするバージョンに置き換えます。
```
https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-version.zip
```
**AWS IoT Greengrass Core ソフトウェアをダウンロードするには**
1. コアデバイスで、 AWS IoT Greengrass Core ソフトウェアを という名前のファイルにダウンロードします`greengrass-nucleus-latest.zip`。
------
#### [ Linux or Unix ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
iwr -Uri https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip -OutFile greengrass-nucleus-latest.zip
```
------
このソフトウェアをダウンロードすると、[Greengrass Core ソフトウェアのライセンス契約](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf)に同意したものと見なされます。
1. (オプション) Greengrass nucleus ソフトウェア署名を確認するには
**注記**
この機能は、Greengrass nucleus バージョン 2.9.5 以降で使用できます。
1. 以下のコマンドを使用して、Greengrass nucleus アーティファクトの署名を確認します。
------
#### [ Linux or Unix ]
```
jarsigner -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
インストールする JDK のバージョンによって、ファイル名が異なる場合があります。インストールした JDK のバージョンに *`jdk17.0.6_10`* を置き換えてください。
```
"C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe" -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
インストールする JDK のバージョンによって、ファイル名が異なる場合があります。インストールした JDK のバージョンに *`jdk17.0.6_10`* を置き換えてください。
```
'C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe' -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
1. `jarsigner` が起動すると、検証結果を示す出力が得られます。
1. Greengrass nucleus の zip ファイルに署名されると、出力に以下のような文が表示されます：
```
jar verified.
```
1. Greengrass nucleus の zip ファイルに署名されないと、出力に以下のような文が表示されます：
```
jar is unsigned.
```
1. Jarsigner `-certs` を `-verify` と`-verbose` オプションと一緒に提供した場合、出力には署名者証明書の詳細情報も含まれます。
1. AWS IoT Greengrass Core ソフトウェアをデバイスのフォルダに解凍します。*GreengrassInstaller* を使用するフォルダに置き換えます。
------
#### [ Linux or Unix ]
```
unzip greengrass-nucleus-latest.zip -d GreengrassInstaller && rm greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
mkdir GreengrassInstaller && tar -xf greengrass-nucleus-latest.zip -C GreengrassInstaller && del greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
Expand-Archive -Path greengrass-nucleus-latest.zip -DestinationPath .\\GreengrassInstaller
rm greengrass-nucleus-latest.zip
```
------
1. (オプション) 次のコマンドを実行して、 AWS IoT Greengrass Core ソフトウェアのバージョンを確認します。
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
**重要**
v2.4.0 より前のバージョンの Greengrass nucleus をインストールした場合は、 AWS IoT Greengrass Core ソフトウェアをインストールした後にこのフォルダを削除しないでください。 AWS IoT Greengrass Core ソフトウェアは、このフォルダ内のファイルを使用して実行します。
ソフトウェアの最新バージョンをダウンロードした場合は、v2.4.0 以降をインストールし、 AWS IoT Greengrass Core ソフトウェアをインストールした後にこのフォルダを削除できます。
## AWS IoT Greengrass Core ソフトウェアのインストール
次のアクションを指定する引数を含むインストーラを実行します。
+ カスタムプロビジョニングプラグインを使用して AWS リソースをプロビジョニングするように指定する部分的な設定ファイルから をインストールします。 AWS IoT Greengrass Core ソフトウェアは、デバイス上のすべての Greengrass コンポーネントの設定を指定する設定ファイルを使用します。インストーラは、指定した部分的な設定ファイルと、カスタムプロビジョニングプラグインが作成する AWS リソースから完全な設定ファイルを作成します。
+ コアデバイスでソフトウェアコンポーネントを実行するために `ggc_user` システムユーザーを使用するように指定します。Linux デバイスでは、このコマンドも `ggc_group` システムグループを使用するように指定し、さらにインストーラによってシステムユーザーとグループが、ユーザーに代わって作成されます。
+ Core AWS IoT Greengrass ソフトウェアを、起動時に実行されるシステムサービスとしてセットアップします。Linux デバイスでは、これは [Systemd](https://en.wikipedia.org/wiki/Systemd) init システムが必要です。
**重要**
Windows コアデバイスでは、 AWS IoT Greengrass Core ソフトウェアをシステムサービスとして設定する必要があります。
指定できる引数の詳細については、「[インストーラ引数](configure-installer.md)」を参照してください。
**注記**
メモリが制限された AWS IoT Greengrass デバイスで実行している場合は、 AWS IoT Greengrass Core ソフトウェアが使用するメモリ量を制御できます。メモリ割り当てを制御するには、nucleus コンポーネントの `jvmOptions` 設定パラメータで JVM ヒープのサイズオプションを設定できます。詳細については、「[JVM オプションでメモリ割り当てを制御する](configure-greengrass-core-v2.md#jvm-tuning)」を参照してください。
**AWS IoT Greengrass Core ソフトウェアをインストールするには (Linux)**
1. AWS IoT Greengrass Core ソフトウェアのバージョンを確認します。
+ *GreengrassInstaller* を、ソフトウェアが含まれるフォルダへのパスに置き換えます。
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
1. テキストエディタを使用し、`config.yaml` という名前の設定ファイルを作成してインストーラに提供します。
例えば、Linux ベースのシステムでは、次のコマンドを実行し、GNU nano を使用してファイルを作成できます。
```
nano GreengrassInstaller/config.yaml
```
次の YAML コンテンツをファイルにコピーします。
```
---
system:
rootpath: "/greengrass/v2"
# The following values are optional. Return them from the provisioning plugin or set them here.
# certificateFilePath: ""
# privateKeyPath: ""
# rootCaPath: ""
# thingName: ""
services:
aws.greengrass.Nucleus:
version: "2.16.1"
configuration:
# The following values are optional. Return them from the provisioning plugin or set them here.
# awsRegion: ""
# iotRoleAlias: ""
# iotDataEndpoint: ""
# iotCredEndpoint: ""
com.example.CustomProvisioning:
configuration:
# You can specify configuration parameters to provide to your plugin.
# pluginParameter: ""
```
次に、以下の操作を実行します。
+ *2.16.1* を AWS IoT Greengrass Core ソフトウェアのバージョンに置き換えます。
+ `/greengrass/v2` の各インスタンスを Greengrass のルートフォルダに置き換えます。
+ (オプション) システムおよび nucleus の設定値を指定します。プロビジョニングプラグインから提供されない場合には、これらの値を設定する必要があります。
+ (オプション) プロビジョニングプラグインに提供する設定パラメータを指定します。
**注記**
この設定ファイルでは、次の例で示されているように、使用するポートやネットワークプロキシなどの他の設定オプションをカスタマイズすることができます。詳細については、[Greengrass nucleus 設定](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration)を参照してください。
```
---
system:
rootpath: "/greengrass/v2"
# The following values are optional. Return them from the provisioning plugin or set them here.
# certificateFilePath: ""
# privateKeyPath: ""
# rootCaPath: ""
# thingName: ""
services:
aws.greengrass.Nucleus:
version: "2.16.1"
configuration:
mqtt:
port: 443
greengrassDataPlanePort: 443
networkProxy:
noProxyAddresses: "http://192.168.0.1,www.example.com"
proxy:
url: "http://my-proxy-server:1100"
username: "Mary_Major"
password: "pass@word1357"
# The following values are optional. Return them from the provisioning plugin or set them here.
# awsRegion: ""
# iotRoleAlias: ""
# iotDataEndpoint: ""
# iotCredEndpoint: ""
com.example.CustomProvisioning:
configuration:
# You can specify configuration parameters to provide to your plugin.
# pluginParameter: ""
```
1. インストーラーを実行します。`--trusted-plugin` を指定してカスタムプロビジョニングプラグインを提供し、`--init-config` を指定して設定ファイルを提供します。
**注記**
Windows では、パスの長さは 260 文字に制限されています。Windows を使用している場合は、`C:\greengrass\v2` や `D:\greengrass\v2` などのルートフォルダを使用して、Greengrass コンポーネントのパスを 260 文字の制限内に留めます。
+ `/greengrass/v2` または *C:\$1greengrass\$1v2* を Greengrass ルートフォルダに置き換えます。
+ *GreengrassInstaller* の各インスタンスをインストーラを解凍したフォルダに置き換えます。
+ カスタムプロビジョニングプラグイン JAR ファイルへのパスを、プラグインの JAR ファイルへのパスに置き換えます。
------
#### [ Linux or Unix ]
```
sudo -E java -Droot="/greengrass/v2" -Dlog.store=FILE \
-jar ./GreengrassInstaller/lib/Greengrass.jar \
--trusted-plugin /path/to/com.example.CustomProvisioning.jar \
--init-config ./GreengrassInstaller/config.yaml \
--component-default-user ggc_user:ggc_group \
--setup-system-service true
```
------
#### [ Windows Command Prompt (CMD) ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" ^
-jar ./GreengrassInstaller/lib/Greengrass.jar ^
--trusted-plugin /path/to/com.example.CustomProvisioning.jar ^
--init-config ./GreengrassInstaller/config.yaml ^
--component-default-user ggc_user ^
--setup-system-service true
```
------
#### [ PowerShell ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" `
-jar ./GreengrassInstaller/lib/Greengrass.jar `
--trusted-plugin /path/to/com.example.CustomProvisioning.jar `
--init-config ./GreengrassInstaller/config.yaml `
--component-default-user ggc_user `
--setup-system-service true
```
------
**重要**
Windows コアデバイスでは、 を指定`--setup-system-service true`して AWS IoT Greengrass Core ソフトウェアをシステムサービスとしてセットアップする必要があります。
`--setup-system-service true` を指定する場合、ソフトウェアをシステムサービスとしてセットアップして実行したら、インストーラは `Successfully set up Nucleus as a system service` を出力します。それ以外の場合、正常にソフトウェアがインストールされていれば、インストーラはメッセージを出力しません。
**注記**
`--provision true` 引数なしでインストーラを実行するとき、ローカル開発ツールをデプロイするために `deploy-dev-tools` 引数を使用できません。Greengrass CLI をデバイスに直接デプロイする方法の情報については、「[Greengrass コマンドラインインターフェイス](gg-cli.md)」を参照してください。
1. ルートフォルダのファイルを確認して、インストールを確認します。
------
#### [ Linux or Unix ]
```
ls /greengrass/v2
```
------
#### [ Windows Command Prompt (CMD) ]
```
dir C:\greengrass\v2
```
------
#### [ PowerShell ]
```
ls C:\greengrass\v2
```
------
インストールが正常に処理された場合、ルートフォルダには `config`、`packages`、`logs` などの複数のフォルダが含まれます。
AWS IoT Greengrass Core ソフトウェアをシステムサービスとしてインストールした場合、インストーラはソフトウェアを実行します。それ以外の場合、ソフトウェアを手動で実行する必要があります。詳細については、「[AWS IoT Greengrass Core ソフトウェアを実行する](run-greengrass-core-v2.md)」を参照してください。
ソフトウェアと を設定および使用する方法の詳細については AWS IoT Greengrass、以下を参照してください。
+ [AWS IoT Greengrass Core ソフトウェアを設定する](configure-greengrass-core-v2.md)
+ [AWS IoT Greengrass コンポーネントを開発する](develop-greengrass-components.md)
+ [AWS IoT Greengrass コンポーネントをデバイスにデプロイする](manage-deployments.md)
+ [Greengrass コマンドラインインターフェイス](gg-cli.md)
# カスタムプロビジョニングプラグインを開発する
カスタムプロビジョニングプラグインを開発するには、`com.aws.greengrass.provisioning.DeviceIdentityInterface` インターフェイスを実装する Java クラスを作成します。Greengrass nucleus JAR ファイルをプロジェクトに含めて、このインターフェイスとクラスにアクセスすることができます。このインターフェイスは、プラグイン設定を入力し、プロビジョニング設定を出力するメソッドを定義するためのものです。プロビジョニング設定では、システムと [Greengrass nucleus コンポーネント](greengrass-nucleus-component.md)の設定を定義します。 AWS IoT Greengrass Core ソフトウェアインストーラは、このプロビジョニング設定を使用して、デバイスで AWS IoT Greengrass Core ソフトウェアを設定します。
カスタムプロビジョニングプラグインを開発したら、インストール中にプラグインを実行するために AWS IoT Greengrass Core ソフトウェアインストーラに提供できる JAR ファイルとして構築します。インストーラは、インストーラが使用するものと同じ JVM でカスタムプロビジョニングプラグインを実行するため、プラグインコードのみが含まれた JAR を作成することができます。
**注記**
[AWS IoT フリートプロビジョニングプラグイン](fleet-provisioning.md)は、インストール中にフリートプロビジョニングを使用するため、`DeviceIdentityInterface` を実装します。フリートプロビジョニングプラグインはオープンソースであるため、ソースコードを確認して、プロビジョニングプラグインインターフェイスの使用方法例を見ることができます。詳細については、GitHub の「[AWS IoT フリートプロビジョニングプラグイン](https://github.com/aws-greengrass/aws-greengrass-fleet-provisioning-by-claim)」を参照してください。
**Topics**
+ [要件](#custom-provisioning-plugin-requirements)
+ [DeviceIdentityInterface インターフェイスを実装する](#implement-device-identity-interface)
## 要件
カスタムプロビジョニングプラグインを開発するには、次の要件を満たす Java クラスを作成する必要があります。
+ `com.aws.greengrass` パッケージ、または `com.aws.greengrass` パッケージ内のパッケージを使用します。
+ 引数を持たないコンストラクタが必要です。
+ `DeviceIdentityInterface` インターフェイスを実装します。詳細については、「[DeviceIdentityInterface インターフェイスを実装する](#implement-device-identity-interface)」を参照してください。
## DeviceIdentityInterface インターフェイスを実装する
カスタムプラグインで `com.aws.greengrass.provisioning.DeviceIdentityInterface` インターフェースを使用するには、Greengrass nucleus をプロジェクトの依存関係として追加します。
**カスタムプロビジョニングプラグインプロジェクトで DeviceIdentityInterface を使用するには**
+ Greengrass nucleus JAR ファイルをライブラリとして追加するか、Greengrass nucleus を Maven の依存関係として追加できます。次のいずれかを行います。
+ Greengrass nucleus JAR ファイルをライブラリとして追加するには、Greengrass nucleus JAR を含む AWS IoT Greengrass Core ソフトウェアをダウンロードします。 AWS IoT Greengrass Core ソフトウェアの最新バージョンは、次の場所からダウンロードできます。
+ [https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip](https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip)
Greengrass nucleus JAR ファイル (`Greengrass.jar`) は、ZIP ファイル内の `lib` フォルダにあります。この JAR ファイルをプロジェクトに追加します。
+ Maven プロジェクトで Greengrass nucleus を使用するには、`com.aws.greengrass` グループ内の `nucleus` アーティファクトに依存関係を追加します。また、Greengrass nucleus は Maven Central リポジトリでは利用できないため、`greengrass-common` レポジトリも追加する必要があります。
```
...
greengrass-common
greengrass common
https://d2jrmugq4soldf.cloudfront.net/snapshots
...
com.aws.greengrass
nucleus
2.5.0-SNAPSHOT
provided
```
### DeviceIdentityInterface インターフェイス
`com.aws.greengrass.provisioning.DeviceIdentityInterface` インターフェイスには、次のシェイプがあります。
**注記**
これらのクラスは、GitHub にある [Greengrass nucleus source code](https://github.com/aws-greengrass/aws-greengrass-nucleus) の [com.aws.greengrass.provisioning package](https://github.com/aws-greengrass/aws-greengrass-nucleus/tree/main/src/main/java/com/aws/greengrass/provisioning) でも確認できます。
```
public interface com.aws.greengrass.provisioning.DeviceIdentityInterface {
ProvisionConfiguration updateIdentityConfiguration(ProvisionContext context)
throws RetryableProvisioningException, InterruptedException;
// Return the name of the plugin.
String name();
}
com.aws.greengrass.provisioning.ProvisionConfiguration {
SystemConfiguration systemConfiguration;
NucleusConfiguration nucleusConfiguration
}
com.aws.greengrass.provisioning.ProvisionConfiguration.SystemConfiguration {
String certificateFilePath;
String privateKeyPath;
String rootCAPath;
String thingName;
}
com.aws.greengrass.provisioning.ProvisionConfiguration.NucleusConfiguration {
String awsRegion;
String iotCredentialsEndpoint;
String iotDataEndpoint;
String iotRoleAlias;
}
com.aws.greengrass.provisioning.ProvisioningContext {
Map parameterMap;
String provisioningPolicy; // The policy is always "PROVISION_IF_NOT_PROVISIONED".
}
com.aws.greengrass.provisioning.exceptions.RetryableProvisioningException {}
```
AWS IoT Greengrass Core ソフトウェアをインストールするには、 `SystemConfiguration`および の各設定値`NucleusConfiguration`が必要ですが、 を返すことができます`null`。カスタムプロビジョニングプラグインが設定値`null`に対して を返す場合は、 AWS IoT Greengrass Core ソフトウェアインストーラに提供する `config.yaml` ファイルを作成するときに、システムまたは nucleus 設定でその値を指定する必要があります。`config.yaml` で定義したオプションに対して、カスタムプロビジョニングプラグインが NULL 以外の値を返した場合、インストーラは `config.yaml` の値をプラグインから返された値に置き換えます。
# インストーラ引数
AWS IoT Greengrass Core ソフトウェアには、ソフトウェアをセットアップし、Greengrass コアデバイスを実行するのに必要となる AWS リソースをプロビジョニングするインストーラが含まれています。インストーラには、インストールを設定するために指定できる次の引数が含まれます。
`-h`, `--help`
(オプション) インストーラのヘルプ情報を表示します。
`--version`
(オプション) AWS IoT Greengrass Core ソフトウェアのバージョンを表示します。
`-Droot`
(オプション) AWS IoT Greengrass Core ソフトウェアのルートとして使用するフォルダへのパス。
この引数は JVM プロパティを設定するため、インストーラを実行するときに `-jar` より前に指定する必要があります。例えば、`java -Droot="/greengrass/v2" -jar /path/to/Greengrass.jar` と指定します。
デフォルト:
+ Linux: `~/.greengrass`
+ Windows: `%USERPROFILE%/.greengrass`
`-ar`, `--aws-region`
AWS IoT Greengrass Core ソフトウェアが、必要な AWS リソースを取得または作成するために使用する AWS リージョン。
`-p`, `--provision`
(オプション) このデバイスをAWS IoT モノとして登録し、コアデバイスが必要とする AWS リソースをプロビジョニングすることができます。`true` を指定すると、AWS IoT Greengrass Core ソフトウェアは、AWS IoT モノ、(オプションの) AWS IoT モノグループ、IAM ロール、および AWS IoT ロールエイリアスをプロビジョニングします。
デフォルト: `false`
`-tn`, `--thing-name`
(オプション) このコアデバイスとして登録する AWS IoT モノの名前。モノの名前が AWS アカウント に存在しない場合、AWS IoT Greengrass Core ソフトウェアが作成します。
モノの名前にコロン (`:`) 記号を含むことができません。
この引数を適用するには、`--provision true` を指定する必要があります。
デフォルト: `GreengrassV2IotThing_` とランダムな UUID。
`-tgn`, `--thing-group-name`
(オプション) このコアデバイスの AWS IoT モノを追加する AWS IoT モノグループの名前。デプロイがこのモノグループをターゲットにしている場合、このコアデバイスは、AWS IoT Greengrass に接続したときにそのデプロイを受け取ります。この名前のモノグループが AWS アカウント に存在しない場合、AWS IoT Greengrass Core ソフトウェアが作成します。
モノグループ名にコロン (`:`) 記号を含めることはできません。
この引数を適用するには、`--provision true` を指定する必要があります。
`-tpn`, `--thing-policy-name`
この機能は、[Greengrass nucleus コンポーネント](greengrass-nucleus-component.md)の v2.4.0 以降に利用できます。
(オプション) このコアデバイスの AWS IoT モノ証明書にアタッチする AWS IoT ポリシーの名前。この名前の AWS IoT ポリシーが AWS アカウント に存在しない場合、AWS IoT Greengrass Core ソフトウェアが作成します。
AWS IoT Greengrass Core ソフトウェアでは、デフォルトで寛容な AWS IoT ポリシーが作成されます。このポリシーの範囲を絞り込むか、ユースケースに応じた権限に制限するカスタムポリシーを作成することができます。詳細については、「[AWS IoT Greengrass V2 コアデバイスの最小 AWS IoT ポリシー](device-auth.md#greengrass-core-minimal-iot-policy)」を参照してください。
この引数を適用するには、`--provision true` を指定する必要があります。
デフォルト: `GreengrassV2IoTThingPolicy`
`-trn`, `--tes-role-name`
(オプション) コアデバイスが AWS サービスとやり取りするための AWS 認証情報を取得するために使用する IAM ロールの名前。この名前のロールが AWS アカウント に存在しない場合、AWS IoT Greengrass Core ソフトウェアが `GreengrassV2TokenExchangeRoleAccess` ポリシーを使ってロールを作成します。このロールは、コンポーネントのアーティファクトをホストする S3 バケットにはアクセスできません。そのため、コンポーネントを作成するときに、アーティファクトの S3 バケットとオブジェクトへのアクセス許可を追加する必要があります。詳細については、「[コアデバイスが AWS サービスとやり取りできるように認可する](device-service-role.md)」を参照してください。
この引数を適用するには、`--provision true` を指定する必要があります。
デフォルト: `GreengrassV2TokenExchangeRole`
`-tra`, `--tes-role-alias-name`
(オプション) このコアデバイスの AWS 認証情報を提供する IAM ロールを指している AWS IoT ロールエイリアスの名前。この名前のロールエイリアスが AWS アカウント に存在しない場合、AWS IoT Greengrass Core ソフトウェアはそれを作成し、指定されている IAM ロールを指すように設定します。
この引数を適用するには、`--provision true` を指定する必要があります。
デフォルト: `GreengrassV2TokenExchangeRoleAlias`
`-ss`, `--setup-system-service`
(オプション) AWS IoT Greengrass Core ソフトウェアは、このデバイスの起動時に実行されるシステムサービスとして設定することができます。システムサービス名は `greengrass` です。詳細については、「[Greengrass nucleus をシステムサービスとして設定する](configure-greengrass-core-v2.md#configure-system-service)」を参照してください。
Linux オペレーティングシステムでこの引数を使用する場合、systemd init システムがデバイス上で利用できる必要があります。
Windows コアデバイスでは、AWS IoT Greengrass Core ソフトウェアをシステムサービスとして設定する必要があります
デフォルト: `false`
`-u`, `--component-default-user`
AWS IoT Greengrass Core ソフトウェアがコンポーネントを実行するために使用するユーザーの名前または ID。例えば、**ggc\$1user** と指定することができます。この値は、Windows オペレーティングシステムでインストーラを実行するときに必要となります。
Linux オペレーティングシステムでは、オプションでグループを指定することもできます。ユーザーとグループをコロンで区切って指定します。例えば、**ggc\$1user:ggc\$1group**。
Linux オペレーティングシステムの場合、次の点についても考慮する必要があります。
+ root として実行する場合、デフォルトのコンポーネントユーザーが設定ファイルで定義されたユーザーになります。設定ファイルでユーザーが定義されていない場合、デフォルトの `ggc_user:ggc_group` になります。もし `ggc_user` または `ggc_group` が存在しない場合は、ソフトウェアが作成します。
+ 非ルートユーザーとして実行すると、AWS IoT Greengrass Core ソフトウェアはそのユーザーとしてコンポーネントを実行します。
+ グループを指定しなかった場合、AWS IoT Greengrass Core ソフトウェアは、システムユーザーのプライマリグループを使用します。
詳細については、「[コンポーネントを実行するユーザーを設定する](configure-greengrass-core-v2.md#configure-component-user)」を参照してください。
`-d`, `--deploy-dev-tools`
(オプション) [Greengrass CLI](greengrass-cli-component.md) コンポーネントをダウンロードして、このコアデバイスにデプロイできます。このツールを使用して、このコアデバイス上でコンポーネントを開発したりデバッグしたりできます。
このコンポーネントは、本番環境ではなく、開発環境でのみで使用することをお勧めします。このコンポーネントは、通常、本番環境では必要とされない情報や操作へのアクセスを提供します。このコンポーネントを必要なコアデバイスにのみデプロイして、最小特権の原則に従います。
この引数を適用するには、`--provision true` を指定する必要があります。
デフォルト: `false`
`-init`, `--init-config`
(オプション) AWS IoT Greengrass Core ソフトウェアのインストールに使用する設定ファイルへのパス。このオプションを使用すると、特定の nucleus 設定された新しいコアデバイスなどを、設定することができます。
指定した設定ファイルとコアデバイス上の既存の設定ファイルがマージされます。これには、コアデバイス上のコンポーネントとコンポーネント設定が含まれます。設定ファイルには、変更しようとしている設定だけをリストすることをおすすめします。
`-tp`, `--trusted-plugin`
(オプション) 信頼されたプラグインとして読み込む JAR ファイルへのパス。このオプションは、[フリートプロビジョニング](fleet-provisioning.md)または[カスタムプロビジョニング](custom-provisioning.md)でインストールする場合、または[ハードウェアセキュリティモジュール](hardware-security.md)でプライベートキーと証明書を使用してインストールする場合など、プロビジョニングプラグインの JAR ファイルを提供するために使用します。
`-s`, `--start`
(オプション) AWS IoT Greengrass Core ソフトウェアのインストール後に起動し、オプションでリソースをプロビジョニングすることができます。
デフォルト: `true`
# AWS IoT Greengrass Core ソフトウェアを実行する
[AWS IoT Greengrass Core ソフトウェアをインストール](install-greengrass-core-v2.md)したら、それを実行してデバイスを に接続します AWS IoT Greengrass。
AWS IoT Greengrass Core ソフトウェアをインストールするときに、[systemd](https://en.wikipedia.org/wiki/Systemd) でシステムサービスとしてインストールするかどうかを指定できます。このオプションを選択すると、インストーラがソフトウェアを実行し、デバイスの起動時に実行するように設定します。
**重要**
Windows コアデバイスでは、 AWS IoT Greengrass Core ソフトウェアをシステムサービスとして設定する必要があります。
**Topics**
+ [AWS IoT Greengrass Core ソフトウェアがシステムサービスとして実行されているかどうかを確認する](#check-system-service)
+ [AWS IoT Greengrass Core ソフトウェアをシステムサービスとして実行する](#run-greengrass-core-system-service)
+ [システムサービスなしで AWS IoT Greengrass Core ソフトウェアを実行する](#run-greengrass-core-no-system-service)
## AWS IoT Greengrass Core ソフトウェアがシステムサービスとして実行されているかどうかを確認する
AWS IoT Greengrass Core ソフトウェアをインストールするときに、 `--setup-system-service true`引数を指定して AWS IoT Greengrass Core ソフトウェアをシステムサービスとしてインストールできます。Linux デバイスでは、[システムサービスとして Core ソフトウェアをセットアップするために systemd](https://en.wikipedia.org/wiki/Systemd) init システムが必要です。 AWS IoT Greengrass このオプションを使用すると、インストーラがソフトウェアを実行し、デバイスの起動時に実行するように設定します。Core AWS IoT Greengrass ソフトウェアをシステムサービスとして正常にインストールすると、インストーラは次のメッセージを出力します。
```
Successfully set up Nucleus as a system service
```
Core AWS IoT Greengrass ソフトウェアを以前にインストールしていて、インストーラ出力がない場合は、ソフトウェアがシステムサービスとしてインストールされているかどうかを確認できます。
**AWS IoT Greengrass Core ソフトウェアがシステムサービスとしてインストールされているかどうかを確認するには**
+ 次のコマンドを実行して、Greengrass システムサービスの状態を確認します。
------
#### [ Linux or Unix (systemd) ]
```
sudo systemctl status greengrass.service
```
AWS IoT Greengrass Core ソフトウェアがシステムサービスとしてインストールされ、アクティブになっている場合、レスポンスは次の例のようになります。
```
● greengrass.service - Greengrass Core
Loaded: loaded (/etc/systemd/system/greengrass.service; enabled; vendor preset: disabled)
Active: active (running) since Thu 2021-02-11 01:33:44 UTC; 4 days ago
Main PID: 16107 (sh)
CGroup: /system.slice/greengrass.service
├─16107 /bin/sh /greengrass/v2/alts/current/distro/bin/loader
└─16111 java -Dlog.store=FILE -Droot=/greengrass/v2 -jar /greengrass/v2/alts/current/distro/lib/Greengrass...
```
`systemctl` または `greengrass.service`が見つからない場合、 AWS IoT Greengrass Core ソフトウェアはシステムサービスとしてインストールされません。ソフトウェアを実行するには、「[システムサービスなしで AWS IoT Greengrass Core ソフトウェアを実行する](#run-greengrass-core-no-system-service)」を参照してください。
------
#### [ Windows Command Prompt (CMD) ]
```
sc query greengrass
```
AWS IoT Greengrass Core ソフトウェアが Windows サービスとしてインストールされ、アクティブになっている場合、レスポンスは次の例のようになります。
```
SERVICE_NAME: greengrass
TYPE : 10 WIN32_OWN_PROCESS
STATE : 4 RUNNING
(STOPPABLE, NOT_PAUSABLE, ACCEPTS_SHUTDOWN)
WIN32_EXIT_CODE : 0 (0x0)
SERVICE_EXIT_CODE : 0 (0x0)
CHECKPOINT : 0x0
WAIT_HINT : 0x0
```
------
#### [ PowerShell ]
```
Get-Service greengrass
```
AWS IoT Greengrass Core ソフトウェアが Windows サービスとしてインストールされ、アクティブになっている場合、レスポンスは次の例のようになります。
```
Status Name DisplayName
------ ---- -----------
Running greengrass greengrass
```
------
## AWS IoT Greengrass Core ソフトウェアをシステムサービスとして実行する
AWS IoT Greengrass Core ソフトウェアがシステムサービスとしてインストールされている場合は、システムサービスマネージャーを使用してソフトウェアを起動、停止、管理できます。詳細については、「[Greengrass nucleus をシステムサービスとして設定する](configure-greengrass-core-v2.md#configure-system-service)」を参照してください。
**AWS IoT Greengrass Core ソフトウェアを実行するには**
+ 次のコマンドを実行して AWS IoT Greengrass Core ソフトウェアを起動します。
------
#### [ Linux or Unix (systemd) ]
```
sudo systemctl start greengrass.service
```
------
#### [ Windows Command Prompt (CMD) ]
```
sc start greengrass
```
------
#### [ PowerShell ]
```
Start-Service greengrass
```
------
## システムサービスなしで AWS IoT Greengrass Core ソフトウェアを実行する
Linux コアデバイスでは、 AWS IoT Greengrass Core ソフトウェアがシステムサービスとしてインストールされていない場合、ソフトウェアのローダースクリプトを実行してソフトウェアを実行できます。
**システムサービスなしで AWS IoT Greengrass Core ソフトウェアを実行するには**
+ 次のコマンドを実行して AWS IoT Greengrass Core ソフトウェアを起動します。ターミナルでこのコマンドを実行する場合は、ターミナルセッションを開いたままにして AWS IoT Greengrass Core ソフトウェアを実行し続ける必要があります。
+ `/greengrass/v2` または *C:\$1greengrass\$1v2* を、使用する Greengrass ルートフォルダに置き換えます。
```
sudo /greengrass/v2/alts/current/distro/bin/loader
```
正常に起動すると、ソフトウェアは次のメッセージを出力します。
```
Launched Nucleus successfully.
```
# Docker コンテナで AWS IoT Greengrass Core ソフトウェアを実行する
AWS IoT Greengrass は、Docker コンテナで実行するように設定できます。Docker は、Linux コンテナに基づくアプリケーションの構築、実行、テスト、およびデプロイを行うためのツールを提供するプラットフォームです。 AWS IoT Greengrass Docker イメージを実行するときに、Docker コンテナに AWS 認証情報を提供するかどうかを選択し、 AWS IoT Greengrass Core ソフトウェアインストーラが Greengrass コアデバイスが動作するために必要なリソースを自動的にプロビジョニング AWS できるようにします。認証情報を提供し AWS ない場合は、 AWS リソースを手動でプロビジョニングし、Docker コンテナで AWS IoT Greengrass Core ソフトウェアを実行できます。
**Topics**
+ [サポートされているプラットフォームと要件](#greengrass-docker-supported-platforms)
+ [ソフトウェアダウンロード](#greengrass-docker-downloads)
+ [AWS リソースをプロビジョニングする方法を選択する](#greengrass-docker-resource-provisioning)
+ [Dockerfile から AWS IoT Greengrass イメージを構築する](build-greengrass-dockerfile.md)
+ [自動プロビジョニングを使用して Docker AWS IoT Greengrass で を実行する](run-greengrass-docker-automatic-provisioning.md)
+ [手動プロビジョニングを使用して Docker AWS IoT Greengrass で を実行する](run-greengrass-docker-manual-provisioning.md)
+ [Docker コンテナ AWS IoT Greengrass でのトラブルシューティング](docker-troubleshooting.md)
## サポートされているプラットフォームと要件
Core ソフトウェアを AWS IoT Greengrass Docker コンテナにインストールして実行するには、ホストコンピュータが以下の最小要件を満たしている必要があります。
+ インターネットに接続された Linux ベースのオペレーティングシステム。
+ [Docker Engine](https://docs.docker.com/engine/install/) バージョン 18.09 以降。
+ (オプション) [Docker Compose](https://docs.docker.com/compose/install/) バージョン 1.22 以降。Docker Compose は、Docker Compose CLI を使用して Docker イメージを実行する場合のみ必要です。
Docker コンテナ内で Lambda 関数コンポーネントを実行するには、追加の要件を満たすようにコンテナを設定する必要があります。詳細については、「[Lambda 関数の要件](setting-up.md#greengrass-v2-lambda-requirements)」を参照してください。
### プロセスモードでコンポーネントを実行する
AWS IoT Greengrass は、Docker コンテナ内の分離されたランタイム環境での Lambda AWS IoT Greengrass 関数または AWS提供コンポーネントの実行をサポートしていません。これらのコンポーネントは、分離せずにプロセスモードで実行する必要があります。
Lambda 関数コンポーネントを設定するときは、分離モードを **[No container]** (コンテナなし) に設定します。詳細については、「[AWS Lambda 関数を実行する](run-lambda-functions.md)」を参照してください。
以下 AWSが提供するコンポーネントのいずれかをデプロイするときは、各コンポーネントの設定を更新して、 `containerMode`パラメータを に設定します`NoContainer`。設定の更新の詳細については、「[コンポーネント設定の更新](update-component-configurations.md)」を参照してください。
+ [CloudWatch メトリクス](cloudwatch-metrics-component.md)
+ [Device Defender](device-defender-component.md)
+ [Firehose](kinesis-firehose-component.md)
+ [Modbus-RTU プロトコルアダプタ](modbus-rtu-protocol-adapter-component.md)
+ [Amazon SNS](sns-component.md)
## AWS IoT Greengrass Docker ソフトウェアのダウンロード
AWS IoT Greengrass には、Amazon Linux 2 (x86\$164) ベースイメージに AWS IoT Greengrass Core ソフトウェアと依存関係がインストールされているコンテナイメージを構築するための Dockerfile が用意されています。Dockerfile のベースイメージを変更して、別のプラットフォームアーキテクチャ AWS IoT Greengrass で実行できます。
Dockerfile パッケージを、[GitHub](https://github.com/aws-greengrass/aws-greengrass-docker) からダウンロードします。
Dockerfile は古いバージョンの Greengrass を使用しています。必要なバージョンの Greengrass を使用するようにファイルを更新する必要があります。Dockerfile から AWS IoT Greengrass コンテナイメージを構築する方法については、「」を参照してください[Dockerfile から AWS IoT Greengrass コンテナイメージを構築する](build-greengrass-dockerfile.md)。
## AWS リソースをプロビジョニングする方法を選択する
AWS IoT Greengrass Core ソフトウェアを Docker コンテナにインストールする場合、Greengrass コアデバイスが動作するために必要な AWS リソースを自動的にプロビジョニングするか、手動でプロビジョニングしたリソースを使用するかを選択できます。
+ **自動リソースプロビジョニング** — インストーラは、 AWS IoT Greengrass コンテナイメージを初めて実行するときに、 AWS IoT モノ、 AWS IoT モノのグループ、IAM ロール、および AWS IoT ロールエイリアスをプロビジョニングします。インストーラは、ローカル開発ツールをコアデバイスにデプロイすることもできるため、デバイスを使用してカスタムソフトウェアコンポーネントを開発とテストできます。これらのリソースを自動的にプロビジョニングするには、Docker イメージに環境変数として AWS 認証情報を提供する必要があります。
自動プロビジョニングを使用するには、Docker 環境変数 `PROVISION=true` を設定し、認証ファイルをマウントして、 AWS 認証情報をコンテナに提供する必要があります。
+ **手動リソースプロビジョニング** — コンテナに AWS 認証情報を提供しない場合は、 AWS IoT Greengrass コンテナイメージを実行する前にリソースを手動でプロビジョニング AWS できます。これらのリソースに関する情報を Docker コンテナ内の AWS IoT Greengrass Core ソフトウェアインストーラに提供するには、設定ファイルを作成する必要があります。
手動プロビジョニングを使用するには、Docker 環境変数 `PROVISION=false` を設定する必要があります。手動プロビジョニングがデフォルトのオプションです。
詳細については、「[Dockerfile から AWS IoT Greengrass コンテナイメージを構築する](build-greengrass-dockerfile.md)」を参照してください。
# Dockerfile から AWS IoT Greengrass コンテナイメージを構築する
AWS には、Docker コンテナで AWS IoT Greengrass Core ソフトウェアをダウンロードして実行するために使用できる Dockerfile が用意されています。Dockerfiles には、 AWS IoT Greengrass コンテナイメージを構築するためのソースコードが含まれています。
AWS IoT Greengrass コンテナイメージを構築する前に、インストールする AWS IoT Greengrass Core ソフトウェアのバージョンを選択するように Dockerfile を設定する必要があります。また、環境変数を設定することで、インストール時のリソースのプロビジョニング方法を選択したり、他のインストールオプションをカスタマイズすることもできます。このセクションでは、Dockerfile AWS IoT Greengrass から Docker イメージを設定および構築する方法について説明します。
## Dockerfile パッケージをダウンロードする
Dockerfile AWS IoT Greengrass パッケージは GitHub からダウンロードできます。
[AWS Greengrass Docker リポジトリ](https://github.com/aws-greengrass/aws-greengrass-docker)
パッケージをダウンロードしたら、コンテンツをコンピュータ上の `download-directory/aws-greengrass-docker-nucleus-version` フォルダに抽出します。Dockerfile は古いバージョンの Greengrass を使用しています。必要なバージョンの Greengrass を使用するようにファイルを更新する必要があります。
## AWS IoT Greengrass Core ソフトウェアバージョンを指定する
Dockerfile で次のビルド引数を使用して、Docker イメージで使用する AWS IoT Greengrass Core AWS IoT Greengrass ソフトウェアのバージョンを指定します。デフォルトでは、Dockerfile は最新バージョンの AWS IoT Greengrass Core ソフトウェアを使用します。
`GREENGRASS_RELEASE_VERSION`
AWS IoT Greengrass Core ソフトウェアのバージョン。デフォルトでは、Dockerfile は Greengrass nucleus の利用可能な最新バージョンをダウンロードします。この値を、ダウンロードする nucleus のバージョンに設定します。
## 環境変数を設定する
環境変数を使用すると、Docker コンテナに AWS IoT Greengrass Core ソフトウェアをインストールする方法をカスタマイズできます。Docker AWS IoT Greengrass イメージの環境変数は、さまざまな方法で設定できます。
+ 同じ環境変数を使用して複数のイメージを作成するには、Dockerfile で環境変数を直接設定します。
+ `docker run` を使用してコンテナを開始するには、コマンドで環境変数を引数として渡すか、環境変数ファイルで環境変数を設定してから、そのファイルを引数として渡します。Docker で環境変数を設定するための詳細については、Docker ドキュメントの「[environment variables](https://docs.docker.com/engine/reference/commandline/run/#env)」を参照してください。
+ `docker-compose up` を使用してコンテナを開始するには、環境変数ファイルで環境変数を設定してから、そのファイルを引数として渡します。Compose で環境変数を設定するための詳細については、「[Docker ドキュメント](https://docs.docker.com/compose/environment-variables/)」を参照してください。
AWS IoT Greengrass Docker イメージには、次の環境変数を設定できます。
**注記**
Dockerfile の `TINI_KILL_PROCESS_GROUP` 変数は変更しないでください。この変数を使用すると、PIDs グループ内のすべての PID `SIGTERM`に転送できるため、Docker コンテナが停止したときに AWS IoT Greengrass Core ソフトウェアが正しくシャットダウンできます。
`GGC_ROOT_PATH`
(オプション) AWS IoT Greengrass Core ソフトウェアのルートとして使用するコンテナ内のフォルダへのパス。
デフォルト: `/greengrass/v2`
`PROVISION`
(オプション) AWS IoT Greengrass Core が AWS リソースをプロビジョニングするかどうかを決定します。
+ を指定すると`true`、 AWS IoT Greengrass Core ソフトウェアはコンテナイメージを AWS IoT モノとして登録し、Greengrass コアデバイスが必要とする AWS リソースをプロビジョニングします。 AWS IoT Greengrass Core ソフトウェアは、 AWS IoT モノ、 AWS IoT モノのグループ、IAM ロール、および AWS IoT ロールエイリアスをプロビジョニングします (オプション）。詳細については、「[自動リソースプロビジョニングを使用して Docker コンテナ AWS IoT Greengrass で を実行する](run-greengrass-docker-automatic-provisioning.md)」を参照してください。
+ を指定する場合は`false`、手動で作成した AWS リソースと証明書を使用するように指定する設定ファイルを AWS IoT Greengrass Core インストーラに提供する必要があります。詳細については、「[手動リソースプロビジョニングを使用して Docker コンテナ AWS IoT Greengrass で を実行する](run-greengrass-docker-manual-provisioning.md)」を参照してください。
デフォルト: `false`
`AWS_REGION`
(オプション) AWS IoT Greengrass Core ソフトウェア AWS リージョン が必要な AWS リソースを取得または作成するために使用する 。
デフォルト: `us-east-1`。
`THING_NAME`
(オプション) このコアデバイスとして登録する AWS IoT モノの名前。この名前のモノが に存在しない場合 AWS アカウント、 AWS IoT Greengrass Core ソフトウェアによって作成されます。
この引数を適用するには、`PROVISION=true` を指定する必要があります。
デフォルト: `GreengrassV2IotThing_` とランダムな UUID。
`THING_GROUP_NAME`
(オプション) このコアデバイスの AWS IoT を追加する AWS IoT モノのグループの名前 デプロイがこのモノのグループをターゲットにしている場合、このグループとそのグループの他のコアデバイスは、接続時にそのデプロイを受け取ります AWS IoT Greengrass。この名前のモノのグループが に存在しない場合 AWS アカウント、 AWS IoT Greengrass Core ソフトウェアによって作成されます。
この引数を適用するには、`PROVISION=true` を指定する必要があります。
`TES_ROLE_NAME`
(オプション) Greengrass コアデバイスが AWS サービスとやり取りできるようにする AWS 認証情報を取得するために使用する IAM ロールの名前。この名前のロールが に存在しない場合 AWS アカウント、 AWS IoT Greengrass Core ソフトウェアはそれを `GreengrassV2TokenExchangeRoleAccess`ポリシーで作成します。このロールは、コンポーネントのアーティファクトをホストする S3 バケットにはアクセスできません。そのため、コンポーネントを作成するときに、アーティファクトの S3 バケットとオブジェクトへのアクセス許可を追加する必要があります。詳細については、「[コアデバイスが AWS サービスとやり取りできるように認可する](device-service-role.md)」を参照してください。
デフォルト: `GreengrassV2TokenExchangeRole`
`TES_ROLE_ALIAS_NAME`
(オプション) Greengrass コアデバイスの AWS 認証情報を提供する AWS IoT IAM ロールを指すロールエイリアスの名前。この名前のロールエイリアスが に存在しない場合 AWS アカウント、 AWS IoT Greengrass Core ソフトウェアによって作成され、指定した IAM ロールにポイントされます。
デフォルト: `GreengrassV2TokenExchangeRoleAlias`
`COMPONENT_DEFAULT_USER`
(オプション) AWS IoT Greengrass Core ソフトウェアがコンポーネントの実行に使用するシステムユーザーとグループの名前または ID。ユーザーとグループは、コロンで区切って指定します。グループはオプションです。たとえば、**ggc\$1user:ggc\$1group** や **ggc\$1user** と指定することができます。
+ root として実行した場合、設定ファイルで定義したユーザーとグループがデフォルトとなります。設定ファイルでユーザーとグループが定義されていない場合、デフォルトは `ggc_user:ggc_group` になります。もし `ggc_user` または `ggc_group` が存在しない場合は、ソフトウェアが作成します。
+ ルート以外のユーザーとして を実行すると、 AWS IoT Greengrass Core ソフトウェアはそのユーザーを使用してコンポーネントを実行します。
+ グループを指定しない場合、 AWS IoT Greengrass Core ソフトウェアはシステムユーザーのプライマリグループを使用します。
詳細については、「[コンポーネントを実行するユーザーを設定する](configure-greengrass-core-v2.md#configure-component-user)」を参照してください。
`DEPLOY_DEV_TOOLS`
[Greengrass CLI コンポーネント](greengrass-cli-component.md)をコンテナイメージにダウンロードし、デプロイするかどうかを定義します。Greengrass CLI を使用して、コンポーネントをローカルで開発およびデバッグすることができます。
このコンポーネントは、本番環境ではなく、開発環境でのみで使用することをお勧めします。このコンポーネントは、通常、本番環境では必要とされない情報や操作へのアクセスを提供します。このコンポーネントを必要なコアデバイスにのみデプロイして、最小特権の原則に従います。
デフォルト: `false`
`INIT_CONFIG`
(オプション) AWS IoT Greengrass Core ソフトウェアのインストールに使用する設定ファイルへのパス。このオプションを使用して、特定の nucleus 設定で新しい Greengrass コアデバイスをセットアップしたり、手動でプロビジョニングされたリソースを指定したりできます。設定ファイルは、この引数で指定したパスにマウントする必要があります。
`TRUSTED_PLUGIN`
この機能は、[Greengrass nucleus コンポーネント](greengrass-nucleus-component.md)の v2.4.0 以降に利用できます。
(オプション) 信頼されたプラグインとして読み込む JAR ファイルへのパス。[フリートプロビジョニング](fleet-provisioning.md)や[カスタムプロビジョニング](custom-provisioning.md)でインストールする場合など、プロビジョニングプラグインの JAR ファイルを提供する場合にこのオプションを使用します。
`THING_POLICY_NAME`
この機能は、[Greengrass nucleus コンポーネント](greengrass-nucleus-component.md)の v2.4.0 以降に利用できます。
(オプション) このコアデバイスの AWS IoT モノ証明書にアタッチする AWS IoT ポリシーの名前。この名前の AWS IoT ポリシーが AWS IoT Greengrass Core ソフトウェアに存在しない場合は AWS アカウント 、作成します。
この引数を適用するには、`PROVISION=true` を指定する必要があります。
AWS IoT Greengrass Core ソフトウェアは、デフォルトで許可 AWS IoT ポリシーを作成します。このポリシーの範囲を絞り込むか、ユースケースに応じた権限に制限するカスタムポリシーを作成することができます。詳細については、「[AWS IoT Greengrass V2 コアデバイスの最小 AWS IoT ポリシー](device-auth.md#greengrass-core-minimal-iot-policy)」を参照してください。
## インストールする依存関係を指定する
Dockerfile の RUN AWS IoT Greengrass 命令は、 AWS IoT Greengrass Core ソフトウェアインストーラを実行するコンテナ環境を準備します。Docker コンテナで AWS IoT Greengrass Core ソフトウェアのインストーラを実行する前に、インストールされる依存関係をカスタマイズできます。
## AWS IoT Greengrass イメージの構築
AWS IoT Greengrass Dockerfile を使用して AWS IoT Greengrass コンテナイメージを構築します。Docker CLI または Docker Compose CLI を使用してイメージを構築し、コンテナを開始することができます。また、Docker CLI を使用してイメージを構築し、その後 Docker Compose を使用してそのイメージからコンテナを開始することもできます。
------
#### [ Docker ]
1. ホストマシンで次のコマンドを実行し、設定した Dockerfile が含まれるディレクトリに切り替えます。
```
cd download-directory/aws-greengrass-docker-nucleus-version
```
1. 次のコマンドを実行して、Dockerfile から AWS IoT Greengrass コンテナイメージを構築します。
```
sudo docker build -t "platform/aws-iot-greengrass:nucleus-version" ./
```
------
#### [ Docker Compose ]
1. ホストマシンで次のコマンドを実行し、Dockerfile ファイルと Compose ファイルが含まれてるディレクトリに切り替えます。
```
cd download-directory/aws-greengrass-docker-nucleus-version
```
1. 次のコマンドを実行して、Compose ファイルを使用して AWS IoT Greengrass コンテナイメージを構築します。
```
docker-compose -f docker-compose.yml build
```
------
AWS IoT Greengrass コンテナイメージが正常に作成されました。Docker イメージには AWS IoT Greengrass Core ソフトウェアがインストールされています。Core AWS IoT Greengrass ソフトウェアを Docker コンテナで実行できるようになりました。
# 自動リソースプロビジョニングを使用して Docker コンテナ AWS IoT Greengrass で を実行する
このチュートリアルでは、自動的にプロビジョニングされた AWS リソースとローカル開発ツールを使用して、Docker コンテナに AWS IoT Greengrass Core ソフトウェアをインストールして実行する方法について説明します。この開発環境を使用して、Docker コンテナ AWS IoT Greengrass の機能を調べることができます。ソフトウェアには、これらのリソースをプロビジョニングし、ローカル開発ツールをデプロイするための AWS 認証情報が必要です。
コンテナに AWS 認証情報を提供できない場合は、コアデバイスが動作するために必要なリソースをプロビジョニング AWS できます。開発ツールをコアデバイスにデプロイして、開発デバイスとして使用することもできます。これにより、コンテナの実行時にデバイスに付与するアクセス許可を減らすことができます。詳細については、「[手動リソースプロビジョニングを使用して Docker コンテナ AWS IoT Greengrass で を実行する](run-greengrass-docker-manual-provisioning.md)」を参照してください。
## 前提条件
このチュートリアルを完了するには、以下が必要です。
+ AWS アカウント。アカウントをお持ちでない場合は、「[のセットアップ AWS アカウント](setting-up.md#set-up-aws-account)」を参照してください。
+ Greengrass AWS コアデバイスの AWS IoT および IAM リソースをプロビジョニングするアクセス許可を持つ IAM ユーザー。 AWS IoT Greengrass Core ソフトウェアインストーラは、認証情報 AWS を使用してこれらのリソースを自動的にプロビジョニングします。リソースを自動的にプロビジョニングする最小の IAM ポリシーの詳細については、「[インストーラがリソースをプロビジョニングするための最小限の IAM ポリシー](provision-minimal-iam-policy.md)」を参照してください。
+ Docker AWS IoT Greengrass イメージ。[Dockerfile AWS IoT Greengrass からイメージを構築](build-greengrass-dockerfile.md)できます。
+ Docker コンテナを実行するホストコンピュータは、以下の要件を満たしている必要があります。
+ インターネットに接続された Linux ベースのオペレーティングシステム。
+ [Docker Engine](https://docs.docker.com/engine/install/) バージョン 18.09 以降。
+ (オプション) [Docker Compose](https://docs.docker.com/compose/install/) バージョン 1.22 以降。Docker Compose は、Docker Compose CLI を使用して Docker イメージを実行する場合のみ必要です。
## AWS 認証情報を設定する
このステップでは、 AWS セキュリティ認証情報を含む認証情報ファイルをホストコンピュータに作成します。 AWS IoT Greengrass Docker イメージを実行するときは、この認証情報ファイルを含むフォルダを Docker コンテナ`/root/.aws/`の にマウントする必要があります。 AWS IoT Greengrass インストーラは、これらの認証情報を使用して のリソースをプロビジョニングします AWS アカウント。インストーラがリソースを自動的にプロビジョニングするために必要な最小 IAM ポリシーについては、「[インストーラがリソースをプロビジョニングするための最小限の IAM ポリシー](provision-minimal-iam-policy.md)」を参照してください。
1. 次のいずれかを取得します。
+ IAM ユーザーの長期的な認証情報。長期認証情報を取得する方法については、「*IAM ユーザーガイド*」の「[IAM ユーザーのアクセスキーを管理します。](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html)」を参照してください。
+ (推奨) IAM ロールの一時的な認証情報。一時的な認証情報を取得する方法については、「*IAM ユーザーガイド*」の「[AWS CLIで一時的なセキュリティ認証情報を使用する](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html#using-temp-creds-sdk-cli)」を参照してください。
1. 認証情報ファイルを配置するフォルダを作成します。
```
mkdir ./greengrass-v2-credentials
```
1. テキストエディタを使用して、`./greengrass-v2-credentials` フォルダに `credentials` という名前の設定ファイルを作成します。
例えば、次のコマンドを実行し、GNU nano を使用して `credentials` ファイルを作成できます。
```
nano ./greengrass-v2-credentials/credentials
```
1. 次の形式で AWS 認証情報を `credentials` ファイルに追加します。
```
[default]
aws_access_key_id = AKIAIOSFODNN7EXAMPLE
aws_secret_access_key = wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
aws_session_token = AQoEXAMPLEH4aoAH0gNCAPy...truncated...zrkuWJOgQs8IZZaIv2BXIa2R4Olgk
```
一時的な認証情報の場合のみ `aws_session_token` を含めます。
**重要**
AWS IoT Greengrass コンテナを起動したら、ホストコンピュータから認証情報ファイルを削除します。認証情報ファイルを削除しない場合、 AWS 認証情報はコンテナ内にマウントされたままになります。詳細については、「[コンテナで AWS IoT Greengrass Core ソフトウェアを実行する](#run-greengrass-image-automatic-provisioning)」を参照してください。
## 環境ファイルを作成する
このチュートリアルでは、環境ファイルを使用して、Docker コンテナ内の AWS IoT Greengrass Core ソフトウェアインストーラに渡される環境変数を設定します。また、`docker run` コマンドで [`-e` または `--env` 引数](https://docs.docker.com/engine/reference/commandline/run/#env)を使用して、Docker コンテナに環境変数を設定する、または `docker-compose.yml` ファイルの [`environment` ブロック](https://docs.docker.com/compose/compose-file/compose-file-v3/#environment)で変数を設定することもできます。
1. テキストエディタを使用して、`.env` という名前の環境ファイルを作成します。
例えば、Linux ベースのシステムでは、次のコマンドを実行し、GNU nano を使用して現在のディレクトリに `.env` を作成できます。
```
nano .env
```
1. 次の内容をファイルにコピーします。
```
GGC_ROOT_PATH=/greengrass/v2
AWS_REGION=region
PROVISION=true
THING_NAME=MyGreengrassCore
THING_GROUP_NAME=MyGreengrassCoreGroup
TES_ROLE_NAME=GreengrassV2TokenExchangeRole
TES_ROLE_ALIAS_NAME=GreengrassCoreTokenExchangeRoleAlias
COMPONENT_DEFAULT_USER=ggc_user:ggc_group
```
次に、以下の値を置き換えます。
+ `/greengrass/v2`。インストールに使用する Greengrass ルートフォルダ。`GGC_ROOT` 環境変数を使用して、この値を設定します。
+ *リージョン*。リソースを作成した AWS リージョン 。
+ *MyGreengrassCore*。 AWS IoT モノの名前。モノが存在しない場合、インストーラによって作成されます。インストーラは証明書をダウンロードして AWS IoT 、モノとして認証します。
+ *MyGreengrassCoreGroup*。 AWS IoT モノのグループの名前。モノグループが存在しない場合、インストーラはそのグループを作成してモノを追加します。モノグループが存在してアクティブなデプロイがある場合、コアデバイスはデプロイで指定されたソフトウェアをダウンロードして実行します。
+ *GreengrassV2TokenExchangeRole*。Greengrass コアデバイスが一時的な AWS 認証情報を取得できるようにする IAM トークン交換ロールの名前に置き換えます。ロールが存在しない場合、インストーラがロールを作成し、*GreengrassV2TokenExchangeRole* という名前のポリシーを作成してアタッチします。詳細については、「[コアデバイスが AWS サービスとやり取りできるように認可する](device-service-role.md)」を参照してください。
+ *GreengrassCoreTokenExchangeRoleAlias*。トークン交換ロールエイリアス。ロールエイリアスが存在しない場合、インストーラがロールエイリアスを作成し、指定した IAM トークン交換ロールを指します。詳細については、以下を参照してください。
**注記**
`DEPLOY_DEV_TOOLS` 環境変数を `true` に設定して、[[Greengrass CLI component]](greengrass-cli-component.md) (Greengrass CLI コンポーネント) をデプロイできます。これにより、Docker コンテナ内でカスタムコンポーネントを開発できます。このコンポーネントは、本番環境ではなく、開発環境でのみで使用することをお勧めします。このコンポーネントは、通常、本番環境では必要とされない情報や操作へのアクセスを提供します。このコンポーネントを必要なコアデバイスにのみデプロイして、最小特権の原則に従います。
## コンテナで AWS IoT Greengrass Core ソフトウェアを実行する
このチュートリアルでは、Docker コンテナでビルドした Docker イメージを起動する方法を説明します。Docker CLI または Docker Compose CLI を使用して、Docker コンテナで AWS IoT Greengrass Core ソフトウェアイメージを実行できます。
------
#### [ Docker ]
1. 次のコマンドを実行して Docker コンテナを起動します。
```
docker run --rm --init -it --name docker-image \
-v path/to/greengrass-v2-credentials:/root/.aws/:ro \
--env-file .env \
-p 8883 \
your-container-image:version
```
このコマンド例は、[docker run](https://docs.docker.com/engine/reference/commandline/run/) に次の引数を使用します。
+ [https://docs.docker.com/engine/reference/run/#clean-up---rm](https://docs.docker.com/engine/reference/run/#clean-up---rm): コンテナの終了時にクリーンアップを実行します。
+ [https://docs.docker.com/engine/reference/run/#specify-an-init-process](https://docs.docker.com/engine/reference/run/#specify-an-init-process): コンテナで init プロセスを使用します。
**注記**
Docker コンテナを停止するときに AWS IoT Greengrass Core ソフトウェアをシャットダウンするには、 `--init`引数が必要です。
+ [https://docs.docker.com/engine/reference/run/#foreground](https://docs.docker.com/engine/reference/run/#foreground): (オプション) Docker コンテナを対話型プロセスとしてフォアグラウンドで実行します。これを `-d` 引数に置き換えて、代わりに Docker コンテナをデタッチモードで実行できます。詳細については、「Docker ドキュメント」の「[デタッチ vs フォアグラウンド](https://docs.docker.com/engine/reference/run/#detached-vs-foreground)」を参照してください。
+ [https://docs.docker.com/engine/reference/run/#name---name](https://docs.docker.com/engine/reference/run/#name---name): `aws-iot-greengrass` という名前のコンテナを実行します。
+ [https://docs.docker.com/storage/volumes/](https://docs.docker.com/storage/volumes/)。 ボリュームを Docker コンテナにマウントして、設定ファイルと証明書ファイルをコンテナ内で AWS IoT Greengrass 実行できるようにします。
+ [https://docs.docker.com/engine/reference/commandline/run/#env](https://docs.docker.com/engine/reference/commandline/run/#env)。 (オプション) Docker コンテナ内の AWS IoT Greengrass Core ソフトウェアインストーラに渡される環境変数を設定する環境ファイルを指定します。この引数は、環境変数を設定するための [[environment file]](run-greengrass-docker-manual-provisioning.md#create-env-file-manual-provisioning) (環境ファイル) を作成した場合にのみ必要です。環境ファイルを作成していない場合は、`--env` 引数を使用して、「Docker 実行コマンド」で環境変数を直接設定できます。
+ [https://docs.docker.com/engine/reference/commandline/run/#publish](https://docs.docker.com/engine/reference/commandline/run/#publish): (オプション) 8883 コンテナポートをホストマシンに公開します。 AWS IoT Greengrass は MQTT トラフィックにポート 8883 を使用するため、MQTT を介して接続および通信する場合は、この引数が必要です。他のポートを開くには、追加の `-p` 引数を使用します。
**注記**
セキュリティを強化して Docker コンテナを実行するには、`--cap-drop` 引数および `--cap-add` 引数を使用して、コンテナの Linux 機能を選択的に有効にします。詳細については、「Docker ドキュメント」の「[[Runtime privilege and Linux capabilities]](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) (ランタイム特権と Linux 機能)」を参照してください。
1. ホストデバイスで `./greengrass-v2-credentials` から認証情報を削除します。
```
rm -rf ./greengrass-v2-credentials
```
**重要**
これらの認証情報は、コアデバイスがセットアップ時にのみ必要とする広範なアクセス許可を提供するため、削除します。これらの認証情報を削除しないと、Greengrass コンポーネントとコンテナで実行されている他のプロセスがそれらにアクセスできます。Greengrass コンポーネントに AWS 認証情報を指定する必要がある場合は、トークン交換サービスを使用します。詳細については、「[AWS サービスとやり取り](interact-with-aws-services.md)」を参照してください。
------
#### [ Docker Compose ]
1. テキストエディタを使用して、`docker-compose.yml` という名前の Docker Compose ファイルを作成します。
例えば、Linux ベースのシステムでは、次のコマンドを実行し、GNU nano を使用して現在のディレクトリに `docker-compose.yml` を作成できます。
```
nano docker-compose.yml
```
**注記**
AWSが提供する Compose ファイルの最新バージョンを [GitHub](https://github.com/aws-greengrass/aws-greengrass-docker/releases/) からダウンロードして使用することもできます。
1. Compose ファイルに以下の内容を追加します。ファイルは次の例のようになります。*docker-image* をお使いの Docker イメージの名前に置き換えます。
```
version: '3.7'
services:
greengrass:
init: true
container_name: aws-iot-greengrass
image: docker-image
volumes:
- ./greengrass-v2-credentials:/root/.aws/:ro
env_file: .env
ports:
- "8883:8883"
```
この例の Compose ファイルでは、以下のパラメータはオプションです。
+ `ports` - 8883 コンテナポートをホストマシンに公開します。は MQTT トラフィックにポート 8883 AWS IoT Greengrass を使用するため、このパラメータは MQTT 経由で接続および通信する場合に必要です。
+ `env_file`— Docker コンテナ内の AWS IoT Greengrass Core ソフトウェアインストーラに渡される環境変数を設定する環境ファイルを指定します。このパラメータは、環境変数を設定するための [[environment file]](run-greengrass-docker-manual-provisioning.md#create-env-file-manual-provisioning) (環境ファイル) を作成した場合にのみ必要です。環境ファイルを作成していない場合は、[[environment]](https://docs.docker.com/compose/compose-file/compose-file-v3/#environment) (環境) パラメータを使用して、Compose ファイルで環境変数を直接設定できます。
**注記**
セキュリティを強化して Docker コンテナを実行するには、Compose ファイルで `cap_drop` および `cap_add` を使用して、コンテナの Linux 機能を選択的に有効にします。詳細については、「Docker ドキュメント」の「[[Runtime privilege and Linux capabilities]](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) (ランタイム特権と Linux 機能)」を参照してください。
1. 次のコマンドを実行して Docker コンテナを起動します。
```
docker-compose -f docker-compose.yml up
```
1. ホストデバイスで `./greengrass-v2-credentials` から認証情報を削除します。
```
rm -rf ./greengrass-v2-credentials
```
**重要**
これらの認証情報は、コアデバイスがセットアップ時にのみ必要とする広範なアクセス許可を提供するため、削除します。これらの認証情報を削除しないと、Greengrass コンポーネントとコンテナで実行されている他のプロセスがそれらにアクセスできます。Greengrass コンポーネントに AWS 認証情報を指定する必要がある場合は、トークン交換サービスを使用します。詳細については、「[AWS サービスとやり取り](interact-with-aws-services.md)」を参照してください。
------
## 次の手順
AWS IoT Greengrass Core ソフトウェアが Docker コンテナで実行されています。次のコマンドを実行して、現在実行中のコンテナのコンテナ ID を取得します。
```
docker ps
```
その後、次のコマンドを実行してコンテナにアクセスし、コンテナ内で実行されている AWS IoT Greengrass Core ソフトウェアを調べることができます。
```
docker exec -it container-id /bin/bash
```
単純なコンポーネントの作成については、「[チュートリアル: AWS IoT Greengrass V2 の開始方法](getting-started.md)」の「[ステップ 4: デバイス上でコンポーネントを開発およびテストする](create-first-component.md)」を参照してください。
**注記**
`docker exec` を使用して Docker コンテナ内でコマンドを実行すると、これらのコマンドは Docker ログに記録されません。Docker ログにコマンドを記録するには、Docker コンテナに対話型シェルをアタッチします。詳細については、「[インタラクティブシェルを Docker コンテナにアタッチする](docker-troubleshooting.md#debugging-docker-attach-shell)」を参照してください。
AWS IoT Greengrass Core ログファイルは と呼ばれ`greengrass.log`、 にあります`/greengrass/v2/logs`。コンポーネントログファイルも同じディレクトリにあります。Greengrass ログをホストの一時ディレクトリにコピーするには、次のコマンドを実行します。
```
docker cp container-id:/greengrass/v2/logs /tmp/logs
```
コンテナの終了後、または削除後もログを保持する場合は、Greengrass ディレクトリ全体をマウントするのではなく、`/greengrass/v2/logs` ディレクトリのみをホストの一時ログディレクトリにバインドマウントすることをお勧めします。詳細については、「[Docker コンテナの外部で Greengrass ログを永続化する](docker-troubleshooting.md#debugging-docker-persist-logs)」を参照してください。
実行中の Docker AWS IoT Greengrass コンテナを停止するには、 `docker stop`または を実行します`docker-compose -f docker-compose.yml stop`。このアクションは、`SIGTERM` を Greengrass プロセスに送信し、コンテナで開始されたすべての関連プロセスをシャットダウンします。Docker コンテナは、プロセス PID 1 として `docker-init` の実行可能ファイルで初期化されます。これは、残っているゾンビプロセスを削除するのに役立ちます。詳細については、Docker ドキュメントの「[Specify an init process](https://docs.docker.com/engine/reference/run/#specify-an-init-process)」を参照してください。
Docker コンテナで AWS IoT Greengrass を実行する際の問題のトラブルシューティングについては、「[Docker コンテナ AWS IoT Greengrass でのトラブルシューティング](docker-troubleshooting.md)」を参照してください。
# 手動リソースプロビジョニングを使用して Docker コンテナ AWS IoT Greengrass で を実行する
このチュートリアルでは、手動でプロビジョニングされた AWS リソースを使用して Docker コンテナに AWS IoT Greengrass Core ソフトウェアをインストールして実行する方法について説明します。
**Topics**
+ [前提条件](#docker-manual-provisioning-prereqs)
+ [AWS IoT エンドポイントを取得する](#retrieve-iot-endpoints)
+ [AWS IoT モノを作成する](#create-iot-thing)
+ [モノの証明書を作成する](#create-thing-certificate-mp)
+ [トークン交換ロールを作成する](#create-token-exchange-role)
+ [デバイスに証明書をダウンロードする](#download-thing-certificates)
+ [設定ファイルを作成する](#create-docker-install-configuration-file)
+ [環境ファイルを作成する](#create-env-file-manual-provisioning)
+ [コンテナで AWS IoT Greengrass Core ソフトウェアを実行する](#run-greengrass-image-manual-provisioning)
+ [次の手順](#run-greengrass-docker-next-steps)
## 前提条件
このチュートリアルを完了するには、以下が必要です。
+ AWS アカウント。アカウントをお持ちでない場合は、「[のセットアップ AWS アカウント](setting-up.md#set-up-aws-account)」を参照してください。
+ Docker AWS IoT Greengrass イメージ。[Dockerfile AWS IoT Greengrass からイメージを構築](build-greengrass-dockerfile.md)できます。
+ Docker コンテナを実行するホストコンピュータは、以下の要件を満たしている必要があります。
+ インターネットに接続された Linux ベースのオペレーティングシステム。
+ [Docker Engine](https://docs.docker.com/engine/install/) バージョン 18.09 以降。
+ (オプション) [Docker Compose](https://docs.docker.com/compose/install/) バージョン 1.22 以降。Docker Compose は、Docker Compose CLI を使用して Docker イメージを実行する場合のみ必要です。
## AWS IoT エンドポイントを取得する
の AWS IoT エンドポイントを取得し AWS アカウント、後で使用するために保存します。デバイスはこれらのエンドポイントを使用して AWS IoTに接続します。以下の操作を実行します。
1. AWS IoT のデータエンドポイントを取得します AWS アカウント。
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS
```
要求が正常に処理された場合、レスポンスは次の例のようになります。
```
{
"endpointAddress": "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
}
```
1. の AWS IoT 認証情報エンドポイントを取得します AWS アカウント。
```
aws iot describe-endpoint --endpoint-type iot:CredentialProvider
```
要求が正常に処理された場合、レスポンスは次の例のようになります。
```
{
"endpointAddress": "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
}
```
## AWS IoT モノを作成する
AWS IoT *モノ*は、 に接続するデバイスと論理エンティティを表します AWS IoT。Greengrass コアデバイスは AWS IoT モノです。デバイスを AWS IoT モノとして登録すると、そのデバイスはデジタル証明書を使用して認証できます AWS。
このセクションでは、デバイスを表す AWS IoT モノを作成します。
**AWS IoT モノを作成するには**
1. デバイスの AWS IoT モノを作成します。開発用コンピュータに次のコマンドを実行します。
+ *MyGreengrassCore* を使用するモノの名前に置き換えます。この名前は Greengrass コアデバイスの名前でもあります。
**注記**
モノの名前にコロン (`:`) 記号を含むことができません。
```
aws iot create-thing --thing-name MyGreengrassCore
```
要求が正常に処理された場合、レスポンスは次の例のようになります。
```
{
"thingName": "MyGreengrassCore",
"thingArn": "arn:aws:iot:us-west-2:123456789012:thing/MyGreengrassCore",
"thingId": "8cb4b6cd-268e-495d-b5b9-1713d71dbf42"
}
```
1. (オプション) AWS IoT モノを新規または既存のモノグループに追加します。モノグループを使用して Greengrass コアデバイスのフリートを管理します。ソフトウェアコンポーネントをデバイスにデプロイするとき、個々のデバイスまたはデバイスのグループを対象にできます。アクティブな Greengrass デプロイを持つモノグループにデバイスを追加して、そのモノグループのソフトウェアコンポーネントをデバイスにデプロイできます。以下の操作を実行します。
1. (オプション) AWS IoT モノのグループを作成します。
+ *MyGreengrassCoreGroup* を作成するモノグループの名前に置き換えます。
**注記**
モノグループ名にコロン (`:`) 記号を含めることはできません。
```
aws iot create-thing-group --thing-group-name MyGreengrassCoreGroup
```
要求が正常に処理された場合、レスポンスは次の例のようになります。
```
{
"thingGroupName": "MyGreengrassCoreGroup",
"thingGroupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/MyGreengrassCoreGroup",
"thingGroupId": "4df721e1-ff9f-4f97-92dd-02db4e3f03aa"
}
```
1. AWS IoT モノをモノのグループに追加します。
+ *MyGreengrassCore* を AWS IoT モノの名前に置き換えます。
+ *MyGreengrassCoreGroup* をモノグループの名前に置き換えます。
```
aws iot add-thing-to-thing-group --thing-name MyGreengrassCore --thing-group-name MyGreengrassCoreGroup
```
要求が正常に処理された場合、コマンドは出力されません。
## モノの証明書を作成する
デバイスを AWS IoT モノとして登録すると、そのデバイスはデジタル証明書を使用して認証できます AWS。この証明書により、デバイスは AWS IoT および と通信できます AWS IoT Greengrass。
このセクションでは、デバイスが AWSに接続する際に使用できる証明書を作成してダウンロードします。
**モノの証明書を作成するには**
1. AWS IoT モノの証明書をダウンロードするフォルダを作成します。
```
mkdir greengrass-v2-certs
```
1. AWS IoT モノの証明書を作成してダウンロードします。
```
aws iot create-keys-and-certificate --set-as-active --certificate-pem-outfile greengrass-v2-certs/device.pem.crt --public-key-outfile greengrass-v2-certs/public.pem.key --private-key-outfile greengrass-v2-certs/private.pem.key
```
要求が正常に処理された場合、レスポンスは次の例のようになります。
```
{
"certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
"certificateId": "aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
"certificatePem": "-----BEGIN CERTIFICATE-----
MIICiTCCAfICCQD6m7oRw0uXOjANBgkqhkiG9w
0BAQUFADCBiDELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZ
WF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIw
EAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5
jb20wHhcNMTEwNDI1MjA0NTIxWhcNMTIwNDI0MjA0NTIxWjCBiDELMAkGA1UEBh
MCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBb
WF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMx
HzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5jb20wgZ8wDQYJKoZIhvcNAQE
BBQADgY0AMIGJAoGBAMaK0dn+a4GmWIWJ21uUSfwfEvySWtC2XADZ4nB+BLYgVI
k60CpiwsZ3G93vUEIO3IyNoH/f0wYK8m9TrDHudUZg3qX4waLG5M43q7Wgc/MbQ
ITxOUSQv7c7ugFFDzQGBzZswY6786m86gpEIbb3OhjZnzcvQAaRHhdlQWIMm2nr
AgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAtCu4nUhVVxYUntneD9+h8Mg9q6q+auN
KyExzyLwaxlAoo7TJHidbtS4J5iNmZgXL0FkbFFBjvSfpJIlJ00zbhNYS5f6Guo
EDmFJl0ZxBHjJnyp378OD8uTs7fLvjx79LjSTbNYiytVbZPQUQ5Yaxu2jXnimvw
3rrszlaEXAMPLE=
-----END CERTIFICATE-----",
"keyPair": {
"PublicKey": "-----BEGIN PUBLIC KEY-----\
MIIBIjANBgkqhkEXAMPLEQEFAAOCAQ8AMIIBCgKCAQEAEXAMPLE1nnyJwKSMHw4h\
MMEXAMPLEuuN/dMAS3fyce8DW/4+EXAMPLEyjmoF/YVF/gHr99VEEXAMPLE5VF13\
59VK7cEXAMPLE67GK+y+jikqXOgHh/xJTwo+sGpWEXAMPLEDz18xOd2ka4tCzuWEXAMPLEahJbYkCPUBSU8opVkR7qkEXAMPLE1DR6sx2HocliOOLtu6Fkw91swQWEXAMPLE\\GB3ZPrNh0PzQYvjUStZeccyNCx2EXAMPLEvp9mQOUXP6plfgxwKRX2fEXAMPLEDa\
hJLXkX3rHU2xbxJSq7D+XEXAMPLEcw+LyFhI5mgFRl88eGdsAEXAMPLElnI9EesG\
FQIDAQAB\
-----END PUBLIC KEY-----\
",
"PrivateKey": "-----BEGIN RSA PRIVATE KEY-----\
key omitted for security reasons\
-----END RSA PRIVATE KEY-----\
"
}
}
```
後で証明書を設定するために使用する証明書の Amazon リソースネーム (ARN) を保存します。
次に、モノの証明書を設定します。詳細については、「[モノの証明書を設定する](manual-installation.md#configure-thing-certificate)」を参照してください。
## トークン交換ロールを作成する
Greengrass コアデバイスは、*トークン交換ロールと呼ばれる IAM サービスロール*を使用して、 AWS サービスへの呼び出しを承認します。デバイスは認証情報 AWS IoT プロバイダーを使用して、このロールの一時的な AWS 認証情報を取得します。これにより、デバイスは Amazon CloudWatch Logs とやり取り AWS IoTしたり、Amazon CloudWatch Logs にログを送信したり、Amazon S3 からカスタムコンポーネントアーティファクトをダウンロードしたりできます。 Amazon CloudWatch 詳細については、「[コアデバイスが AWS サービスとやり取りできるように認可する](device-service-role.md)」を参照してください。
AWS IoT *ロールエイリアス*を使用して、Greengrass コアデバイスのトークン交換ロールを設定します。ロールエイリアスは、デバイスのトークン交換ロールを変更できるようにしますが、デバイス設定は同じ内容に保たれます。詳細については、「*AWS IoT Core デベロッパーガイド*」の「[Authorizing direct calls to AWS services](https://docs.aws.amazon.com/iot/latest/developerguide/authorizing-direct-aws.html)」を参照してください。
このセクションでは、トークン交換 IAM ロールと AWS IoT 、ロールを指すロールエイリアスを作成します。Greengrass コアデバイスを既に設定している場合、新しく作成せず、トークン交換ロールとロールエイリアスを使用できます。次に、デバイスの AWS IoT モノを設定してそのロールとエイリアスを使用します。
**トークン交換 IAM ロールを作成するには**
1. デバイスがトークン交換ロールとして使用できる IAM ロールを作成します。以下の操作を実行します。
1. トークン交換ロールが必要とする、信頼できるポリシードキュメントが含まれるファイルを作成します。
例えば、Linux ベースのシステムでは、次のコマンドを実行し、GNU nano を使用してファイルを作成できます。
```
nano device-role-trust-policy.json
```
次の JSON をファイルにコピーします。
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
1. 信頼ポリシードキュメントでトークン交換ロールを作成します。
+ *GreengrassV2TokenExchangeRole* を、作成する IAM ロールの名前に置き換えます。
```
aws iam create-role --role-name GreengrassV2TokenExchangeRole --assume-role-policy-document file://device-role-trust-policy.json
```
要求が正常に処理された場合、レスポンスは次の例のようになります。
```
{
"Role": {
"Path": "/",
"RoleName": "GreengrassV2TokenExchangeRole",
"RoleId": "AROAZ2YMUHYHK5OKM77FB",
"Arn": "arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole",
"CreateDate": "2021-02-06T00:13:29+00:00",
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
}
```
1. トークン交換ロールが必要なアクセスポリシードキュメントを含むファイルを作成します。
例えば、Linux ベースのシステムでは、次のコマンドを実行し、GNU nano を使用してファイルを作成できます。
```
nano device-role-access-policy.json
```
次の JSON をファイルにコピーします。
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents",
"logs:DescribeLogStreams",
"s3:GetBucketLocation"
],
"Resource": "*"
}
]
}
```
**注記**
このアクセスポリシーでは、S3 バケットのコンポーネントアーティファクトへのアクセスが許可されていません。Amazon S3 でアーティファクトを定義するカスタムコンポーネントをデプロイするには、コアデバイスがコンポーネントアーティファクトを取得できるようにする許可をロールに追加する必要があります。詳細については、「[コンポーネントのアーティファクトの S3 バケットへのアクセスを許可する](device-service-role.md#device-service-role-access-s3-bucket)」を参照してください。
コンポーネントアーティファクトに S3 バケットをまだ持っていない場合、バケットを作成した後でこれらのアクセス許可を追加できます。
1. ポリシードキュメントから IAM ポリシーを作成します。
+ *GreengrassV2TokenExchangeRoleAccess* を作成する IAM ポリシーの名前に置き換えます。
```
aws iam create-policy --policy-name GreengrassV2TokenExchangeRoleAccess --policy-document file://device-role-access-policy.json
```
要求が正常に処理された場合、レスポンスは次の例のようになります。
```
{
"Policy": {
"PolicyName": "GreengrassV2TokenExchangeRoleAccess",
"PolicyId": "ANPAZ2YMUHYHACI7C5Z66",
"Arn": "arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess",
"Path": "/",
"DefaultVersionId": "v1",
"AttachmentCount": 0,
"PermissionsBoundaryUsageCount": 0,
"IsAttachable": true,
"CreateDate": "2021-02-06T00:37:17+00:00",
"UpdateDate": "2021-02-06T00:37:17+00:00"
}
}
```
1. IAM ポリシーをトークン交換ロールにアタッチします。
+ *GreengrassV2TokenExchangeRole* を、IAM ロールの名前に置き換えます。
+ ポリシー ARN を前のステップで作成した IAM ポリシーの ARN に置き換えます。
```
aws iam attach-role-policy --role-name GreengrassV2TokenExchangeRole --policy-arn arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess
```
要求が正常に処理された場合、コマンドは出力されません。
1. トークン交換 AWS IoT ロールを指すロールエイリアスを作成します。
+ *GreengrassCoreTokenExchangeRoleAlias* を作成するロールエイリアスの名前に置き換えます。
+ ロール ARN を前のステップで作成した IAM ロールの ARN に置き換えます。
```
aws iot create-role-alias --role-alias GreengrassCoreTokenExchangeRoleAlias --role-arn arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole
```
要求が正常に処理された場合、レスポンスは次の例のようになります。
```
{
"roleAlias": "GreengrassCoreTokenExchangeRoleAlias",
"roleAliasArn": "arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
```
**注記**
ロールエイリアスを作成するには、トークン交換 IAM ロールを AWS IoTに渡す許可が必要です。ロールエイリアスを作成しようとしたときにエラーメッセージが表示された場合は、 AWS ユーザーにこのアクセス許可があることを確認してください。詳細については、「 *AWS Identity and Access Management ユーザーガイド*[」の「 AWS サービスにロールを渡すアクセス許可をユーザーに付与](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_passrole.html)する」を参照してください。
1. Greengrass コアデバイスがロールエイリアスを使用してトークン交換ロールを引き受けることを許可する AWS IoT ポリシーを作成してアタッチします。Greengrass コアデバイスを以前にセットアップしたことがある場合は、新しいロールエイリアスポリシーを作成する代わりに、そのロールエイリアス AWS IoT ポリシーをアタッチできます。以下の操作を実行します。
1. (オプション) ロールエイリアスに必要な AWS IoT ポリシードキュメントを含むファイルを作成します。
例えば、Linux ベースのシステムでは、次のコマンドを実行し、GNU nano を使用してファイルを作成できます。
```
nano greengrass-v2-iot-role-alias-policy.json
```
次の JSON をファイルにコピーします。
+ リソース ARN をロールエイリアスの ARN に置き換えます。
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iot:AssumeRoleWithCertificate",
"Resource": "arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
]
}
```
1. AWS IoT ポリシードキュメントから ポリシーを作成します。
+ *GreengrassCoreTokenExchangeRoleAliasPolicy* を、作成する AWS IoT ポリシーの名前に置き換えます。
```
aws iot create-policy --policy-name GreengrassCoreTokenExchangeRoleAliasPolicy --policy-document file://greengrass-v2-iot-role-alias-policy.json
```
要求が正常に処理された場合、レスポンスは次の例のようになります。
```
{
"policyName": "GreengrassCoreTokenExchangeRoleAliasPolicy",
"policyArn": "arn:aws:iot:us-west-2:123456789012:policy/GreengrassCoreTokenExchangeRoleAliasPolicy",
"policyDocument": "{
\\"Version\\":\\"2012-10-17 \\",
\\"Statement\\": [
{
\\"Effect\\": \\"Allow\\",
\\"Action\\": \\"iot:AssumeRoleWithCertificate\\",
\\"Resource\\": \\"arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias\\"
}
]
}",
"policyVersionId": "1"
}
```
1. AWS IoT モノの証明書に AWS IoT ポリシーをアタッチします。
+ *GreengrassCoreTokenExchangeRoleAliasPolicy* をロールエイリアス AWS IoT ポリシーの名前に置き換えます。
+ ターゲット ARN を AWS IoT モノの証明書の ARN に置き換えます。
```
aws iot attach-policy --policy-name GreengrassCoreTokenExchangeRoleAliasPolicy --target arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4
```
要求が正常に処理された場合、コマンドは出力されません。
## デバイスに証明書をダウンロードする
以前に、デバイスの証明書を開発用コンピュータにダウンロードしました。このセクションでは、Amazon ルート認証局 (CA) の証明書もダウンロードします。次に、開発用コンピュータとは異なるコンピュータで Docker で AWS IoT Greengrass Core ソフトウェアを実行する場合は、証明書をそのホストコンピュータにコピーします。 AWS IoT Greengrass Core ソフトウェアは、これらの証明書を使用して AWS IoT クラウドサービスに接続します。
**証明書をデバイスにダウンロードするには**
1. 開発用コンピュータで、Amazon ルート認証局 (CA) 証明書をダウンロードします。 AWS IoT 証明書は、デフォルトで Amazon のルート CA 証明書に関連付けられています。
------
#### [ Linux or Unix ]
```
sudo curl -o ./greengrass-v2-certs/AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -o .\greengrass-v2-certs\AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ PowerShell ]
```
iwr -Uri https://www.amazontrust.com/repository/AmazonRootCA1.pem -OutFile .\greengrass-v2-certs\AmazonRootCA1.pem
```
------
1. 開発用コンピュータとは異なるデバイスで Docker で AWS IoT Greengrass Core ソフトウェアを実行する場合は、証明書をホストコンピュータにコピーします。開発用コンピュータとホストコンピュータで SSH と SCP が有効になっている場合、開発用コンピュータの `scp` コマンドを実行して、証明書を転送できます。*device-ip-address* をホストコンピュータの IP アドレスに置き換えます。
```
scp -r greengrass-v2-certs/ device-ip-address:~
```
## 設定ファイルを作成する
1. ホストコンピュータで、設定ファイルを配置するフォルダを作成します。
```
mkdir ./greengrass-v2-config
```
1. テキストエディタを使用して、`./greengrass-v2-config` フォルダに `config.yaml` という名前の設定ファイルを作成します。
例えば、次のコマンドを実行し、GNU nano を使用して `config.yaml` を作成できます。
```
nano ./greengrass-v2-config/config.yaml
```
1. 次の YAML コンテンツをファイルにコピーします。この部分設定ファイルは、システムパラメータと Greengrass nucleus パラメータを指定します。
```
---
system:
certificateFilePath: "/tmp/certs/device.pem.crt"
privateKeyPath: "/tmp/certs/private.pem.key"
rootCaPath: "/tmp/certs/AmazonRootCA1.pem"
rootpath: "/greengrass/v2"
thingName: "MyGreengrassCore"
services:
aws.greengrass.Nucleus:
componentType: "NUCLEUS"
version: "nucleus-version"
configuration:
awsRegion: "region"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
iotDataEndpoint: "device-data-prefix-ats.iot.region.amazonaws.com"
iotCredEndpoint: "device-credentials-prefix.credentials.region.amazonaws.com"
```
次に、以下の値を置き換えます。
+ */tmp/certs*。コンテナの起動時にダウンロードした証明書をマウントする Docker コンテナ内のディレクトリ。
+ `/greengrass/v2`。インストールに使用する Greengrass ルートフォルダ。`GGC_ROOT` 環境変数を使用して、この値を設定します。
+ *MyGreengrassCore*。 AWS IoT モノの名前。
+ *nucleus バージョン*。インストールする AWS IoT Greengrass Core ソフトウェアのバージョン。この値は、ダウンロードした Docker イメージまたは Dockerfile のバージョンと一致する必要があります。`latest` タグ付きの Greengrass Docker イメージをダウンロードした場合は、****docker inspect *image-id***** を使用してイメージのバージョンを確認してください。
+ *リージョン*。 AWS IoT リソースを作成した AWS リージョン 。また、[環境ファイル](#create-env-file-manual-provisioning)の `AWS_REGION` 環境変数に同じ値を指定する必要があります。
+ *GreengrassCoreTokenExchangeRoleAlias*。トークン交換ロールエイリアス。
+ *デバイスデータプレフィックス*。 AWS IoT データエンドポイントのプレフィックス。
+ *device-credentials-prefix*。 AWS IoT 認証情報エンドポイントのプレフィックス。
## 環境ファイルを作成する
このチュートリアルでは、環境ファイルを使用して、Docker コンテナ内の AWS IoT Greengrass Core ソフトウェアインストーラに渡される環境変数を設定します。また、`docker run` コマンドで [`-e` または `--env` 引数](https://docs.docker.com/engine/reference/commandline/run/#env)を使用して、Docker コンテナに環境変数を設定する、または `docker-compose.yml` ファイルの [`environment` ブロック](https://docs.docker.com/compose/compose-file/compose-file-v3/#environment)で変数を設定することもできます。
1. テキストエディタを使用して、`.env` という名前の環境ファイルを作成します。
例えば、Linux ベースのシステムでは、次のコマンドを実行し、GNU nano を使用して現在のディレクトリに `.env` を作成できます。
```
nano .env
```
1. 次の内容をファイルにコピーします。
```
GGC_ROOT_PATH=/greengrass/v2
AWS_REGION=region
PROVISION=false
COMPONENT_DEFAULT_USER=ggc_user:ggc_group
INIT_CONFIG=/tmp/config/config.yaml
```
次に、以下の値を置き換えます。
+ `/greengrass/v2`。 AWS IoT Greengrass Core ソフトウェアのインストールに使用するルートフォルダへのパス。
+ *リージョン*。 AWS IoT リソースを作成した AWS リージョン 。[[configuration file]](#create-docker-install-configuration-file) (設定ファイル) の `awsRegion` 設定パラメータに同じ値を指定する必要があります。
+ */tmp/config/*。Docker コンテナの起動時に設定ファイルをマウントするフォルダ。
**注記**
`DEPLOY_DEV_TOOLS` 環境変数を `true` に設定して、[[Greengrass CLI component]](greengrass-cli-component.md) (Greengrass CLI コンポーネント) をデプロイできます。これにより、Docker コンテナ内でカスタムコンポーネントを開発できます。このコンポーネントは、本番環境ではなく、開発環境でのみで使用することをお勧めします。このコンポーネントは、通常、本番環境では必要とされない情報や操作へのアクセスを提供します。このコンポーネントを必要なコアデバイスにのみデプロイして、最小特権の原則に従います。
## コンテナで AWS IoT Greengrass Core ソフトウェアを実行する
このチュートリアルでは、Docker コンテナでビルドした Docker イメージを起動する方法を説明します。Docker CLI または Docker Compose CLI を使用して、Docker コンテナで AWS IoT Greengrass Core ソフトウェアイメージを実行できます。
------
#### [ Docker ]
+ このチュートリアルでは、Docker コンテナでビルドした Docker イメージを起動する方法を説明します。
```
docker run --rm --init -it --name docker-image \
-v path/to/greengrass-v2-config:/tmp/config/:ro \
-v path/to/greengrass-v2-certs:/tmp/certs:ro \
--env-file .env \
-p 8883 \
your-container-image:version
```
このコマンド例は、[docker run](https://docs.docker.com/engine/reference/commandline/run/) に次の引数を使用します。
+ [https://docs.docker.com/engine/reference/run/#clean-up---rm](https://docs.docker.com/engine/reference/run/#clean-up---rm): コンテナの終了時にクリーンアップを実行します。
+ [https://docs.docker.com/engine/reference/run/#specify-an-init-process](https://docs.docker.com/engine/reference/run/#specify-an-init-process): コンテナで init プロセスを使用します。
**注記**
Docker コンテナを停止するときに AWS IoT Greengrass Core ソフトウェアをシャットダウンするには、 `--init`引数が必要です。
+ [https://docs.docker.com/engine/reference/run/#foreground](https://docs.docker.com/engine/reference/run/#foreground): (オプション) Docker コンテナを対話型プロセスとしてフォアグラウンドで実行します。これを `-d` 引数に置き換えて、代わりに Docker コンテナをデタッチモードで実行できます。詳細については、「Docker ドキュメント」の「[デタッチ vs フォアグラウンド](https://docs.docker.com/engine/reference/run/#detached-vs-foreground)」を参照してください。
+ [https://docs.docker.com/engine/reference/run/#name---name](https://docs.docker.com/engine/reference/run/#name---name): `aws-iot-greengrass` という名前のコンテナを実行します。
+ [https://docs.docker.com/storage/volumes/](https://docs.docker.com/storage/volumes/)。 ボリュームを Docker コンテナにマウントして、設定ファイルと証明書ファイルをコンテナ内で AWS IoT Greengrass 実行できるようにします。
+ [https://docs.docker.com/engine/reference/commandline/run/#env](https://docs.docker.com/engine/reference/commandline/run/#env)。 (オプション) Docker コンテナ内の AWS IoT Greengrass Core ソフトウェアインストーラに渡される環境変数を設定する環境ファイルを指定します。この引数は、環境変数を設定するための [[environment file]](#create-env-file-manual-provisioning) (環境ファイル) を作成した場合にのみ必要です。環境ファイルを作成していない場合は、`--env` 引数を使用して、「Docker 実行コマンド」で環境変数を直接設定できます。
+ [https://docs.docker.com/engine/reference/commandline/run/#publish](https://docs.docker.com/engine/reference/commandline/run/#publish): (オプション) 8883 コンテナポートをホストマシンに公開します。 AWS IoT Greengrass は MQTT トラフィックにポート 8883 を使用するため、MQTT を介して接続および通信する場合は、この引数が必要です。他のポートを開くには、追加の `-p` 引数を使用します。
**注記**
セキュリティを強化して Docker コンテナを実行するには、`--cap-drop` 引数および `--cap-add` 引数を使用して、コンテナの Linux 機能を選択的に有効にします。詳細については、「Docker ドキュメント」の「[[Runtime privilege and Linux capabilities]](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) (ランタイム特権と Linux 機能)」を参照してください。
------
#### [ Docker Compose ]
1. テキストエディタを使用して、`docker-compose.yml` という名前の Docker Compose ファイルを作成します。
例えば、Linux ベースのシステムでは、次のコマンドを実行し、GNU nano を使用して現在のディレクトリに `docker-compose.yml` を作成できます。
```
nano docker-compose.yml
```
**注記**
AWSが提供する Compose ファイルの最新バージョンを [GitHub](https://github.com/aws-greengrass/aws-greengrass-docker/releases/) からダウンロードして使用することもできます。
1. Compose ファイルに以下の内容を追加します。ファイルは次の例のようになります。*コンテナ名:バージョン*を Docker イメージの名前に置き換えます。
```
version: '3.7'
services:
greengrass:
init: true
build:
context: .
container_name: aws-iot-greengrass
image: your-container-name:version
volumes:
- /path/to/greengrass-v2-config:/tmp/config/:ro
- /path/to/greengrass-v2-certs:/tmp/certs:ro
env_file: .env
ports:
- "8883:8883"
```
この例の Compose ファイルでは、以下のパラメータはオプションです。
+ `ports` - 8883 コンテナポートをホストマシンに公開します。は MQTT トラフィックにポート 8883 AWS IoT Greengrass を使用するため、このパラメータは MQTT 経由で接続および通信する場合に必要です。
+ `env_file`— Docker コンテナ内の AWS IoT Greengrass Core ソフトウェアインストーラに渡される環境変数を設定する環境ファイルを指定します。このパラメータは、環境変数を設定するための [[environment file]](#create-env-file-manual-provisioning) (環境ファイル) を作成した場合にのみ必要です。環境ファイルを作成していない場合は、[[environment]](https://docs.docker.com/compose/compose-file/compose-file-v3/#environment) (環境) パラメータを使用して、Compose ファイルで環境変数を直接設定できます。
**注記**
セキュリティを強化して Docker コンテナを実行するには、Compose ファイルで `cap_drop` および `cap_add` を使用して、コンテナの Linux 機能を選択的に有効にします。詳細については、「Docker ドキュメント」の「[[Runtime privilege and Linux capabilities]](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) (ランタイム特権と Linux 機能)」を参照してください。
1. 次のコマンドを実行して、コンテナを起動します。
```
docker-compose -f docker-compose.yml up
```
------
## 次の手順
AWS IoT Greengrass Core ソフトウェアが Docker コンテナで実行されています。次のコマンドを実行して、現在実行中のコンテナのコンテナ ID を取得します。
```
docker ps
```
その後、次のコマンドを実行してコンテナにアクセスし、コンテナ内で実行されている AWS IoT Greengrass Core ソフトウェアを調べることができます。
```
docker exec -it container-id /bin/bash
```
単純なコンポーネントの作成については、「[チュートリアル: AWS IoT Greengrass V2 の開始方法](getting-started.md)」の「[ステップ 4: デバイス上でコンポーネントを開発およびテストする](create-first-component.md)」を参照してください。
**注記**
`docker exec` を使用して Docker コンテナ内でコマンドを実行すると、これらのコマンドは Docker ログに記録されません。Docker ログにコマンドを記録するには、Docker コンテナに対話型シェルをアタッチします。詳細については、「[インタラクティブシェルを Docker コンテナにアタッチする](docker-troubleshooting.md#debugging-docker-attach-shell)」を参照してください。
AWS IoT Greengrass Core ログファイルは と呼ばれ`greengrass.log`、 にあります`/greengrass/v2/logs`。コンポーネントログファイルも同じディレクトリにあります。Greengrass ログをホストの一時ディレクトリにコピーするには、次のコマンドを実行します。
```
docker cp container-id:/greengrass/v2/logs /tmp/logs
```
コンテナの終了後、または削除後もログを保持する場合は、Greengrass ディレクトリ全体をマウントするのではなく、`/greengrass/v2/logs` ディレクトリのみをホストの一時ログディレクトリにバインドマウントすることをお勧めします。詳細については、「[Docker コンテナの外部で Greengrass ログを永続化する](docker-troubleshooting.md#debugging-docker-persist-logs)」を参照してください。
実行中の Docker AWS IoT Greengrass コンテナを停止するには、 `docker stop`または を実行します`docker-compose -f docker-compose.yml stop`。このアクションは、`SIGTERM` を Greengrass プロセスに送信し、コンテナで開始されたすべての関連プロセスをシャットダウンします。Docker コンテナは、プロセス PID 1 として `docker-init` の実行可能ファイルで初期化されます。これは、残っているゾンビプロセスを削除するのに役立ちます。詳細については、Docker ドキュメントの「[Specify an init process](https://docs.docker.com/engine/reference/run/#specify-an-init-process)」を参照してください。
Docker コンテナで AWS IoT Greengrass を実行する際の問題のトラブルシューティングについては、「[Docker コンテナ AWS IoT Greengrass でのトラブルシューティング](docker-troubleshooting.md)」を参照してください。
# Docker コンテナ AWS IoT Greengrass でのトラブルシューティング
以下の情報は、Docker コンテナ AWS IoT Greengrass で を実行する際の問題のトラブルシューティングや、Docker コンテナ AWS IoT Greengrass での に関する問題のデバッグに役立ちます。
**Topics**
+ [Docker コンテナを実行する際に生じる問題のトラブルシューティング](#troubleshooting-container-errors)
+ [Docker コンテナ AWS IoT Greengrass でのデバッグ](#debugging-greengrass-in-docker)
## Docker コンテナを実行する際に生じる問題のトラブルシューティング
以下の情報は、Docker コンテナ AWS IoT Greengrass で を実行する際の問題のトラブルシューティングに役立ちます。
**Topics**
+ [エラー: Cannot perform an interactive login from a non TTY device (TTY 以外のデバイスから対話型ログインを実行できません)](#docker-troubleshootin-ecr-get-login-password)
+ [エラー: Unknown options: -no-include-email (不明なオプション: -含めない-電子メール)](#docker-troubleshooting-cli-version)
+ [エラー: A firewall is blocking file Sharing between windows and the containers. (ファイアウォールが、ウィンドウとコンテナー間のファイル共有をブロックしています。)](#docker-troubleshooting-firewall)
+ [エラー: An error occurred (AccessDeniedException) when calling the GetAuthorizationToken operation: User: arn:aws:iam::*account-id*:user/ is not authorized to perform: ecr:GetAuthorizationToken on resource: \$1 (GetAuthorizationToken 操作の呼び出し中にエラーが発生しました (AccessDeniedException): ユーザー arn:aws:iam::account-id:user/ には、リソースに対して ecr:GetAuthorizationToken を実行する権限がありません: \$1)](#docker-troubleshooting-ecr-perms)
+ [エラー: You have reached your pull rate limit (プルレート制限に達しました)](#docker-troubleshooting-too-many-requests)
### エラー: Cannot perform an interactive login from a non TTY device (TTY 以外のデバイスから対話型ログインを実行できません)
`aws ecr get-login-password` コマンドを実行すると、このエラーが発生することがあります。 AWS CLI 最新バージョン 2 またはバージョン 1 がインストールされていることを確認します。 AWS CLI バージョン 2 を使用することをお勧めします。詳細については、「*AWS Command Line Interface ユーザーガイド*」の「[Installing the AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html)」を参照してください。
### エラー: Unknown options: -no-include-email (不明なオプション: -含めない-電子メール)
`aws ecr get-login` コマンドを実行すると、このエラーが発生することがあります。 AWS CLI 最新バージョンがインストールされていることを確認します (例: Run: `pip install awscli --upgrade --user`)。詳細については、「 *AWS Command Line Interface ユーザーガイド*[」の「Microsoft Windows AWS Command Line Interface での](https://docs.aws.amazon.com/cli/latest/userguide/awscli-install-windows.html) のインストール」を参照してください。
### エラー: A firewall is blocking file Sharing between windows and the containers. (ファイアウォールが、ウィンドウとコンテナー間のファイル共有をブロックしています。)
Windows コンピュータで Docker を実行すると、このエラーまたは `Firewall Detected` メッセージが表示されることがあります。このエラーは、仮想プライベートネットワーク (VPN) にサインインしていて、ネットワーク設定が原因で共有ドライブをマウントできない場合にも発生することがあります。このような場合は、VPN をオフにし、Docker コンテナを再実行します。
### エラー: An error occurred (AccessDeniedException) when calling the GetAuthorizationToken operation: User: arn:aws:iam::*account-id*:user/ is not authorized to perform: ecr:GetAuthorizationToken on resource: \$1 (GetAuthorizationToken 操作の呼び出し中にエラーが発生しました (AccessDeniedException): ユーザー arn:aws:iam::account-id:user/ には、リソースに対して ecr:GetAuthorizationToken を実行する権限がありません: \$1)
このエラーは、Amazon ECR リポジトリにアクセスするための十分な権限がない状態で `aws ecr get-login-password` コマンドを実行したときに表示されることがあります。詳細については、「Amazon ECR ユーザーガイド」の「[Amazon ECR リポジトリポリシーの例](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-policy-examples.html)」および「[1 つの Amazon ECR リポジトリにアクセスする](https://docs.aws.amazon.com/AmazonECR/latest/userguide/security_iam_id-based-policy-examples.html)」を参照してください。
### エラー: You have reached your pull rate limit (プルレート制限に達しました)
Docker Hub は、匿名ユーザーと無料の Docker Hub ユーザーが行うことができるプルリクエストの数を制限します。匿名ユーザーまたは無料のユーザーのプルリクエストの上限に達すると、次のいずれかのエラーが表示されます。
```
ERROR: toomanyrequests: Too Many Requests.
```
```
You have reached your pull rate limit.
```
これらのエラーを解決するには、別のプルリクエストを試行する前に数時間を置いてください。多数のプルリクエストを継続的に送信する予定がある場合は、[Docker Hub ウェブサイト](https://www.docker.com/increase-rate-limits)にある制限数に関する情報と、Docker アカウントの認証とアップグレードのオプションに関する情報を参照してください。
## Docker コンテナ AWS IoT Greengrass でのデバッグ
Docker コンテナの問題をデバッグするには、Greengrass ランタイムログを維持するか、Docker コンテナにインタラクティブシェルをアタッチすることができます。
### Docker コンテナの外部で Greengrass ログを永続化する
AWS IoT Greengrass コンテナを停止したら、次の`docker cp `コマンドを使用して Greengrass ログを Docker コンテナから一時ログディレクトリにコピーできます。
```
docker cp container-id:/greengrass/v2/logs /tmp/logs
```
コンテナが終了または削除された後もログを保持するには、`/greengrass/v2/logs`ディレクトリをバインドマウントした後に AWS IoT Greengrass Docker コンテナを実行する必要があります。
`/greengrass/v2/logs` ディレクトリをバインドマウントするには、新しい Docker AWS IoT Greengrass コンテナを実行するときに次のいずれかを実行します。
+ `docker run` コマンドに `-v /tmp/logs:/greengrass/v2/logs:ro` を含めます。
設定ファイル内の `volumes` ブロックを編集して、`docker-compose up` コマンドを実行する前に次の行を含めます。
```
volumes:
- /tmp/logs:/greengrass/v2/logs:ro
```
その後、 AWS IoT Greengrass が Docker コンテナ内で実行されている間に、ホスト`/tmp/logs`の でログをチェックして Greengrass ログを確認できます。
Greengrass Docker コンテナを実行するための情報については、「[手動プロビジョニングを使用して Docker AWS IoT Greengrass で を実行する](run-greengrass-docker-manual-provisioning.md)」および「[自動プロビジョニングを使用して Docker AWS IoT Greengrass で を実行する](run-greengrass-docker-automatic-provisioning.md)」を参照してください。
### インタラクティブシェルを Docker コンテナにアタッチする
Docker コンテナ内でコマンドを実行するにあたり `docker exec` を使用する場合、これらのコマンドは Docker ログにキャプチャされません。コマンドを Docker ログに記録すると、Greengrass Docker コンテナの状態を調査する際に役立ちます。次のいずれかを行います。
+ 別のターミナルで次のコマンドを実行して、ターミナルの標準入力、出力、およびエラーを実行中のコンテナにアタッチします。これにより、現在のターミナルから Docker コンテナを表示して、制御することができます。
```
docker attach container-id
```
+ 別のターミナルで次のコマンドを実行します。これにより、コンテナがアタッチされていない場合でも、コマンドをインタラクティブモードで実行できるようになります。
```
docker exec -it container-id sh -c "command > /proc/1/fd/1"
```
一般的な AWS IoT Greengrass トラブルシューティングについては、「」を参照してください[トラブルシューティング AWS IoT Greengrass V2](troubleshooting.md)。
# AWS IoT Greengrass Core ソフトウェアを設定する
AWS IoT Greengrass Core ソフトウェアには、ソフトウェアの設定に使用できるオプションが用意されています。デプロイを作成して、各 AWS IoT Greengrass コアデバイスで Core ソフトウェアを設定できます。
**Topics**
+ [Greengrass nucleus コンポーネントをデプロイする](#configure-nucleus-component)
+ [Greengrass nucleus をシステムサービスとして設定する](#configure-system-service)
+ [JVM オプションでメモリ割り当てを制御する](#jvm-tuning)
+ [コンポーネントを実行するユーザーを設定する](#configure-component-user)
+ [コンポーネントのシステムリソース制限を設定する](#configure-component-system-resource-limits)
+ [ポート 443 での接続またはネットワークプロキシを通じた接続](#configure-alpn-network-proxy)
+ [プライベート CA によって署名されたデバイス証明書を使用する](#configure-nucleus-private-ca)
+ [MQTT タイムアウトとキャッシュ設定を設定する](#configure-mqtt)
+ [IPv6 ネットワークで Greengrass Nucleus を設定する](#configure-ipv6)
## Greengrass nucleus コンポーネントをデプロイする
AWS IoT Greengrass は、Greengrass コアデバイスにデプロイできるコンポーネントとして AWS IoT Greengrass Core ソフトウェアを提供します。複数の Greengrass コアデバイスに同じ設定を適用するためのデプロイを作成することができます。詳細については、「[Greengrass nucleus](greengrass-nucleus-component.md)」および「[AWS IoT Greengrass Core ソフトウェア (OTA) の更新](update-greengrass-core-v2.md)」を参照してください。
## Greengrass nucleus をシステムサービスとして設定する
以下を実行するには、デバイスの init システムで AWS IoT Greengrass Core ソフトウェアをシステムサービスとして設定する必要があります。
+ デバイスの起動時に AWS IoT Greengrass Core ソフトウェアを起動します。これは、大量のデバイスのフリートを管理する場合に有効な方法です。
+ プラグインコンポーネントをインストールして実行します。いくつかの AWS提供されるコンポーネントはプラグインコンポーネントであり、Greengrass nucleus と直接インターフェイスできます。コンポーネントタイプの詳細については、「[コンポーネントタイプ](develop-greengrass-components.md#component-types)」を参照してください。
+ over-the-air (OTA) アップデートをコアデバイスの AWS IoT Greengrass Core ソフトウェアに適用します。詳細については、「[AWS IoT Greengrass Core ソフトウェア (OTA) の更新](update-greengrass-core-v2.md)」を参照してください。
+ デプロイによってコンポーネントが新しいバージョンに更新されるか、特定の設定パラメータが更新されると、コンポーネントが AWS IoT Greengrass Core ソフトウェアまたはコアデバイスを再起動できるようにします。詳細については、「[ブートストラップのライフサイクルステップ](component-recipe-reference.md#bootstrap-lifecycle-definition)」を参照してください。
**重要**
Windows コアデバイスでは、 AWS IoT Greengrass Core ソフトウェアをシステムサービスとして設定する必要があります。
**Topics**
+ [nucleus をシステムサービスとして設定する (Linux)](#configure-system-service-linux)
+ [nucleus をシステムサービスとして設定する (Windows)](#configure-system-service-windows)
### nucleus をシステムサービスとして設定する (Linux)
Linux デバイスは、initd、systemd、SystemV などの様々な初期化システムをサポートします。 AWS IoT Greengrass Core ソフトウェアをインストールして nucleus をシステムサービスとして起動し、デバイスの起動時に起動するように `--setup-system-service true`引数を設定します。インストーラは、systemd を使用するシステムサービスとして AWS IoT Greengrass Core ソフトウェアを設定します。
nucleus がシステムサービスとして実行するように、手動で設定することもできます。次の例は、systemd のサービスファイルです。
```
[Unit]
Description=Greengrass Core
[Service]
Type=simple
PIDFile=/greengrass/v2/alts/loader.pid
RemainAfterExit=no
Restart=on-failure
RestartSec=10
ExecStart=/bin/sh /greengrass/v2/alts/current/distro/bin/loader
[Install]
WantedBy=multi-user.target
```
システムサービスを設定したら、次のコマンドを実行して、起動時のデバイスの起動と AWS IoT Greengrass Core ソフトウェアの起動または停止を設定できます。
+ サービス (systemd) のステータスを確認するには
```
sudo systemctl status greengrass.service
```
+ デバイスの起動時に nucleus を起動できるようにするには。
```
sudo systemctl enable greengrass.service
```
+ デバイスの起動時に nucleus の起動を停止するには。
```
sudo systemctl disable greengrass.service
```
+ AWS IoT Greengrass Core ソフトウェアを起動するには。
```
sudo systemctl start greengrass.service
```
+ AWS IoT Greengrass Core ソフトウェアを停止するには。
```
sudo systemctl stop greengrass.service
```
### nucleus をシステムサービスとして設定する (Windows)
AWS IoT Greengrass Core ソフトウェアをインストールして nucleus を Windows サービスとして起動し、デバイスの起動時に起動するように `--setup-system-service true`引数を設定します。
サービスを設定したら、次のコマンドを実行して、起動時のデバイスの起動と AWS IoT Greengrass Core ソフトウェアの起動または停止を設定できます。これらのコマンドを実行するには、管理者としてコマンドプロンプトまたは PowerShell を実行する必要があります。
------
#### [ Windows Command Prompt (CMD) ]
+ サービスのステータスを確認するには
```
sc query "greengrass"
```
+ デバイスの起動時に nucleus を起動できるようにするには。
```
sc config "greengrass" start=auto
```
+ デバイスの起動時に nucleus の起動を停止するには。
```
sc config "greengrass" start=disabled
```
+ AWS IoT Greengrass Core ソフトウェアを起動するには。
```
sc start "greengrass"
```
+ AWS IoT Greengrass Core ソフトウェアを停止するには。
```
sc stop "greengrass"
```
**注記**
Windows デバイスでは、 AWS IoT Greengrass Core ソフトウェアは Greengrass コンポーネントプロセスをシャットダウンしている間、このシャットダウンシグナルを無視します。このコマンドを実行するときに AWS IoT Greengrass Core ソフトウェアがシャットダウンシグナルを無視する場合は、数秒待ってから再試行してください。
------
#### [ PowerShell ]
+ サービスのステータスを確認するには
```
Get-Service -Name "greengrass"
```
+ デバイスの起動時に nucleus を起動できるようにするには。
```
Set-Service -Name "greengrass" -Status stopped -StartupType automatic
```
+ デバイスの起動時に nucleus の起動を停止するには。
```
Set-Service -Name "greengrass" -Status stopped -StartupType disabled
```
+ AWS IoT Greengrass Core ソフトウェアを起動するには。
```
Start-Service -Name "greengrass"
```
+ AWS IoT Greengrass Core ソフトウェアを停止するには。
```
Stop-Service -Name "greengrass"
```
**注記**
Windows デバイスでは、 AWS IoT Greengrass Core ソフトウェアは Greengrass コンポーネントプロセスをシャットダウンしている間、このシャットダウンシグナルを無視します。このコマンドを実行するときに AWS IoT Greengrass Core ソフトウェアがシャットダウンシグナルを無視する場合は、数秒待ってから再試行してください。
------
## JVM オプションでメモリ割り当てを制御する
メモリが制限された AWS IoT Greengrass デバイスで実行している場合は、Java 仮想マシン (JVM) オプションを使用して、 AWS IoT Greengrass Core ソフトウェアが使用するメモリ量を制御する最大ヒープサイズ、ガベージコレクションモード、コンパイラオプションを制御できます。JVM のヒープサイズは、[ガベージコレクション](https://docs.oracle.com/javase/8/docs/technotes/guides/vm/gctuning/introduction.html)が発生する前、あるいはアプリケーションがメモリ不足になる前に、アプリケーションが使用できるメモリ量を決定します。最大ヒープサイズは、多量の作業を実行中にヒープを拡張する場合に JVM が割り当てることのできる最大メモリ容量を指定します。
メモリの割り当てを制御するには、新しいデプロイを作成するか、nucleus コンポーネントが含まれる既存のデプロイを修正し、[nucleus コンポーネント設定](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration-jvm-options)内の `jvmOptions` 設定パラメータで JVM オプションを指定します。
要件に応じて、メモリ割り当てを減らしたり、最小限のメモリ割り当てで AWS IoT Greengrass Core ソフトウェアを実行できます。
**メモリ割り当ての削減**
メモリ割り当てを減らして AWS IoT Greengrass Core ソフトウェアを実行するには、次の設定マージ更新例を使用して nucleus 設定で JVM オプションを設定することをお勧めします。
```
{
"jvmOptions": "-XX:+UseSerialGC -XX:TieredStopAtLevel=1"
}
```
**最小限のメモリ割り当て**
最小メモリ割り当てで AWS IoT Greengrass Core ソフトウェアを実行するには、次の設定マージ更新例を使用して nucleus 設定で JVM オプションを設定することをお勧めします。
```
{
"jvmOptions": "-Xmx32m -XX:+UseSerialGC -Xint"
}
```
**重要**
最小メモリ割り当てで AWS IoT Greengrass Core ソフトウェアを実行すると、JVM がより少ないメモリを使用するときにより多くの処理を行うため、低スペックシステムのパフォーマンスに大きな影響を与える可能性があります。メモリとパフォーマンスのニーズのバランスを取るために、オプションを調整することをお勧めします。
これらの設定マージ更新例では、次の JVM オプションを使用します。
`-XX:+UseSerialGC`
JVM ヒープスペースにシリアルガベージコレクションを使用するように指定します。シリアルガベージコレクタは速度が遅くなりますが、他の JVM ガベージコレクションの実装と比べると使用するメモリが少なくなります。
`-XX:TieredStopAtLevel=1`
Java ジャストインタイム (JIT) コンパイラを一度使用するように、JVM に指示します。JIT でコンパイルされたコードはデバイスメモリ内のスペースを使用するため、JIT コンパイラを複数回使用すると、1 回のコンパイルよりも多くのメモリを消費します。
`-XmxNNm`
JVM の最大ヒープサイズを設定します。
最大ヒープサイズの設定が低すぎると、パフォーマンスが低下したり、メモリ不足エラーが発生する可能性があります。`-XmxNNm` オプションで最大サイズを設定する前に、現在のヒープ使用量を測定することをお勧めします。JVM オプションを使用して `-XX:NativeMemoryTracking=detail` JVM を設定します。次に、[jcmd Utility](https://docs.oracle.com/javase/8/docs/technotes/guides/troubleshoot/tooldescr006.html) 内の `VM.native_memory` コマンドリクエストを使用して、現在のヒープ使用量を測定します。
ヒープの測定がオプションでない場合は、開始値として `-Xmx64m` を使用してヒープサイズを 64 MB に制限します。その後、そこから最大ヒープサイズを段階的に減らしていきます。最小限のメモリ割り当てにする場合は、`-Xmx32m` を開始値として指定し、ヒープサイズを 32 MB に制限します。
実際の要件に応じて、`-Xmx` の値は増減することができますが、最大ヒープサイズは 16 MB 以下に設定しないことを強く推奨します。また、必要な JVM ヒープサイズは、コアデバイスにデプロイされたプラグインコンポーネントをもとに、時間の経過とともに変化する場合もあります。最大ヒープサイズが環境に対して低すぎると、メモリ不足が原因で AWS IoT Greengrass Core ソフトウェアで予期しないエラーが発生する可能性があります。メモリ不足が原因でパフォーマンスが低下したり、エラーが発生したりする場合は、既知の正常な設定に戻します。例えば、通常のコミットヒープサイズが `41428KB` の場合、`-Xmx40m` を使用してヒープ使用量をわずかに制限します。
`-Xint`
Java ジャストインタイム (JIT) コンパイラを使用しないように、JVM に指示します。代わりに、JVM は解釈専用モードで実行されます。このモードは JIT コンパイルコードを実行する場合よりも速度は遅く (低価格帯システムへのデプロイと比較して、潜在的に 20 倍遅くなる) なりますが、コンパイルされたコードはメモリ内のスペースを使用しません。
設定マージ更新の作成については、「[コンポーネント設定の更新](update-component-configurations.md)」を参照してください。
## コンポーネントを実行するユーザーを設定する
AWS IoT Greengrass Core ソフトウェアは、ソフトウェアを実行するものとは異なるシステムユーザーおよびグループとしてコンポーネントプロセスを実行できます。これにより、 AWS IoT Greengrass コアデバイスで実行されるコンポーネントにアクセス許可を付与することなく、 Core ソフトウェアをルートとして、または管理者ユーザーとして実行できるため、セキュリティが向上します。
次の表は、指定したユーザーとして AWS IoT Greengrass Core ソフトウェアが実行できるコンポーネントのタイプを示しています。詳細については、「[コンポーネントタイプ](develop-greengrass-components.md#component-types)」を参照してください。
| コンポーネントタイプ | コンポーネントユーザを設定する |
| --- | --- |
| nucleus | ![\[No\]](http://docs.aws.amazon.com/ja_jp/greengrass/v2/developerguide/images/icon-no.png) いいえ |
| プラグイン | ![\[No\]](http://docs.aws.amazon.com/ja_jp/greengrass/v2/developerguide/images/icon-no.png) いいえ |
| ジェネリック | ![\[Yes\]](http://docs.aws.amazon.com/ja_jp/greengrass/v2/developerguide/images/icon-yes.png) はい |
| Lambda (非コンテナ化) | ![\[Yes\]](http://docs.aws.amazon.com/ja_jp/greengrass/v2/developerguide/images/icon-yes.png) はい |
| Lambda (コンテナ化) | ![\[Yes\]](http://docs.aws.amazon.com/ja_jp/greengrass/v2/developerguide/images/icon-yes.png) はい |
デプロイ設定で指定する前に、コンポーネントユーザーを作成する必要があります。Windows ベースのデバイスでは、LocalSystem アカウントの認証情報マネージャーインスタンスにも、ユーザーのユーザー名とパスワードを保存する必要があります。詳細については、「[Windows デバイスでコンポーネントユーザーをセットアップする](#create-component-user-windows)」を参照してください。
Linux ベースのデバイスでコンポーネントユーザーを設定する場合、オプションでグループを指定することもできます。ユーザーとグループを `user:group` の形式に従ってコロン (`:`) で区切って指定します。グループを指定しない場合、 AWS IoT Greengrass Core ソフトウェアはデフォルトでユーザーのプライマリグループになります。名前または ID を使用して、ユーザーとグループを識別できます。
Linux ベースのデバイスでは、コンポーネントを存在しないシステムユーザー (不明なユーザーとも呼ばれる) として実行することで、セキュリティを強化することもできます。Linux プロセスは、同じユーザーによって実行される他のプロセスに信号を送ることができます。不明なユーザーは他のプロセスを実行しないため、コンポーネントを不明なユーザーとして実行して、コンポーネントがコアデバイス上の他のコンポーネントに信号を送るのを防ぐことができます。コンポーネントを不明なユーザーとして実行するには、コアデバイスに存在しないユーザー ID を指定します。不明なグループとして実行する場合は、存在しないグループ ID を指定することもできます。
各コンポーネントと各コアデバイスごとに、ユーザーを設定することができます。
+ **コンポーネントの設定**
各コンポーネントが、そのコンポーネントに固有のユーザーで実行されるように設定することができます。デプロイを作成するときに、各コンポーネントのユーザをそのコンポーネントの `runWith` 設定で指定できます。 AWS IoT Greengrass Core ソフトウェアは、コンポーネントを設定した場合、指定されたユーザーとしてコンポーネントを実行します。設定がない場合は、コアデバイス用に設定したデフォルトのユーザーとしてコンポーネントを実行します。デプロイ設定でコンポーネントユーザーを指定するための詳細については、[デプロイの作成](create-deployments.md) の [`runWith`](create-deployments.md#component-run-with-config) 設定パラメータを参照してください。
+ **コアデバイスのデフォルトユーザーを設定する**
AWS IoT Greengrass Core ソフトウェアがコンポーネントの実行に使用するデフォルトユーザーを設定できます。 AWS IoT Greengrass Core ソフトウェアは、コンポーネントを実行するときに、そのコンポーネントのユーザーを指定しているかどうかを確認し、それを使用してコンポーネントを実行します。コンポーネントがユーザーを指定しない場合、 AWS IoT Greengrass Core ソフトウェアはコアデバイス用に設定したデフォルトユーザーとしてコンポーネントを実行します。詳細については、「[デフォルトのコンポーネントユーザーを設定する](#configure-default-component-user)」を参照してください。
**注記**
Windows ベースのデバイスでは、コンポーネントを実行するにあたり、少なくとも一人のデフォルトユーザーを指定する必要があります。
Linux ベースのデバイスでは、コンポーネントを実行するユーザーを設定しない場合には、以下について考慮する必要があります。
AWS IoT Greengrass Core ソフトウェアをルートとして実行した場合、ソフトウェアはコンポーネントを実行しません。root として実行する場合は、コンポーネントを実行するデフォルトユーザーを指定する必要があります。
AWS IoT Greengrass Core ソフトウェアを非ルートユーザーとして実行する場合、ソフトウェアはそのユーザーとしてコンポーネントを実行します。
**Topics**
+ [Windows デバイスでコンポーネントユーザーをセットアップする](#create-component-user-windows)
+ [デフォルトのコンポーネントユーザーを設定する](#configure-default-component-user)
### Windows デバイスでコンポーネントユーザーをセットアップする
**Windows デバイスでコンポーネントユーザーをセットアップするには**
1. デバイス上の LocalSystem アカウントにデフォルトユーザーを作成します。
```
net user /add component-user password
```
1. [Microsoft の PsExec ユーティリティ](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec)を使用して、コンポーネントユーザーのユーザー名とパスワードを LocalSystem アカウントの認証情報マネージャインスタンスに格納します。
```
psexec -s cmd /c cmdkey /generic:component-user /user:component-user /pass:password
```
**注記**
Windows デバイスでは、LocalSystem アカウントが Greengrass nucleus を実行します。コンポーネントユーザー情報を LocalSystem アカウントに保存するには、PsExec ユーティリティを使用する必要があります。認証情報マネージャーアプリケーションを使用すると、この情報は LocalSystem アカウントではなく、現在ログオンしているユーザーの Windows アカウントに保存されます。
### デフォルトのコンポーネントユーザーを設定する
デプロイを使用して、コアデバイスのデフォルトユーザーを設定できます。このデプロイでは、[nucleus コンポーネント](greengrass-nucleus-component.md)の設定を更新します。
**注記**
`--component-default-user` オプションを使用して AWS IoT Greengrass Core ソフトウェアをインストールするときに、デフォルトユーザーを設定することもできます。詳細については、「[AWS IoT Greengrass Core ソフトウェアをインストールします。](install-greengrass-core-v2.md)」を参照してください。
`aws.greengrass.Nucleus` コンポーネントに対する、以下の設定更新を指定する[デプロイを作成します](create-deployments.md)。
------
#### [ Linux ]
```
{
"runWithDefault": {
"posixUser": "ggc_user:ggc_group"
}
}
```
------
#### [ Windows ]
```
{
"runWithDefault": {
"windowsUser": "ggc_user"
}
}
```
**注記**
指定するユーザーが存在し、このユーザーのユーザー名とパスワードが、Windows デバイス上にある LocalSystem アカウントの認証情報マネージャーインスタンスに格納されている必要があります。詳細については、「[Windows デバイスでコンポーネントユーザーをセットアップする](#create-component-user-windows)」を参照してください。
------
次の例では、`ggc_user` をデフォルトユーザー、および `ggc_group` をデフォルトグループとして設定する Linux ベースのデバイスのデプロイを定義しています。`merge` 設定の更新には、シリアル化された JSON オブジェクトが必要です。
```
{
"components": {
"aws.greengrass.Nucleus": {
"version": "2.16.1",
"configurationUpdate": {
"merge": "{\"runWithDefault\":{\"posixUser\":\"ggc_user:ggc_group\"}}"
}
}
}
}
```
## コンポーネントのシステムリソース制限を設定する
**注記**
この機能は、[Greengrass nucleus コンポーネントの](greengrass-nucleus-component.md) v2.4.0 以降で使用できます。現在、この機能は Windows AWS IoT Greengrass コアデバイスでサポートされていません。
各コンポーネントのプロセスがコアデバイスで使用できる CPU および RAM の最大使用数を設定できます。
下表は、システムリソースの制限をサポートするコンポーネントの種類を示したものです。詳細については、「[コンポーネントタイプ](develop-greengrass-components.md#component-types)」を参照してください。
| コンポーネントタイプ | システムリソースの制限を設定する |
| --- | --- |
| nucleus | ![\[No\]](http://docs.aws.amazon.com/ja_jp/greengrass/v2/developerguide/images/icon-no.png) いいえ |
| プラグイン | ![\[No\]](http://docs.aws.amazon.com/ja_jp/greengrass/v2/developerguide/images/icon-no.png) いいえ |
| ジェネリック | ![\[Yes\]](http://docs.aws.amazon.com/ja_jp/greengrass/v2/developerguide/images/icon-yes.png) はい |
| Lambda (非コンテナ化) | ![\[Yes\]](http://docs.aws.amazon.com/ja_jp/greengrass/v2/developerguide/images/icon-yes.png) はい |
| Lambda (コンテナ化) | ![\[No\]](http://docs.aws.amazon.com/ja_jp/greengrass/v2/developerguide/images/icon-no.png) いいえ |
**重要**
[Docker コンテナで AWS IoT Greengrass Core ソフトウェアを実行する場合、](run-greengrass-docker.md)システムリソースの制限はサポートされていません。
各コンポーネントと各コアデバイスごとに、システムリソースの制限を設定することができます。
+ **コンポーネントの設定**
各コンポーネントは、そのコンポーネントに固有のシステムリソース制限を設定することができます。デプロイを作成するときに、デプロイ内の各コンポーネントに対して、システムリソースの制限を指定することができます。コンポーネントがシステムリソース制限をサポートしている場合、 AWS IoT Greengrass Core ソフトウェアは、コンポーネントのプロセスにその制限を適用します。コンポーネントのシステムリソース制限を指定しない場合、 AWS IoT Greengrass Core ソフトウェアはコアデバイスに設定したデフォルトを使用します。詳細については、「[デプロイの作成](create-deployments.md)」を参照してください。
+ **コアデバイスのデフォルトを設定する**
AWS IoT Greengrass Core ソフトウェアがこれらの制限をサポートするコンポーネントに適用するデフォルトのシステムリソース制限を設定できます。 AWS IoT Greengrass Core ソフトウェアがコンポーネントを実行すると、そのコンポーネントに指定したシステムリソース制限が適用されます。そのコンポーネントがシステムリソース制限を指定しない場合、 AWS IoT Greengrass Core ソフトウェアはコアデバイス用に設定したデフォルトのシステムリソース制限を適用します。デフォルトのシステムリソース制限を指定しない場合、 AWS IoT Greengrass Core ソフトウェアはデフォルトでシステムリソース制限を適用しません。詳細については、「[デフォルトのシステムリソース制限を設定する](#configure-default-component-system-resource-limits)」を参照してください。
### デフォルトのシステムリソース制限を設定する
[Greengrass nucleus コンポーネント](greengrass-nucleus-component.md)をデプロイして、コアデバイスのデフォルトのシステムリソース制限を設定することができます。デフォルトのシステムリソース制限を設定するには、`aws.greengrass.Nucleus` コンポーネントに対して次の設定更新を指定する[デプロイを作成します](create-deployments.md)。
```
{
"runWithDefault": {
"systemResourceLimits": {
"cpu": cpuTimeLimit,
"memory": memoryLimitInKb
}
}
}
```
次の例では、CPU 時間制限を `2` (4 つの CPU コアを持つデバイスでの使用量 50％ に相当) に設定するデプロイを定義しています。また、この例ではメモリ使用量を 100 MB に設定しています。
```
{
"components": {
"aws.greengrass.Nucleus": {
"version": "2.16.1",
"configurationUpdate": {
"merge": "{\"runWithDefault\":{\"systemResourceLimits\":\"cpus\":2,\"memory\":102400}}}"
}
}
}
}
```
## ポート 443 での接続またはネットワークプロキシを通じた接続
AWS IoT Greengrass コアデバイスは、TLS クライアント認証で MQTT メッセージングプロトコル AWS IoT Core を使用して と通信します。慣例では、TLS を介した MQTT ではポート 8883 を使用します。ただし、セキュリティ対策として、制限の厳しい環境では一定範囲の TCP ポートに対するインバウンドトラフィックとアウトバウンドトラフィックを制限する場合があります。例えば、企業のファイアウォールでは HTTPS トラフィック用のポート 443 は開いても、あまり一般的ではないプロトコル用の他のポート (MQTT トラフィック用のポート 8883 など) は閉じる場合があります。他にも、制限のある環境によっては、インターネットに接続する前に、すべてのトラフィックがプロキシを経由する必要が生じる場合もあります。
**注記**
Greengrass [nucleus コンポーネント v2.0.3 以前を実行する Greengrass ](greengrass-nucleus-component.md)コアデバイスは、ポート 8443 を使用して AWS IoT Greengrass データプレーンエンドポイントに接続します。これらのデバイスは、ポート 8443 でこのエンドポイントに接続できる必要があります。詳細については、「[プロキシまたはファイアウォールを介したデバイストラフィックを許可する](allow-device-traffic.md)」を参照してください。
これらのシナリオで通信を有効にするために、 には次の設定オプション AWS IoT Greengrass が用意されています。
+ **ポート 443 を介した MQTT 通信**。ネットワークでポート 443 への接続を許可している場合は、デフォルトのポート 8883 ではなくポート 443 を MQTT トラフィックに使用するように、Greengrass コアデバイスを設定することができます。ポート 443 への直接接続またはネットワークプロキシサーバーを介した接続を使用できます。証明書ベースのクライアント認証を使用するデフォルト設定とは異なり、ポート 443 上の MQTT は認証に[デバイスのサービスロール](device-service-role.md)を使用します。
詳細については、「[ポート 443 経由で MQTT を設定する](#configure-mqtt-port-443)」を参照してください。
+ **ポート 443 を介した HTTPS 通信**。 AWS IoT Greengrass Core ソフトウェアはデフォルトでポート 8443 経由で HTTPS トラフィックを送信しますが、ポート 443 を使用するように設定できます。 AWS IoT Greengrass は [Application Layer Protocol Network](https://tools.ietf.org/html/rfc7301) (ALPN) TLS 拡張機能を使用してこの接続を有効にします。デフォルト設定と同様に、ポート 443 経由の HTTPS は証明書ベースのクライアント認証を使用します。
**重要**
ALPN を使用したポート 443 経由の HTTPS 通信を有効にするためには、コアデバイスで Java 8 更新 252 以降が実行されている必要があります。Java バージョン 9 以降のすべての更新も、ALPN をサポートしています。
詳細については、「[ポート 443 経由で HTTPS を設定する](#configure-https-port-443)」を参照してください。
+ **ネットワークプロキシを介した接続**。ネットワークプロキシサーバーを Greengrass コアデバイスに接続するための仲介役として設定できます。 AWS IoT Greengrass は、HTTP および HTTPS プロキシに対する基本認証をサポートしています。
HTTPS プロキシを使用するには、Greengrass コアデバイスで [Greengrass nucleus ](greengrass-nucleus-component.md) v2.5.0 以降を実行している必要があります。
AWS IoT Greengrass Core ソフトウェアは、、`ALL_PROXY`、、`HTTP_PROXY``HTTPS_PROXY`および `NO_PROXY`環境変数を介してプロキシ設定をコンポーネントに渡します。コンポーネントはこれらの設定を使用して、プロキシ経由で接続する必要があります。コンポーネントは、一般的なライブラリ (boto3、cURL、python `requests` パッケージなど) を使用し、通常、これらの環境変数をデフォルトで使用して接続を行います。関数もこれらの同じ環境変数を指定した場合、 AWS IoT Greengrass ではオーバーライドされません。
詳細については、「[ネットワークプロキシを設定する](#configure-network-proxy)」を参照してください。
### ポート 443 経由で MQTT を設定する
既存のコアデバイスに、または新しいコアデバイスに AWS IoT Greengrass Core ソフトウェアをインストールする際に、ポート 443 経由で MQTT を設定することができます。
**Topics**
+ [既存のコアデバイスにポート 443 経由で MQTT を設定する](#configure-mqtt-port-443-deployment)
+ [インストール中にポート 443 経由で MQTT を設定する](#configure-mqtt-port-443-installer)
#### 既存のコアデバイスにポート 443 経由で MQTT を設定する
デプロイを使用して、単一のコアデバイスまたはコアデバイスのグループに MQTT をポート 443 経由で設定できます。このデプロイでは、[nucleus コンポーネント](greengrass-nucleus-component.md)の設定を更新します。`mqtt` 設定を更新すると、nucleus が再起動します。
ポート 443経由で MQTT を設定するには、`aws.greengrass.Nucleus` コンポーネントに以下の設定更新を指定する[デプロイを作成します](create-deployments.md)。
```
{
"mqtt": {
"port": 443
}
}
```
次の例では、ポート 443 経由で MQTT を設定するデプロイを定義します。`merge` 設定の更新には、シリアル化された JSON オブジェクトが必要です。
```
{
"components": {
"aws.greengrass.Nucleus": {
"version": "2.16.1",
"configurationUpdate": {
"merge": "{\"mqtt\":{\"port\":443}}"
}
}
}
}
```
#### インストール中にポート 443 経由で MQTT を設定する
Core ソフトウェアを AWS IoT Greengrass コアデバイスにインストールするときに、ポート 443 経由で MQTT を設定できます。ポート 443 経由で MQTT を設定するには、`--init-config` インストーラ引数を使用します。この引数は、[手動によるプロビジョニング](manual-installation.md)、[フリートプロビジョニング](fleet-provisioning.md)、または[カスタムプロビジョニング](custom-provisioning.md)でインストールするときに指定できます。
### ポート 443 経由で HTTPS を設定する
この機能を使用するには、[Greengrass nucleus](greengrass-nucleus-component.md) v2.0.4 以降が必要です。
既存のコアデバイスに、または新しいコアデバイスに AWS IoT Greengrass Core ソフトウェアをインストールする際に、ポート 443 経由で HTTPS を設定することができます。
**Topics**
+ [既存のコアデバイスにポート 443 経由で HTTPS を設定する](#configure-https-port-443-deployment)
+ [インストール中にポート 443 経由で HTTPS を設定する](#configure-https-port-443-installer)
#### 既存のコアデバイスにポート 443 経由で HTTPS を設定する
デプロイを使用して、単一のコアデバイスまたはコアデバイスのグループに HTTPS をポート 443 経由で設定できます。このデプロイでは、[nucleus コンポーネント](greengrass-nucleus-component.md)の設定を更新します。
ポート 443 経由で HTTPS を設定するには、`aws.greengrass.Nucleus` コンポーネントに以下の設定更新を指定する[デプロイを作成します](create-deployments.md)。
```
{
"greengrassDataPlanePort": 443
}
```
次の例では、ポート 443 経由で HTTPS を設定するデプロイを定義します。`merge` 設定の更新には、シリアル化された JSON オブジェクトが必要です。
```
{
"components": {
"aws.greengrass.Nucleus": {
"version": "2.16.1",
"configurationUpdate": {
"merge": "{\"greengrassDataPlanePort\":443}"
}
}
}
}
```
#### インストール中にポート 443 経由で HTTPS を設定する
Core ソフトウェアを AWS IoT Greengrass コアデバイスにインストールするときに、ポート 443 経由で HTTPS を設定できます。ポート 443 経由で HTTPS を設定するには、`--init-config` インストーラ引数を使用します。この引数は、[手動によるプロビジョニング](manual-installation.md)、[フリートプロビジョニング](fleet-provisioning.md)、または[カスタムプロビジョニング](custom-provisioning.md)でインストールするときに指定できます。
### ネットワークプロキシを設定する
このセクションの手順に従って、Greengrass コアデバイスが HTTP または HTTPS ネットワークプロキシを介してインターネットに接続するように設定します。コアデバイスが使用するエンドポイントとポートの詳細については、「[プロキシまたはファイアウォールを介したデバイストラフィックを許可する](allow-device-traffic.md)」を参照してください。
**重要**
コアデバイスで [Greengrass nucleus](greengrass-nucleus-component.md) v2.4.0 以前のバージョンが動作している場合、ネットワークプロキシを使用するには、デバイスのロールが以下の権限を許可している必要があります。
`iot:Connect`
`iot:Publish`
`iot:Receive`
`iot:Subscribe`
これは、デバイスがトークン交換サービスの AWS 認証情報を使用して MQTT 接続を認証するため必要です AWS IoT。デバイスは MQTT を使用して からデプロイを受信およびインストールするため AWS クラウド、ロールにこれらのアクセス許可を定義しない限り、デバイスは機能しません。デバイスは通常 MQTT 接続を認証するために X.509 証明書を使用しますが、プロキシを使用している場合には、認証にこれを使用できません。
デバイスのロールを設定する方法の詳細については、「[コアデバイスが AWS サービスとやり取りできるように認可する](device-service-role.md)」を参照してください。
**Topics**
+ [既存のコアデバイスでネットワークプロキシを設定する](#configure-network-proxy-deployment)
+ [インストール中にネットワークプロキシを設定する](#configure-network-proxy-installer)
+ [コアデバイスが HTTPS プロキシを信頼できるようにする](#https-proxy-certificate-trust)
+ [networkProxy オブジェクト](#network-proxy-object)
#### 既存のコアデバイスでネットワークプロキシを設定する
デプロイを使用して、単一のコアデバイスまたはコアデバイスのグループにネットワークプロキシを設定できます。このデプロイでは、[nucleus コンポーネント](greengrass-nucleus-component.md)の設定を更新します。`networkProxy` 設定を更新すると、nucleus が再起動します。
ネットワークプロキシを設定するには、`aws.greengrass.Nucleus` コンポーネントに以下の設定更新をマージする[デプロイを作成します](create-deployments.md)。この設定更新プログラムには、[networkProxy オブジェクト](#network-proxy-object)が含まれます。
```
{
"networkProxy": {
"noProxyAddresses": "http://192.168.0.1,www.example.com",
"proxy": {
"url": "https://my-proxy-server:1100"
}
}
}
```
次の例では、ネットワークプロキシを設定するデプロイを定義します。`merge` 設定の更新には、シリアル化された JSON オブジェクトが必要です。
```
{
"components": {
"aws.greengrass.Nucleus": {
"version": "2.16.1",
"configurationUpdate": {
"merge": "{\"networkProxy\":{\"noProxyAddresses\":\"http://192.168.0.1,www.example.com\",\"proxy\":{\"url\":\"https://my-proxy-server:1100\",\"username\":\"Mary_Major\",\"password\":\"pass@word1357\"}}}"
}
}
}
}
```
#### インストール中にネットワークプロキシを設定する
Core ソフトウェアを AWS IoT Greengrass コアデバイスにインストールするときに、ネットワークプロキシを設定できます。`--init-config` インストーラ引数を使用して、ネットワークプロキシを設定します。この引数は、[手動によるプロビジョニング](manual-installation.md)、[フリートプロビジョニング](fleet-provisioning.md)、または[カスタムプロビジョニング](custom-provisioning.md)でインストールするときに指定できます。
#### コアデバイスが HTTPS プロキシを信頼できるようにする
HTTPS プロキシを使用するようにコアデバイスを設定する場合は、コアデバイスにプロキシサーバー証明書チェーンを追加して、コアデバイスが HTTPS プロキシを信頼するようにする必要があります。この設定を行わなかった場合、コアデバイスがプロキシ経由でトラフィックをルーティングしようとしたときにエラーが発生する可能性があります。コアデバイスの Amazon ルート CA 証明書ファイルにプロキシサーバー CA 証明書を追加します。
**コアデバイスに HTTPS プロキシを信頼させるには**
1. コアデバイス上で Amazon ルート CA 証明書ファイルを検索します。
+ [自動プロビジョニング](quick-installation.md)を使用して AWS IoT Greengrass Core ソフトウェアをインストールした場合、Amazon ルート CA 証明書ファイルは にあります`/greengrass/v2/rootCA.pem`。
+ [手動](manual-installation.md)プロビジョニングまたは[フリートプロビジョニング](fleet-provisioning.md)を使用して AWS IoT Greengrass Core ソフトウェアをインストールした場合、Amazon ルート CA 証明書ファイルが に存在する可能性があります`/greengrass/v2/AmazonRootCA1.pem`。
Amazon ルート CA 証明書がこれらの場所に存在しない場合は、`/greengrass/v2/config/effectiveConfig.yaml` の `system.rootCaPath` プロパティを確認して場所を見つけます。
1. Amazon ルート CA 証明書ファイルにプロキシサーバー CA 証明書ファイルの内容を追加します。
次の例は、Amazon ルート CA 証明書ファイルに追加されたプロキシサーバー CA 証明書を示しています。
```
-----BEGIN CERTIFICATE-----
MIIEFTCCAv2gAwIQWgIVAMHSAzWG/5YVRYtRQOxXUTEpHuEmApzGCSqGSIb3DQEK
\nCwUAhuL9MQswCQwJVUzEPMAVUzEYMBYGA1UECgwP1hem9uLmNvbSBJbmMuMRww
... content of proxy CA certificate ...
+vHIRlt0e5JAm5\noTIZGoFbK82A0/nO7f/t5PSIDAim9V3Gc3pSXxCCAQoFYnui
GaPUlGk1gCE84a0X\n7Rp/lND/PuMZ/s8YjlkY2NmYmNjMCAXDTE5MTEyN2cM216
gJMIADggEPADf2/m45hzEXAMPLE=
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
MIIDQTCCAimgF6AwIBAgITBmyfz/5mjAo54vB4ikPmljZKyjANJmApzyMZFo6qBg
ADA5MQswCQYDVQQGEwJVUzEPMA0tMVT8QtPHRh8jrdkGA1UEChMGDV3QQDExBBKW
... content of root CA certificate ...
o/ufQJQWUCyziar1hem9uMRkwFwYVPSHCb2XV4cdFyQzR1KldZwgJcIQ6XUDgHaa
5MsI+yMRQ+hDaXJiobldXgjUka642M4UwtBV8oK2xJNDd2ZhwLnoQdeXeGADKkpy
rqXRfKoQnoZsG4q5WTP46EXAMPLE
-----END CERTIFICATE-----
```
#### networkProxy オブジェクト
ネットワークプロキシに関する情報を指定するには、`networkProxy` オブジェクトを使用します。このオブジェクトには、次の情報が含まれます。
`noProxyAddresses`
(オプション) プロキシの対象外となる IP アドレスやホスト名をカンマで区切ったリスト。
`proxy`
接続先のプロキシ。このオブジェクトには、次の情報が含まれます。
`url`
プロキシサーバーの URL (`scheme://userinfo@host:port` 形式)。
+ `scheme` - スキーム。`http` または `https` である必要があります。
**重要**
HTTPS プロキシを使用するには、Greengrass コアデバイスで [Greengrass nucleus ](greengrass-nucleus-component.md) v2.5.0 以降を実行している必要があります。
HTTPS プロキシを設定する場合は、コアデバイスの Amazon ルート CA 証明書にプロキシサーバー CA 証明書を追加する必要があります。詳細については、「[コアデバイスが HTTPS プロキシを信頼できるようにする](#https-proxy-certificate-trust)」を参照してください。
+ `userinfo` - (オプション) ユーザー名とパスワードの情報。この情報を `url` で指定する場合、Greengrass コアデバイスは `username` および `password` フィールドを無視します。
+ `host` – プロキシサーバーのホスト名または IP アドレス。
+ `port` - (オプション) ポート番号。ポートを指定しない場合、Greengrass コアデバイスは次のデフォルト値を使用します。
+ `http` – 80
+ `https` – 443
`username`
(オプション) プロキシサーバーを認証するユーザー名です。
`password`
(オプション) プロキシサーバーを認証するパスワードです。
## プライベート CA によって署名されたデバイス証明書を使用する
カスタムのプライベート認証機関 (CA) を使用する場合は、 Greengrass nucleus の **greengrassDataPlaneEndpoint** で **iotdata** を設定する必要があります。このオプションは、**--init-config** [インストーラ引数](configure-installer.md)を使用するデプロイまたはインストール中に設定できます。
デバイスが接続する Greengrass データプレーンのエンドポイントを、カスタマイズすることができます。この設定オプションを **iotdata** に設定して、Greengrass データプレーンエンドポイントを (**iotDataEndpoint** により指定することが可能な) IoT データエンドポイントと同じエンドポイントに設定できます。
## MQTT タイムアウトとキャッシュ設定を設定する
AWS IoT Greengrass 環境では、コンポーネントは MQTT を使用して通信できます AWS IoT Core。 AWS IoT Greengrass Core ソフトウェアは、コンポーネントの MQTT メッセージを管理します。コアデバイスが AWS クラウドへの接続を失うと、ソフトウェアは MQTT メッセージをキャッシュして、接続が復元されたときに後で再試行します。メッセージのタイムアウトやキャッシュのサイズなどの設定を設定できます。詳細については、「[Greengrass nucleus コンポーネント](greengrass-nucleus-component.md)」の「`mqtt` および `mqtt.spooler` 設定パラメータ」を参照してください。
AWS IoT Core は、MQTT メッセージブローカーにサービスクォータを課します。これらのクォータは、コアデバイスと AWS IoT Core間に送信されるメッセージに適用される場合があります。詳細については、「*AWS 全般のリファレンス*」の「[AWS IoT Core message broker service quotas](https://docs.aws.amazon.com/general/latest/gr/iot-core.html#message-broker-limits)」を参照してください。
## IPv6 ネットワークで Greengrass Nucleus を設定する
Greengrass Nucleus は Greengrass API AWS IoT Core を通じて と通信します。 [ APIs](https://docs.aws.amazon.com/general/latest/gr/greengrassv2.html) Greengrass API は、デュアルスタック環境で IPv6 をサポートしています。
IPv6 のデュアルスタックエンドポイントを有効にするには:
+ システムプロパティ `aws.useDualstackEndpoint=true`、および `java.net.preferIPv6Addresses=true` を `jvmOptions` に追加します
+ `s3EndpointType` を `DUALSTACK` に設定します。
[デプロイ](https://docs.aws.amazon.com/greengrass/v2/developerguide/create-deployments.html)時にこのオプションを設定するか、`--init-config` [インストーラ引数](https://docs.aws.amazon.com/greengrass/v2/developerguide/configure-installer.html)を使用して手動でプロビジョニングします。詳細については、「[Using Amazon S3 dual-stack endpoints](https://docs.aws.amazon.com/AmazonS3/latest/API/dual-stack-endpoints.html)」を参照してください。
**Example デプロイ用のコード:**
```
{
"jvmOptions": "-Daws.useDualstackEndpoint=true",
"s3EndpointType":"DUALSTACK"
}
```
**Example 手動プロビジョニングによる `config.yaml`:**
```
---
system:
...
services:
aws.greengrass.Nucleus:
...
configuration:
...
jvmOptions: "-Daws.useDualstackEndpoint=true -Djava.net.preferIPv6Addresses=true"
s3EndpointType: "DUALSTACK"
```
# AWS IoT Greengrass Core ソフトウェア (OTA) の更新
AWS IoT Greengrass Core ソフトウェアは、ソフトウェアに無線通信 (OTA) を実行するためにデバイスに展開できる [Greengrass nucleus コンポーネント](greengrass-nucleus-component.md)と他のオプションコンポーネントで設定されています。この機能は AWS IoT Greengrass Core ソフトウェアに組み込まれています。
OTA 更新により、以下の作業の効率が向上します。
+ セキュリティの脆弱性を修正する。
+ ソフトウェアの安定性の問題に対処する。
+ 新しい機能や改良された機能をデプロイする。
**Topics**
+ [要件](#ota-update-requirements)
+ [コアデバイスの考慮事項](#ota-update-considerations)
+ [Greengrass nucleus の更新動作](#ota-update-behavior-nucleus)
+ [OTA 更新の実行](#create-ota-update)
## 要件
AWS IoT Greengrass Core ソフトウェアに対する OTA 更新をデプロイするため、次の要件が適用されます:
+ Greengrass コアデバイスはデプロイを受信するため、AWS クラウド への接続が必要です。
+ Greengrass コアデバイスは、AWS IoT Core と AWS IoT Greengrass を使用した認証用の証明書とキーで正しく設定およびプロビジョニングする必要があります。
+ AWS IoT Greengrass Core ソフトウェアは、システムサービスとしてセットアップして実行する必要があります。nucleus を JAR ファイル、`Greengrass.jar` から実行する場合、OTA 更新は機能しません。詳細については、「[Greengrass nucleus をシステムサービスとして設定する](configure-greengrass-core-v2.md#configure-system-service)」を参照してください。
## コアデバイスの考慮事項
OTA 更新を実行する前に、更新するコアデバイスと接続されているクライアントデバイスへの影響に注意してください:
+ Greengrass nucleus がシャットダウンします。
+ コアデバイスで実行されているすべてのコンポーネントもシャットダウンされます。これらのコンポーネントがローカルリソースに書き込む場合、それらのリソースを適切にシャットダウンしない限り、正しくない状態で放置する場合があります。コンポーネントは、使用するリソースをクリーンアップするまで、[プロセス間通信](interprocess-communication.md)を使用して、nucleus コンポーネントに更新を延期するように指示します。
+ nucleus コンポーネントがシャットダウン中、コアデバイスは AWS クラウド とローカルデバイスとの接続を失います。コアデバイスは、シャットダウン中にクライアントデバイスからのメッセージをルーティングしません。
+ コンポーネントとして実行される存続期間の長い Lambda 関数は、動的状態の情報を失って保留中の作業はすべて破棄されます。
## Greengrass nucleus の更新動作
コンポーネントをデプロイする際、AWS IoT Greengrass は、そのコンポーネントの従属関係においてサポートされた最新のバージョンをインストールします。このため、新しいデバイスをモノグループに追加したり、これらのデバイスを対象とするデプロイを更新すると、AWS が提供するパブリックコンポーネントの新しいパッチバージョンが自動的にコアデバイスにデプロイされる場合があります。nucleus の更新など、一部の自動更新により、デバイスに予期せぬ再起動が発生することがあります。
[Greengrass nucleus コンポーネント](greengrass-nucleus-component.md)のバージョンが変更されるとき、AWS IoT Greengrass Core ソフトウェア (デバイスの nucleus と他のすべてのコンポーネントを含む) が再起動して変更を適用します。nucleus コンポーネントが更新される際の[コアデバイスへの影響](#ota-update-considerations)によって、新しい nucleus パッチバージョンがデバイスにデプロイされるタイミングを制御することをお勧めします。それを実行するには、Greengrass nucleus コンポーネントを直接デプロイに含める必要があります。コンポーネントを直接含めるということは、そのコンポーネントの特定バージョンをデプロイ設定に含め、コンポーネントの従属関係に依存してそのコンポーネントをデバイスにデプロイしないことを意味します。コンポーネントレシピで従属関係を定義する方法の詳細については、「[レシピの形式](component-recipe-reference.md#recipe-format)」を参照してください。
次の表を参照して、アクションとデプロイ設定に基づいて Greengrass nucleus コンポーネントの更新動作について把握します。
| アクション | デプロイ設定 | nucleus の更新動作 |
| --- | --- | --- |
| デプロイを改訂せずに、既存のデプロイがターゲットするモノグループに新しいデバイスを追加します。 | デプロイは Greengrass nucleus を直接含めていない。デプロイは、AWS が提供するコンポーネントを少なくとも 1 つ直接含み、あるいは AWS が提供するコンポーネントに依存するカスタムコンポーネント、または Greengrass nucleus のカスタムコンポーネントが含まれます。 | 新しいデバイスには、すべてのコンポーネントに関する依存関係の要件を満たす nucleus の最新パッチバージョンをインストールします。既存のデバイスには、nucleus のインストールされたバージョンを更新しません。 |
| デプロイを改訂せずに、既存のデプロイがターゲットするモノグループに新しいデバイスを追加します。 | デプロイは、Greengrass nucleus の特定バージョンが直接含まれています。 | 新しいデバイスには、指定された nucleus バージョンをインストールします。既存のデバイスには、nucleus のインストールされたバージョンを更新しません。 |
| 新しいデプロイを作成、あるいは既存のデプロイを修正します。 | デプロイは Greengrass nucleus を直接含めていない。デプロイは、AWS が提供するコンポーネントを少なくとも 1 つ直接含み、あるいは AWS が提供するコンポーネントに依存するカスタムコンポーネント、または Greengrass nucleus のカスタムコンポーネントが含まれます。 | すべてのターゲットデバイスには、ターゲットのモノグループに追加する新しいデバイスをすべて含め、すべてのコンポーネントにおける依存関係の要件を満たす nucleus の最新パッチバージョンをインストールします。 |
| 新しいデプロイを作成、あるいは既存のデプロイを修正します。 | デプロイは、Greengrass nucleus の特定バージョンが直接含まれています。 | すべてのターゲットデバイスには、ターゲットのモノグループに追加する新しいデバイスをすべて含め、指定された nucleus バージョンをインストールします。 |
## OTA 更新の実行
OTA 更新を実行するには、[nucleus コンポーネント](greengrass-nucleus-component.md)とインストールするバージョンを含む[デプロイを作成](create-deployments.md)します。
# AWS IoT Greengrass Core ソフトウェアをアンインストールする
AWS IoT Greengrass Core ソフトウェアをアンインストールして、Greengrass コアデバイスとして使用しないデバイスからソフトウェアを削除できます。これらの手順を使用して、失敗したインストールをクリーンアップすることもできます。
**AWS IoT Greengrass Core ソフトウェアをアンインストールするには**
1. ソフトウェアをシステムサービスとして実行する場合は、サービスを停止、無効化、および削除する必要があります。オペレーティングシステムに適した次のコマンドを実行します。
------
#### [ Linux ]
1. サービスを停止します。
```
sudo systemctl stop greengrass.service
```
1. サービスを無効にします。
```
sudo systemctl disable greengrass.service
```
1. サービスを削除します。
```
sudo rm /etc/systemd/system/greengrass.service
```
1. サービスが削除されていることを確認します。
```
sudo systemctl daemon-reload && sudo systemctl reset-failed
```
------
#### [ Windows (Command Prompt) ]
**注記**
これらのコマンドを実行するには、管理者としてコマンドプロンプトを実行する必要があります。
1. サービスを停止します。
```
sc stop "greengrass"
```
1. サービスを無効にします。
```
sc config "greengrass" start=disabled
```
1. サービスを削除します。
```
sc delete "greengrass"
```
1. デバイスを再起動します。
------
#### [ Windows (PowerShell) ]
**注記**
これらのコマンドを実行するには、管理者として PowerShell を実行している必要があります。
1. サービスを停止します。
```
Stop-Service -Name "greengrass"
```
1. サービスを無効にします。
```
Set-Service -Name "greengrass" -Status stopped -StartupType disabled
```
1. サービスを削除します。
+ PowerShell 6.0 以降の場合:
```
Remove-Service -Name "greengrass" -Confirm:$false -Verbose
```
+ 6.0 より前のバージョンの PowerShell の場合:
```
Get-Item HKLM:\SYSTEM\CurrentControlSet\Services\greengrass | Remove-Item -Force -Verbose
```
1. デバイスを再起動します。
------
1. デバイスからルートフォルダを削除します。`/greengrass/v2` または *C:\$1greengrass\$1v2* をルートフォルダへのパスに置き換えてください。
------
#### [ Linux ]
```
sudo rm -rf /greengrass/v2
```
------
#### [ Windows (Command Prompt) ]
```
rmdir /s /q C:\greengrass\v2
```
------
#### [ Windows (PowerShell) ]
```
cmd.exe /c "rmdir /s /q C:\greengrass\v2"
```
------
1. AWS IoT Greengrass サービスからコアデバイスを削除します。この手順により、コアデバイスのステータス情報が AWS クラウド から削除されます。同じ名前のコアデバイスに AWS IoT Greengrass Core ソフトウェアを再インストールする予定の場合は、必ずこの手順を完了させてください。
+ AWS IoT Greengrass コンソールからコアデバイスを削除するには、次の手順を実行します。
1. [AWS IoT Greengrass コンソール](https://console.aws.amazon.com/greengrass)に移動します。
1. **[Core devices]** (コアデバイス) を選択します。
1. 削除するコアデバイスを選択します。
1. **[削除]** を選択します。
1. 確認モーダルで、**[[Delete]** (削除) を選択します。
+ AWS Command Line Interface でコアデバイスを削除するには、[DeleteCoreDevice](https://docs.aws.amazon.com/greengrass/v2/APIReference/API_DeleteCoreDevice.html) 操作を使用します。以下のコマンドを実行して、*MyGreengrassCore* をコアデバイスの名前に置き換えます。
```
aws greengrassv2 delete-core-device --core-device-thing-name MyGreengrassCore
```