翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。 # チュートリアル: AWS IoT Greengrass V2 の開始方法 この基礎的なチュートリアルでは、AWS IoT Greengrass V2 の基本的な機能について知ることができます。このチュートリアルでは、以下の作業を行います。 1. Raspberry Pi などの Linux デバイスや Windows デバイスに AWS IoT Greengrass Core ソフトウェアをインストールして設定します。このデバイスは Greengrass コアデバイスです。 1. Greengrass コアデバイス上で、Hello World コンポーネントを開発します。コンポーネントは、Greengrass コアデバイス上で動作するソフトウェアです。 1. このコンポーネントを AWS クラウド にある AWS IoT Greengrass V2 にアップロードします。 1. このコンポーネントを、AWS クラウド から Greengrass コアデバイスにデプロイします。 **注記** このチュートリアルでは、開発環境をセットアップする方法と、AWS IoT Greengrass の機能について説明します。実稼働デバイスをセットアップおよび設定する方法の詳細については、以下を参照してください。 [AWS IoT Greengrass コアデバイスのセットアップ](setting-up.md) [AWS IoT Greengrass Core ソフトウェアをインストールします。](install-greengrass-core-v2.md) このチュートリアルは 20～30 分を要します。 **Topics** + [前提条件](getting-started-prerequisites.md) + [ステップ 1: AWS アカウントを設定する](getting-started-set-up-aws-account.md) + [ステップ 2: 環境の構築](getting-started-set-up-environment.md) + [ステップ 3: AWS IoT Greengrass Core ソフトウェアをインストールする](install-greengrass-v2.md) + [ステップ 4: デバイス上でコンポーネントを開発およびテストする](create-first-component.md) + [ステップ 5: AWS IoT Greengrass サービスでコンポーネントを作成する](upload-first-component.md) + [ステップ 6: コンポーネントをデプロイする](deploy-first-component.md) + [次のステップ](getting-started-next-steps.md) # 前提条件 この入門チュートリアルを完了するには、以下が必要です。 + AWS アカウント。アカウントをお持ちでない場合は、「[ステップ 1: AWS アカウントを設定する](getting-started-set-up-aws-account.md)」を参照してください。 + AWS IoT Greengrass V2 をサポートする [AWS リージョン](https://en.wikipedia.org/wiki/Amazon_Web_Services#Availability_and_topology) を使用します。サポートされているリージョンのリストについては、「*AWS 全般のリファレンス*」の「[AWS IoT Greengrass V2 の エンドポイントとクォータ](https://docs.aws.amazon.com/general/latest/gr/greengrassv2.html)」を参照してください。 + 管理者権限を持つ AWS Identity and Access Management (IAM) ユーザー。 + Greengrass コアデバイスとしてセットアップするデバイス。[Raspberry Pi OS](https://www.raspberrypi.org/downloads/) を搭載した Raspberry Pi (以前の Raspbian) または Windows 10 デバイスなど。このデバイスに対する管理者権限を持っているか、`sudo` を通してなどの方法で、管理者権限を取得できる必要があります。このデバイスにはインターネット接続が必要です。 また、AWS IoT Greengrass Core ソフトウェアをインストールして実行するための要件を満たしている、別のデバイスを使用することもできます。 開発用コンピュータがこれらの要件を満たしている場合は、このチュートリアルで Greengrass コアデバイスとしてセットアップできます。 + デバイス上のすべてのユーザーに対して [Python](https://www.python.org/downloads/) 3.5 以降がインストールされており、`PATH` 環境変数に追加されていること。Windows の場合は、すべてのユーザーに対して Python Launcher for Windows ランチャーがインストールされている必要があります。 **重要** Windows では、デフォルトでは Python がすべてのユーザーにインストールされません。Python をインストールするときには、インストールをカスタマイズして、AWS IoT Greengrass Core ソフトウェアが Python スクリプトを実行するように設定する必要があります。たとえば、グラフィカル Python インストーラを使用する場合には、次の操作を行います。 **Install launcher for all users (recommended)** (すべてのユーザーにランチャーをインストールする (推奨)) を選択します。 **Customize installation** を選択します。 を選択します。。**Next** を選択します。。**Install for all users** を選択します。。**Add Python to environment variables** **[インストール]** を選択します。 詳細については、「Python 3 ドキュメント」の「[Windows で Python を使用する](https://docs.python.org/3/using/windows.html)」を参照してください。 + 開発コンピュータおよびデバイスに AWS Command Line Interface (AWS CLI) がインストールされており、認証情報が設定されていること。開発用コンピュータとデバイスで、同じ AWS リージョン リージョンを使って AWS CLI を設定しているか確認してください。AWS IoT Greengrass V2 を AWS CLI で使用するには、以下のいずれかのバージョン以降である必要があります。 + 最小 AWS CLI V1 バージョン: v1.18.197 + 最小 AWS CLI V2 バージョン: v2.1.11 **ヒント** 現在の AWS CLI のバージョンを確認するには、次のコマンドを実行します。 ``` aws --version ``` 詳細については、「AWS Command Line Interface ユーザーガイド」の「[AWS CLI のインストール、更新、アンインストール](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html)」と「[AWS CLI の設定](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html)」を参照してください。 **注記** 32 ビットのオペレーティングシステムを備えた Raspberry Pi などの、32 ビット ARM デバイスを使用する場合は、AWS CLI V1 をインストールします。AWS CLIV2 は 32 ビット ARM デバイスでは利用できません。詳細については、「[AWS CLI バージョン 1 のインストール、更新、およびアンインストール](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv1.html)」を参照してください。 # ステップ 1: AWS アカウントを設定する ## にサインアップする 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)の実行にはルートユーザーのみを使用するようにしてください。 AWS サインアッププロセスが完了すると、 から確認メールが送信されます。[https://aws.amazon.com/](https://aws.amazon.com/) の **[マイアカウント]** をクリックして、いつでもアカウントの現在のアクティビティを表示し、アカウントを管理することができます。 ## 管理アクセスを持つユーザーを作成する にサインアップしたら AWS アカウント、日常的なタスクにルートユーザーを使用しないように AWS アカウントのルートユーザー、 のセキュリティを確保し AWS IAM アイデンティティセンター、 を有効にして管理ユーザーを作成します。 **を保護する AWS アカウントのルートユーザー** 1. **ルートユーザー**を選択し、 AWS アカウント E メールアドレスを入力して、アカウント所有者[AWS マネジメントコンソール](https://console.aws.amazon.com/)として にサインインします。次のページでパスワードを入力します。 ルートユーザーを使用してサインインする方法については、*AWS サインイン ユーザーガイド*の[ルートユーザーとしてサインインする](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial)を参照してください。 1. ルートユーザーの多要素認証 (MFA) を有効にします。 手順については、*IAM* [ユーザーガイドの AWS アカウント 「ルートユーザー (コンソール) の仮想 MFA デバイス](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html)を有効にする」を参照してください。 **管理アクセスを持つユーザーを作成する** 1. IAM アイデンティティセンターを有効にします。 手順については、「AWS IAM アイデンティティセンター ユーザーガイド」の「[AWS IAM アイデンティティセンターの有効化](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html)」を参照してください。 1. IAM アイデンティティセンターで、ユーザーに管理アクセスを付与します。 を ID ソース IAM アイデンティティセンターディレクトリ として使用する方法のチュートリアルについては、*AWS IAM アイデンティティセンター 「 ユーザーガイド*」の[「デフォルトを使用してユーザーアクセスを設定する IAM アイデンティティセンターディレクトリ](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html)」を参照してください。 **管理アクセス権を持つユーザーとしてサインインする** + IAM アイデンティティセンターのユーザーとしてサインインするには、IAM アイデンティティセンターのユーザーの作成時に E メールアドレスに送信されたサインイン URL を使用します。 IAM Identity Center ユーザーを使用してサインインする方法については、*AWS サインイン 「 ユーザーガイド*[」の AWS 「 アクセスポータルにサインイン](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html)する」を参照してください。 **追加のユーザーにアクセス権を割り当てる** 1. IAM アイデンティティセンターで、最小特権のアクセス許可を適用するというベストプラクティスに従ったアクセス許可セットを作成します。 手順については、「AWS IAM アイデンティティセンター ユーザーガイド」の「[権限設定を作成する](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html)」*を参照してください*。 1. グループにユーザーを割り当て、そのグループにシングルサインオンアクセス権を割り当てます。 手順については、「*AWS IAM アイデンティティセンター ユーザーガイド*」の「[Add groups](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html)」を参照してください。 # ステップ 2: 環境の構築 **注記** これらのステップは nucleus lite には適用されません。 このセクションのステップに従って、 AWS IoT Greengrass コアデバイスとして使用する Linux または Windows デバイスをセットアップします。 ## Linux デバイス (Raspberry Pi) をセットアップする これらのステップでは、Raspberry Pi OS を備えた Raspberry Pi を使用していることを前提としています。別のデバイスまたはオペレーティングシステムを使用する場合は、お使いのデバイスに該当するドキュメントを参照してください。 **用に Raspberry Pi をセットアップするには AWS IoT Greengrass V2** 1. Raspberry Pi で SSH を有効にして、リモート接続します。詳細については、「*Raspberry Pi ドキュメント*」の「[SSH (Secure shell)](https://www.raspberrypi.com/documentation/computers/remote-access.html#ssh)」を参照してください。 1. Raspberry Pi の IP アドレスを検索して SSH で接続します。これを行うには、Raspberry Pi 上で次のコマンドを実行します。 ``` hostname -I ``` 1. SSH で Raspberry Pi に接続します。 開発用コンピュータに次のコマンドを実行します。*username* をサインインするユーザーの名前に置き換えて、*pi-ip-address* を前のステップで検索した IP アドレスに置き換えます。 ``` ssh username@pi-ip-address ``` **重要** 開発コンピュータで Microsoft Windows の以前のバージョンを使用している場合、`ssh` コマンドがないか、`ssh` があっても Raspberry Pi に接続できない可能性があります。Raspberry Pi に接続するには、無料のオープンソース SSH クライアントである [PuTTY](https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html) をインストールすることができます。「[PuTTY ドキュメント](https://tartarus.org/~simon/putty-snapshots/htmldoc/Chapter2.html#gs)」を参照して、Raspberry Pi に接続します。 1. AWS IoT Greengrass Core ソフトウェアが実行する必要がある Java ランタイムをインストールします。Raspberry Pi で、次のコマンドを使用して Java 11 をインストールします。 ``` sudo apt install default-jdk ``` インストールが完了したら、次のコマンドを実行して Java が Raspberry Pi で実行されていることを確認します。 ``` java -version ``` このコマンドは、デバイス上で実行されている Java のバージョンを出力します。出力は、次の例のようになります。 ``` 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) ``` **ヒント: Raspberry Pi にカーネルパラメータを設定する** デバイスが Raspberry Pi の場合、次の手順を実行して Linux カーネルパラメータを表示と更新できます。 `/boot/cmdline.txt` ファイルを開きます。このファイルでは、Raspberry Pi の起動時に適用する Linux カーネルパラメータを指定します。 例えば、Linux ベースのシステムでは、次のコマンドを実行し、GNU nano を使用してファイルを開きます。 ``` sudo nano /boot/cmdline.txt ``` `/boot/cmdline.txt` ファイルに次のカーネルパラメータが含まれていることを確認します。`systemd.unified_cgroup_hierarchy=0` パラメータは、cgroups v2 ではなく、cgroups v1 を使用することを指定します。 ``` cgroup_enable=memory cgroup_memory=1 systemd.unified_cgroup_hierarchy=0 ``` `/boot/cmdline.txt` ファイルにこれらのパラメータが含まれていない場合、あるいは異なる値を持つこれらのパラメータが含まれている場合、これらのパラメータと値を含むようにファイルを更新してください。 `/boot/cmdline.txt` ファイルを更新した場合、Raspberry Pi を再起動して変更を適用します。 ``` sudo reboot ``` ## 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 デバイスをセットアップする **の 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 アカウントに保存されます。 # ステップ 3: AWS IoT Greengrass Core ソフトウェアをインストールする **ヒント** [AWS IoT Greengrass AI エージェントコンテキストパック](https://github.com/aws-greengrass/greengrass-agent-context-pack)を試して、 AWS IoT Greengrass をすばやくセットアップして試すことをお勧めします。エージェントコンテキストパックを使用すると、AI エージェントは Greengrass Nucleus と Nucleus Lite のセットアップ、コンポーネントのデプロイ、一般的な問題のトラブルシューティングを行うことができます。 このセクションの手順に従って、ローカル開発に使用できる AWS IoT Greengrass コアデバイスとして Raspberry Pi を設定します。このセクションでは、以下を実行するインストーラをダウンロードして実行し、デバイスの AWS IoT Greengrass Core ソフトウェアを設定します。 + Greengrass nucleus コンポーネントをインストールします。nucleus は必須コンポーネントであり、デバイスで AWS IoT Greengrass Core ソフトウェアを実行するための最小要件です。詳細については、「[Greengrass nucleus コンポーネント](greengrass-nucleus-component.md)」を参照してください。 + デバイスを AWS IoT モノとして登録し、デバイスが接続できるようにするデジタル証明書をダウンロードします AWS。詳細については、「[AWS IoT Greengrassのデバイス認証と認可](device-auth.md)」を参照してください。 + モノのグループまたはフリートである AWS IoT モノの AWS IoT グループにデバイスのモノを追加します。モノグループを使用すると、Greengrass コアデバイスのフリートを管理できます。ソフトウェアコンポーネントをデバイスにデプロイするとき、個々のデバイスまたはデバイスのグループのどちらにデプロイするのかを選択することができます。詳細については、「*AWS IoT Core デベロッパーガイド*」の「[Managing devices with AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/iot-thing-management.html)」を参照してください。 + Greengrass コアデバイスが AWS サービスとやり取りを許可する IAM ロールを作成します。デフォルトでは、このロールにより、デバイスは Amazon CloudWatch Logs とやり取り AWS IoT してログを送信できます。詳細については、「[コアデバイスが AWS サービスとやり取りできるように認可する](device-service-role.md)」を参照してください。 + AWS IoT Greengrass コマンドラインインターフェイス (`greengrass-cli`) をインストールします。これを使用して、コアデバイスで開発するカスタムコンポーネントをテストできます。詳細については、「[Greengrass コマンドラインインターフェイス](gg-cli.md)」を参照してください。 # AWS IoT Greengrass Core ソフトウェアをインストールする (コンソール) 1. [AWS IoT Greengrass コンソール](https://console.aws.amazon.com/greengrass)にサインインします。 1. **[Greengrass の使用を開始する]** で、**[コアデバイスをセットアップ]** を選択します。 1. **[Step 1: Register a Greengrass core device]** (ステップ 1: Greengrass コアデバイスを登録する) にある **[Core device name]** (コアデバイス名) に、Greengrass コアデバイスの AWS IoT モノの名前を入力します。モノが存在しない場合、インストーラによって作成されます。 1. **[Step 2: Add to a thing group to apply a continuous deployment]** (ステップ 2: モノグループに追加して継続的デプロイを適用する)、に対して **[Thing group]** (モノのグループ) で、AWS IoT コアデバイスを追加するモノグループ。 + **[Enter a new group name]** (新しいグループ名を入力) を選択した場合、**[Thing group name]** (モノグループ名) には作成する新しいグループの名前を入力します。インストーラによって新しいグループが作成されます。 + **[Select an existing group]** (既存のグループを選択) を選択した場合、**[Thing group name]** (モノグループ名)には使用する既存のグループを選択します。 + **[No group]** (グループなし) を選択した場合、インストーラはコアデバイスをモノグループに追加しません。 1. **[Step 3: Install the Greengrass Core software]** (ステップ 3: Greengrass Core ソフトウェアをインストールする) で、以下のステップを実行します。 ------ #### [ Nucleus classic ] 1. コアデバイスのソフトウェアランタイムとして **Nucleus classic** を選択します。 1. コアデバイスのオペレーティングシステムを選択します。**Linux** または **Windows** のいずれかです。 1. デバイスに AWS 認証情報を提供して、インストーラがコアデバイスの AWS IoT と IAM リソースをプロビジョニングできるようにします。セキュリティを強化するには、プロビジョニングに必要な最小限の許可のみを与える 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)」を参照してください。** 1. **[Run the installer]** (インストーラの実行) で、以下のステップを実行します。 1. **[Download the installer]** (インストーラをダウンロードする) で、**[Copy]** (コピー) を選択して、コアデバイス上でコピーしたコマンドを実行します。このコマンドは、AWS IoT Greengrass Core ソフトウェアの最新バージョンをダウンロードし、デバイスで解凍します。 1. **[Run installer]** (インストーラを実行する) で、**[Copy]** (コピー) を選択して、コアデバイス上でコピーしたコマンドを実行します。このコマンドでは、AWS IoT Greengrass Core ソフトウェアインストーラを実行し、コアデバイスの AWS リソースを設定するために、前のステップで指定した AWS IoT モノとモノグループ名を使用します。 また、このコマンドは次を行います。 + AWS IoT Greengrass Core ソフトウェアを、ブート時に実行されるシステムサービスとして設定します。Linux デバイスでは、これは [Systemd](https://en.wikipedia.org/wiki/Systemd) init システムが必要です。 **重要** Windows コアデバイスでは、AWS IoT Greengrass Core ソフトウェアをシステムサービスとして設定する必要があります + [AWS IoT Greengrass CLI コンポーネント](gg-cli.md)をデプロイします。このコンポーネントは、コアデバイスでカスタム Greengrass コンポーネントを開発できるようにするためのコマンドラインツールです。 + コアデバイスでソフトウェアコンポーネントを実行するために `ggc_user` システムユーザーを使用するように指定します。Linux デバイスでは、このコマンドも `ggc_group` システムグループを使用するように指定し、さらにインストーラによってシステムユーザーとグループが、ユーザーに代わって作成されます。 このコマンドを実行すると、インストーラが成功したことを示す次のメッセージが表示されます。 ``` Successfully configured Nucleus with provisioned resource details! Configured Nucleus to deploy aws.greengrass.Cli component Successfully set up Nucleus as a system service ``` **注記** Linux デバイスがあるものの、[systemd](https://en.wikipedia.org/wiki/Systemd) がない場合には、インストーラはソフトウェアをシステムサービスとして設定せず、nucleus をシステムサービスとして設定できたことを示す成功メッセージは表示されません。 ------ #### [ Nucleus lite ] 1. コアデバイスのソフトウェアランタイムとして **Nucleus lite** を選択します。 1. デバイスのセットアップ方法を選択して、デバイスを Greengrass コアデバイスにプロビジョニングします。 **オプション 1: パッケージ (約 1 MB) をダウンロードしてデバイスをセットアップする** 1. Greengrass の AWS IoT モノとロールを作成します。 1. デバイスが AWS IoT に接続するために必要な AWS IoT リソースを含む zip ファイルをダウンロードします。 + AWS IoT の認証機関を使用して生成された証明書とプライベートキー。 + デバイスの Greengrass インストールを開始するためのスキーマファイル。 1. Raspberry Pi に最新の Greengrass Nucleus lite ランタイムをインストールするパッケージをダウンロードします。 1. デバイスを AWS IoT Greengrass Core デバイスとしてプロビジョニングし、AWS IoT に接続します。 1. a. USB サムドライブ、SCP/FTP、または SD カードを使用して、Greengrass パッケージと接続キットをデバイスに転送します。 1. b. デバイスの /GreengrassInstaller ディレクトリで greengrass-package.zip ファイルを解凍します。 1. c。接続キットの zip ファイルをデバイスの /directory で解凍します。 1. d。デバイスで提供されたコマンドを実行して AWS IoT Greengrass をインストールします 1. 次に、**[コアデバイスを表示]** を選択します。 **オプション 2: 事前設定されたディスク全体のサンプルイメージ (約 100 MB) をダウンロードしてデバイスをセットアップする** 1. Greengrass の AWS IoT モノとロールを作成します。 1. デバイスが AWS IoT に接続するために必要な AWS IoT リソースを含む zip ファイルをダウンロードします。 + AWS IoT の認証機関を使用して生成された証明書とプライベートキー。 + デバイスの Greengrass インストールを開始するためのスキーマファイル。 1. Greengrass とオペレーティングシステムを含む事前設定されたディスク全体のサンプルイメージをダウンロードします。 1. 接続キットを転送し、イメージをデバイスにフラッシュするには、イメージと共にダウンロードされた readme ファイルに従います。 1. Greengrass のインストールを開始するには、デバイスをオンにして、フラッシュされたイメージから起動します 1. 次に、**[コアデバイスを表示]** を選択します。 **オプション 3: 独自のカスタムビルドでデバイスをセットアップする** 1. Greengrass の AWS IoT モノとロールを作成します。 1. デバイスが AWS IoT に接続するために必要な AWS IoT リソースを含む zip ファイルをダウンロードします。 + AWS IoT の認証機関を使用して生成された証明書とプライベートキー。 + デバイスの Greengrass インストールを開始するためのスキーマファイル。 1. ソースコードから Yocto を使用して独自のイメージをカスタマイズして構築し、接続キットを使用して nucleus lite をインストールするには、GitHub の指示に従います。 1. 次に、**[コアデバイスを表示]** を選択します。 ------ # AWS IoT Greengrass Core ソフトウェアをインストールする (CLI) **注記** これらのステップは nucleus lite には適用されません。 **AWS IoT Greengrass Core ソフトウェアをインストールして設定するには** 1. Greengrass コアデバイスで、次のコマンドを実行してホームディレクトリに切り替えます。 ------ #### [ Linux or Unix ] ``` cd ~ ``` ------ #### [ Windows Command Prompt (CMD) ] ``` cd %USERPROFILE% ``` ------ #### [ PowerShell ] ``` cd ~ ``` ------ 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. 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 ソフトウェアのインストーラを起動します。このコマンドは次のことを行います。 + コアデバイスの動作に必要な AWS リソースを作成します。 + AWS IoT Greengrass Core ソフトウェアを、ブート時に実行されるシステムサービスとして設定します。Linux デバイスでは、これは [Systemd](https://en.wikipedia.org/wiki/Systemd) init システムが必要です。 **重要** Windows コアデバイスでは、AWS IoT Greengrass Core ソフトウェアをシステムサービスとして設定する必要があります + [AWS IoT Greengrass CLI コンポーネント](gg-cli.md)をデプロイします。このコンポーネントは、コアデバイスでカスタム Greengrass コンポーネントを開発できるようにするためのコマンドラインツールです。 + コアデバイスでソフトウェアコンポーネントを実行するために `ggc_user` システムユーザーを使用するように指定します。Linux デバイスでは、このコマンドも `ggc_group` システムグループを使用するように指定し、さらにインストーラによってシステムユーザーとグループが、ユーザーに代わって作成されます。 コマンドの引数値を次のように置き換えます。 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 Greengrass と通信できるようにする AWS IoT ポリシーの名前。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 \ --deploy-dev-tools 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 ^ --deploy-dev-tools 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 ` --deploy-dev-tools true ``` ------ **注記** メモリが制限されているデバイスで AWS IoT Greengrass を実行する場合、AWS IoT Greengrass Core ソフトウェアが使用するメモリ量を制御できます。メモリ割り当てを制御するには、nucleus コンポーネントの `jvmOptions` 設定パラメータで JVM ヒープのサイズオプションを設定できます。詳細については、「[JVM オプションでメモリ割り当てを制御する](configure-greengrass-core-v2.md#jvm-tuning)」を参照してください。 このコマンドを実行すると、インストーラが成功したことを示す次のメッセージが表示されます。 ``` Successfully configured Nucleus with provisioned resource details! Configured Nucleus to deploy aws.greengrass.Cli component Successfully set up Nucleus as a system service ``` **注記** Linux デバイスがあるものの、[systemd](https://en.wikipedia.org/wiki/Systemd) がない場合には、インストーラはソフトウェアをシステムサービスとして設定せず、nucleus をシステムサービスとして設定できたことを示す成功メッセージは表示されません。 # (オプション) Greengrass ソフトウェアを実行する (Linux) **注記** これらのステップは nucleus lite には適用されません。 ソフトウェアをシステムサービスとしてインストールした場合、インストーラがソフトウェアを実行します。実行されない場合は、ソフトウェアを手動で実行する必要があります。インストーラがソフトウェアをシステムサービスとして設定しているかどうかを確認するには、インストーラの出力に次の行がないか探します。 ``` Successfully set up Nucleus as a system service ``` このメッセージが表示されていない場合は、次の手順に従ってソフトウェアを実行します。 1. 次のコマンドを使用してソフトウェアを起動します。 ``` sudo /greengrass/v2/alts/current/distro/bin/loader ``` 正常に起動すると、ソフトウェアは次のメッセージを出力します。 ``` Launched Nucleus successfully. ``` 1. AWS IoT Greengrass Core ソフトウェアを実行し続けるには、現在のコマンドシェルを開いたままにする必要があります。SSH を使用してコアデバイスに接続する場合は、開発コンピュータで次のコマンドを実行して 2 番目の SSH セッションを開き、コアデバイス上で別のコマンドを実行するために使用することができます。*username* をサインインするユーザーの名前に置き換えて、*pi-ip-address* をデバイスの IP アドレスに置き換えます。 ``` ssh username@pi-ip-address ``` Greengrass システムサービスとやり取りする方法の詳細については、「[Greengrass nucleus をシステムサービスとして設定する](configure-greengrass-core-v2.md#configure-system-service)」を参照してください。 # デバイス上の Greengrass CLI のインストールを確認する **注記** これらのステップは nucleus lite には適用されません。 Greengrass CLI のデプロイには、最大で 1 分かかります。次のコマンドを実行すると、デプロイのステータスを確認できます。*MyGreengrassCore* をコアデバイスの名前に置き換えます。 ``` aws greengrassv2 list-effective-deployments --core-device-thing-name MyGreengrassCore ``` `coreDeviceExecutionStatus` はコアデバイスへのデプロイのステータスを示しています。ステータスが `SUCCEEDED` のときに次のコマンドを実行して、Greengrass CLI がインストールされ、実行されていることを確認します。`/greengrass/v2` をルートフォルダへのパスに置き換えます。 ------ #### [ Linux or Unix ] ``` /greengrass/v2/bin/greengrass-cli help ``` ------ #### [ Windows Command Prompt (CMD) ] ``` C:\greengrass\v2\bin\greengrass-cli help ``` ------ #### [ PowerShell ] ``` C:\greengrass\v2\bin\greengrass-cli help ``` ------ このコマンドは Greengrass CLI に関するヘルプ情報を出力します。`greengrass-cli` が見つからない場合は、デプロイで Greengrass CLI のインストールに失敗した可能性があります。詳細については、「[トラブルシューティング AWS IoT Greengrass V2](troubleshooting.md)」を参照してください。 次のコマンドを実行して、CLI AWS IoT Greengrass をデバイスに手動でデプロイすることもできます。 + *region* AWS リージョン を、使用する に置き換えます。 AWS CLI デバイスの の設定に使用した AWS リージョン のと同じ を使用してください。 + *account-id* を AWS アカウント ID に置き換えます。 + *MyGreengrassCore* をコアデバイスの名前に置き換えます。 ------ #### [ Linux, macOS, or Unix ] ``` aws greengrassv2 create-deployment \ --target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" \ --components '{ "aws.greengrass.Cli": { "componentVersion": "2.16.1" } }' ``` ------ #### [ Windows Command Prompt (CMD) ] ``` aws greengrassv2 create-deployment ^ --target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" ^ --components "{\"aws.greengrass.Cli\":{\"componentVersion\":\"2.16.1\"}}" ``` ------ #### [ PowerShell ] ``` aws greengrassv2 create-deployment ` --target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" ` --components '{\"aws.greengrass.Cli\":{\"componentVersion\":\"2.16.1\"}}' ``` ------ **ヒント** `PATH` 環境変数に `/greengrass/v2/bin` (Linux) または `C:\greengrass\v2\bin` (Windows) を追加すると、絶対パスなしで `greengrass-cli` を実行することができます。 AWS IoT Greengrass Core ソフトウェアとローカル開発ツールは、デバイスで実行されます。次に、デバイスで Hello World AWS IoT Greengrass コンポーネントを開発できます。 # ステップ 4: デバイス上でコンポーネントを開発およびテストする コンポーネントは、 AWS IoT Greengrass コアデバイスで実行されるソフトウェアモジュールです。コンポーネントを使用すると、複雑なアプリケーションを個別のビルディングブロックとして作成し管理することができ、Greengrass コアデバイス間で再利用することができます。すべてのコンポーネントは、*レシピ*と*アーティファクト*で設定されます。 + **recipe** すべてのコンポーネントには、メタデータを定義する recipe ファイルが含まれています。recipe では、コンポーネントの設定パラメータ、コンポーネントの依存関係、ライフサイクル、プラットフォームの互換性も指定します。コンポーネントのライフサイクルは、コンポーネントのインストール、実行、およびシャットダウンを行うコマンドを定義します。詳細については、「[AWS IoT Greengrass コンポーネントレシピリファレンス](component-recipe-reference.md)」を参照してください。 recipe は [JSON](https://en.wikipedia.org/wiki/JSON) または [YAML](https://en.wikipedia.org/wiki/YAML) 形式で定義できます。 + **アーティファクト** コンポーネントは、コンポーネントバイナリであるアーティファクトを必要な数だけ持つことができます。アーティファクトには、スクリプト、コンパイルされたコード、静的リソース、およびコンポーネントが消費するその他のファイルが含まれます。コンポーネントはコンポーネントの依存関係からアーティファクトを消費することもできます。 を使用すると AWS IoT Greengrass、Greengrass CLI を使用して、 AWS クラウドとやり取りすることなく Greengrass コアデバイスでローカルにコンポーネントを開発およびテストできます。ローカルコンポーネントを完了すると、コンポーネントレシピとアーティファクトを使用して、 AWS クラウドの AWS IoT Greengrass サービスでそのコンポーネントを作成し、すべての Greengrass コアデバイスにデプロイできます。コンポーネントの詳細については、「[AWS IoT Greengrass コンポーネントを開発する](develop-greengrass-components.md)」を参照してください。 このセクションでは、基本的な Hello World コンポーネントをコアデバイス上でローカルに作成して実行する方法を説明します。 **デバイスで Hello World コンポーネントを開発するには** 1. recipe とアーティファクトのサブフォルダを含むコンポーネントのフォルダを作成します。Greengrass コアデバイスで次のコマンドを実行してこれらのフォルダを作成し、コンポーネントフォルダに変更します。*\$1/greengrassv2* または *%USERPROFILE%\$1greengrassv2* をローカル開発に使用するフォルダへのパスに置き換えます。 ------ #### [ Linux or Unix ] ``` mkdir -p ~/greengrassv2/{recipes,artifacts} cd ~/greengrassv2 ``` ------ #### [ Windows Command Prompt (CMD) ] ``` mkdir %USERPROFILE%\greengrassv2\\recipes, %USERPROFILE%\greengrassv2\\artifacts cd %USERPROFILE%\greengrassv2 ``` ------ #### [ PowerShell ] ``` mkdir ~/greengrassv2/recipes, ~/greengrassv2/artifacts cd ~/greengrassv2 ``` ------ 1. テキストエディタを使用して、コンポーネントのメタデータ、パラメータ、依存関係、ライフサイクル、プラットフォーム機能を定義する recipe ファイルを作成します。recipe ファイル名にコンポーネントのバージョンを含めるようにして、どの recipe がどのコンポーネントバージョンを反映しているのかを特定できるようにします。recipe には YAML 形式または JSON 形式を選択できます。 例えば、Linux ベースのシステムでは、次のコマンドを実行し、GNU nano を使用してファイルを作成できます。 ------ #### [ JSON ] ``` nano recipes/com.example.HelloWorld-1.0.0.json ``` ------ #### [ YAML ] ``` nano recipes/com.example.HelloWorld-1.0.0.yaml ``` ------ **注記** AWS IoT Greengrass はコンポーネントにセマンティックバージョンを使用します。セマンティックバージョンは、major.minor.patch といった番号システムに準拠します。例えば、バージョン `1.0.0` は、コンポーネントの最初のメジャーリリースを表しています。詳細については、「[セマンティックバージョンの仕様](https://semver.org/)」を参照してください。 1. ファイルに次の recipe を貼り付けます。 ------ #### [ JSON ] ``` { "RecipeFormatVersion": "2020-01-25", "ComponentName": "com.example.HelloWorld", "ComponentVersion": "1.0.0", "ComponentDescription": "My first AWS IoT Greengrass component.", "ComponentPublisher": "Amazon", "ComponentConfiguration": { "DefaultConfiguration": { "Message": "world" } }, "Manifests": [ { "Platform": { "os": "linux" }, "Lifecycle": { "run": "python3 -u {artifacts:path}/hello_world.py {configuration:/Message}" } }, { "Platform": { "os": "windows" }, "Lifecycle": { "run": "py -3 -u {artifacts:path}/hello_world.py {configuration:/Message}" } } ] } ``` ------ #### [ YAML ] ``` --- RecipeFormatVersion: '2020-01-25' ComponentName: com.example.HelloWorld ComponentVersion: '1.0.0' ComponentDescription: My first AWS IoT Greengrass component. ComponentPublisher: Amazon ComponentConfiguration: DefaultConfiguration: Message: world Manifests: - Platform: os: linux Lifecycle: run: | python3 -u {artifacts:path}/hello_world.py "{configuration:/Message}" - Platform: os: windows Lifecycle: run: | py -3 -u {artifacts:path}/hello_world.py "{configuration:/Message}" ``` ------ この recipe の `ComponentConfiguration` セクションはパラメータである `Message` を定義しており、デフォルトでは `world` になります。`Manifests` セクションでは、プラットフォームのライフサイクル手順とアーティファクトのセットである*マニフェスト*を定義します。たとえば、複数のマニフェストを定義して、さまざまなプラットフォームに対して異なるインストール手順を指定することができます。マニフェストでは、`Lifecycle` セクションは、Greengrass コアデバイスに `Message` パラメータ値を引数として Hello World スクリプトを実行するように指示します。 1. 次のコマンドを実行して、コンポーネントアーティファクト用のフォルダを作成します。 ------ #### [ Linux or Unix ] ``` mkdir -p artifacts/com.example.HelloWorld/1.0.0 ``` ------ #### [ Windows Command Prompt (CMD) ] ``` mkdir artifacts\com.example.HelloWorld\1.0.0 ``` ------ #### [ PowerShell ] ``` mkdir artifacts\com.example.HelloWorld\1.0.0 ``` ------ **重要** アーティファクトフォルダのパスには、次のフォーマットを使用する必要があります。recipe で指定したコンポーネント名とバージョンを含めてください。 ``` artifacts/componentName/componentVersion/ ``` 1. テキストエディタを使用して、Hello World コンポーネントの Python スクリプトアーティファクトファイルを作成します。 例えば、Linux ベースのシステムでは、次のコマンドを実行し、GNU nano を使用してファイルを作成できます。 ``` nano artifacts/com.example.HelloWorld/1.0.0/hello_world.py ``` 次の Python スクリプトをコピーしてファイルに貼り付けます。 ``` import sys message = "Hello, %s!" % sys.argv[1] # Print the message to stdout, which Greengrass saves in a log file. print(message) ``` 1. ローカル AWS IoT Greengrass CLI を使用して、Greengrass コアデバイスのコンポーネントを管理します。 次のコマンドを実行して、コンポーネントを AWS IoT Greengrass コアにデプロイします。`/greengrass/v2` または *C:\$1greengrass\$1v2* を AWS IoT Greengrass V2 ルートフォルダに置き換え、*\$1/greengrassv2* または *%USERPROFILE%\$1greengrassv2* をコンポーネント開発フォルダに置き換えます。 ------ #### [ Linux or Unix ] ``` sudo /greengrass/v2/bin/greengrass-cli deployment create \ --recipeDir ~/greengrassv2/recipes \ --artifactDir ~/greengrassv2/artifacts \ --merge "com.example.HelloWorld=1.0.0" ``` ------ #### [ Windows Command Prompt (CMD) ] ``` C:\greengrass\v2\bin\greengrass-cli deployment create ^ --recipeDir %USERPROFILE%\greengrassv2\recipes ^ --artifactDir %USERPROFILE%\greengrassv2\artifacts ^ --merge "com.example.HelloWorld=1.0.0" ``` ------ #### [ PowerShell ] ``` C:\greengrass\v2\bin\greengrass-cli deployment create ` --recipeDir ~/greengrassv2/recipes ` --artifactDir ~/greengrassv2/artifacts ` --merge "com.example.HelloWorld=1.0.0" ``` ------ このコマンドは、`recipes` では recipe 、`artifacts` では Python スクリプトを使用するコンポーネントを追加します。`--merge` オプションは指定したコンポーネントとバージョンを追加または更新します。 1. AWS IoT Greengrass Core ソフトウェアは、コンポーネントプロセスからの stdout を `logs`フォルダのログファイルに保存します。Hello World コンポーネントが実行され、メッセージが表示されることを確認するには、次のコマンドを実行します。 ------ #### [ Linux or Unix ] ``` sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log ``` ------ #### [ Windows Command Prompt (CMD) ] ``` type C:\greengrass\v2\logs\com.example.HelloWorld.log ``` `type` コマンドは、ファイルのコンテンツを端末に書き込みます。このコマンドを複数回実行して、ファイル内の変更を確認してください。 ------ #### [ PowerShell ] ``` gc C:\greengrass\v2\logs\com.example.HelloWorld.log -Tail 10 -Wait ``` ------ 次の例に示すようなメッセージが表示されます。 ``` Hello, world! ``` **注記** ファイルが存在しない場合、ローカルデプロイがまだ完了していない可能性があります。ファイルが 15 秒以内に表示されない場合は、デプロイが失敗している可能性があります。これは、recipe が有効でない場合などに発生します。次のコマンドを実行して、 AWS IoT Greengrass コアログファイルを表示します。このファイルは、Greengrass コアデバイスのデプロイサービスからのログが含まれます。 ``` sudo tail -f /greengrass/v2/logs/greengrass.log ``` ``` type C:\greengrass\v2\logs\greengrass.log ``` `type` コマンドは、ファイルのコンテンツを端末に書き込みます。このコマンドを複数回実行して、ファイル内の変更を確認してください。 ``` gc C:\greengrass\v2\logs\greengrass.log -Tail 10 -Wait ``` 1. ローカルコンポーネントを変更して、コードを繰り返してテストします。テキストエディタ`hello_world.py`で を開き、4 行目に次のコードを追加して、 AWS IoT Greengrass コアがログに記録するメッセージを編集します。 ``` message += " Greetings from your first Greengrass component." ``` `hello_world.py` スクリプトには次の内容が表示されるはずです。 ``` import sys message = "Hello, %s!" % sys.argv[1] message += " Greetings from your first Greengrass component." # Print the message to stdout, which Greengrass saves in a log file. print(message) ``` 1. 次のコマンドを実行して、変更内容でコンポーネントを更新します。 ------ #### [ Linux or Unix ] ``` sudo /greengrass/v2/bin/greengrass-cli deployment create \ --recipeDir ~/greengrassv2/recipes \ --artifactDir ~/greengrassv2/artifacts \ --merge "com.example.HelloWorld=1.0.0" ``` ------ #### [ Windows Command Prompt (CMD) ] ``` C:\greengrass\v2\bin\greengrass-cli deployment create ^ --recipeDir %USERPROFILE%\greengrassv2\recipes ^ --artifactDir %USERPROFILE%\greengrassv2\artifacts ^ --merge "com.example.HelloWorld=1.0.0" ``` ------ #### [ PowerShell ] ``` C:\greengrass\v2\bin\greengrass-cli deployment create ` --recipeDir ~/greengrassv2/recipes ` --artifactDir ~/greengrassv2/artifacts ` --merge "com.example.HelloWorld=1.0.0" ``` ------ このコマンドは、最新の Hello World アーティファクトで `com.example.HelloWorld` コンポーネントを更新します。 1. 次のコマンドを実行して、コンポーネントを再起動します。コンポーネントを再起動すると、コアデバイスは最新の変更を使用します。 ------ #### [ Linux or Unix ] ``` sudo /greengrass/v2/bin/greengrass-cli component restart \ --names "com.example.HelloWorld" ``` ------ #### [ Windows Command Prompt (CMD) ] ``` C:\greengrass\v2\bin\greengrass-cli component restart ^ --names "com.example.HelloWorld" ``` ------ #### [ PowerShell ] ``` C:\greengrass\v2\bin\greengrass-cli component restart ` --names "com.example.HelloWorld" ``` ------ 1. ログをもう一度確認して、Hello World コンポーネントが新しいメッセージを出力することか確認してください。 ------ #### [ Linux or Unix ] ``` sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log ``` ------ #### [ Windows Command Prompt (CMD) ] ``` type C:\greengrass\v2\logs\com.example.HelloWorld.log ``` `type` コマンドは、ファイルのコンテンツを端末に書き込みます。このコマンドを複数回実行して、ファイル内の変更を確認してください。 ------ #### [ PowerShell ] ``` gc C:\greengrass\v2\logs\com.example.HelloWorld.log -Tail 10 -Wait ``` ------ 次の例に示すようなメッセージが表示されます。 ``` Hello, world! Greetings from your first Greengrass component. ``` 1. コンポーネントの設定パラメータを更新して、さまざまな設定をテストできます。コンポーネントをデプロイするときに、*設定の更新*を指定して、コアデバイス上のコンポーネントの設定を変更する方法を定義することができます。デフォルト値にリセットする設定値と、コアデバイスにマージする新しい設定値を指定することができます。詳細については、「[コンポーネント設定の更新](update-component-configurations.md)」を参照してください。 以下の操作を実行します。 1. テキストエディタを使用して、`hello-world-config-update.json` という名前のファイルを作成し、設定の更新を含めます。 例えば、Linux ベースのシステムでは、次のコマンドを実行し、GNU nano を使用してファイルを作成できます。 ``` nano hello-world-config-update.json ``` 1. 次の JSON オブジェクトをファイルにコピーして貼り付けます。この JSON オブジェクトは、`friend` の値を `Message` パラメータにマージして、その値を更新する設定更新を定義しています。この設定更新では、リセットする値は指定されていません。マージの更新によって既存の値が置き換えられるため、`Message` パラメータをリセットする必要はありません。 ``` { "com.example.HelloWorld": { "MERGE": { "Message": "friend" } } } ``` 1. 次のコマンドを実行して、設定の更新を Hello World コンポーネントにデプロイします。 ------ #### [ Linux or Unix ] ``` sudo /greengrass/v2/bin/greengrass-cli deployment create \ --merge "com.example.HelloWorld=1.0.0" \ --update-config hello-world-config-update.json ``` ------ #### [ Windows Command Prompt (CMD) ] ``` C:\greengrass\v2\bin\greengrass-cli deployment create ^ --merge "com.example.HelloWorld=1.0.0" ^ --update-config hello-world-config-update.json ``` ------ #### [ PowerShell ] ``` C:\greengrass\v2\bin\greengrass-cli deployment create ` --merge "com.example.HelloWorld=1.0.0" ` --update-config hello-world-config-update.json ``` ------ 1. ログをもう一度確認して、Hello World コンポーネントが新しいメッセージを出力することか確認してください。 ------ #### [ Linux or Unix ] ``` sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log ``` ------ #### [ Windows Command Prompt (CMD) ] ``` type C:\greengrass\v2\logs\com.example.HelloWorld.log ``` `type` コマンドは、ファイルのコンテンツを端末に書き込みます。このコマンドを複数回実行して、ファイル内の変更を確認してください。 ------ #### [ PowerShell ] ``` gc C:\greengrass\v2\logs\com.example.HelloWorld.log -Tail 10 -Wait ``` ------ 次の例に示すようなメッセージが表示されます。 ``` Hello, friend! Greetings from your first Greengrass component. ``` 1. コンポーネントのテストが完了したら、コアデバイスから削除します。以下のコマンドを実行してください。 ------ #### [ Linux or Unix ] ``` sudo /greengrass/v2/bin/greengrass-cli deployment create --remove="com.example.HelloWorld" ``` ------ #### [ Windows Command Prompt (CMD) ] ``` C:\greengrass\v2\bin\greengrass-cli deployment create --remove="com.example.HelloWorld" ``` ------ #### [ PowerShell ] ``` C:\greengrass\v2\bin\greengrass-cli deployment create --remove="com.example.HelloWorld" ``` ------ **重要** この手順は、コンポーネントを AWS IoT Greengrassにアップロードした後、コアデバイスにコンポーネントをデプロイし直すために必要です。そうしなかった場合、ローカルデプロイはコンポーネントの異なるバージョンを指定しているため、デプロイがバージョンの互換性エラーで失敗します。 次のコマンドを実行して、`com.example.HelloWorld` コンポーネントが、デバイス上のコンポーネントリストに表示されないことを確認します。 ------ #### [ Linux or Unix ] ``` sudo /greengrass/v2/bin/greengrass-cli component list ``` ------ #### [ Windows Command Prompt (CMD) ] ``` C:\greengrass\v2\bin\greengrass-cli component list ``` ------ #### [ PowerShell ] ``` C:\greengrass\v2\bin\greengrass-cli component list ``` ------ Hello World コンポーネントが完了し、 AWS IoT Greengrass クラウドサービスにアップロードできるようになりました。その後に、コンポーネントを Greengrass コアデバイスにデプロイできます。 # ステップ 5: AWS IoT Greengrass サービスでコンポーネントを作成する コアデバイスでのコンポーネントの開発が完了したら、コンポーネントを AWS クラウドの AWS IoT Greengrass サービスにアップロードすることができます。また、コンポーネントを[AWS IoT Greengrass コンソール](https://console.aws.amazon.com/greengrass)で直接作成することもできます。 AWS IoT Greengrass はコンポーネントをホストするコンポーネント管理サービスを提供するため、個々のデバイスやデバイスのフリートにデプロイすることができます。コンポーネントを AWS IoT Greengrass サービスにアップロードするには、次の手順を実行します。 + コンポーネントのアーティファクトを S3 バケットにのアップロードします。 + 各アーティファクトの Amazon Simple Storage Service (Amazon S3) URI をコンポーネント recipe に追加します。 + コンポーネントレシピ AWS IoT Greengrass から にコンポーネントを作成します。 このセクションでは、Greengrass コアデバイスでこれらのステップを完了して、Hello World コンポーネントを AWS IoT Greengrass サービスにアップロードします。 ## でコンポーネントを作成する AWS IoT Greengrass (コンソール) 1. AWS アカウントの S3 バケットを使用して、 AWS IoT Greengrass コンポーネントアーティファクトをホストします。コンポーネントをコアデバイスにデプロイすると、デバイスがバケットからコンポーネントのアーティファクトをダウンロードします。 既存の S3 バケットを使用するか、新しいバケットを作成することができます。 1. [Amazon S3 コンソール](https://console.aws.amazon.com/s3)で **[Buckets]** (バケット)、**[Create bucket]** (バケットの作成) の順に選択します。 1. **[Bucket name]** (バケット名) に、一意のバケット名前を入力します。たとえば、**greengrass-component-artifacts-*region*-*123456789012*** を使用できます。*123456789012* を AWS アカウント ID に置き換え、*リージョン* AWS リージョン をこのチュートリアルで使用する に置き換えます。 1. **AWS リージョン**の場合は、このチュートリアルで使用する AWS リージョンを選択します。 1. **[Create bucket]** (バケットの作成) を選択します。 1. **[Buckets]** (バケット) で作成したバケットを選択し、`hello_world.py` スクリプトをバケット内の `artifacts/com.example.HelloWorld/1.0.0` フォルダにアップロードします。オブジェクトを S3 バケットにアップロードする方法の詳細については、「*Amazon Simple Storage Service ユーザーガイド*」の「[オブジェクトのアップロード](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html)」を参照してください。 1. S3 バケット内にある `hello_world.py` オブジェクトの S3 URI をコピーします。この URI は次の例のようになります。amzn-s3-demo-bucket を S3 バケットの名前に置き換えます。 ``` s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py ``` 1. コアデバイスが S3 バケット内のコンポーネントアーティファクトにアクセスすることを許可します。 各コアデバイスには、 とやり取り AWS IoT して AWS クラウドにログを送信できるようにする[コアデバイス IAM ロール](device-service-role.md)があります。このデバイスロールは、デフォルトでは S3 バケットへのアクセスを許可しないため、コアデバイスが S3 バケットからコンポーネントアーティファクトを取得できるようにするポリシーを作成して、アタッチする必要があります。 デバイスのロールで S3 バケットへのアクセスが既に許可されている場合は、このステップを省略できます。そうでない場合は、次に示す方法で、アクセスを許可する IAM ポリシーを作成し、ロールにアタッチします。 1. [[IAM console]](https://console.aws.amazon.com/iam) (IAM コンソール) ナビゲーションメニューで、**[Policies]** (ポリシー) を選択し、**[Create policy]** (ポリシーの作成) を選択します。 1. **JSON** タブで、プレースホルダーコンテンツを以下のポリシーに置き換えます。amzn-s3-demo-bucket をコアデバイスでダウンロードするコンポーネントアーティファクトが含まれる S3 バケットの名前に置き換えます。 ``` { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "s3:GetObject" ], "Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*" } ] } ``` 1. [**次へ**] を選択します。 1. **[ポリシーの詳細セクション]** で、**[名前]** に「**MyGreengrassV2ComponentArtifactPolicy**」と入力します。 1. [**Create policy**] (ポリシーの作成) を選択します。 1. [[IAM console]](https://console.aws.amazon.com/iam) (IAM コンソール) ナビゲーションメニューで、**[Role]** (ロール) をクリックし、コアデバイスのロールの名前を選択します。 AWS IoT Greengrass Core ソフトウェアのインストール時にこのロール名を指定しました。名前を指定していない場合、デフォルトで `GreengrassV2TokenExchangeRole` が設定されます。 1. **[Permissions]** (アクセス許可) タブを選択し、**[Add permissions]** (アクセス許可の追加) を選択してから、**[Attach policies]** (ポリシーの添付) を選択します。 1. **[アクセス許可の追加]** ページで、作成した `MyGreengrassV2ComponentArtifactPolicy` ポリシーの横にあるチェックボックスを選択し、**[アクセス許可の追加]** を選択します。 1. コンポーネント recipe を使用して、[AWS IoT Greengrass コンソール](https://console.aws.amazon.com/greengrass)にコンポーネントを作成します。 1. [AWS IoT Greengrass コンソール](https://console.aws.amazon.com/greengrass)のナビゲーションメニューで、**[Components]** (コンポーネント) 、**[Create component]** (コンポーネントを作成) の順に選択します。 1. **[Component information]** (コンポーネント情報) で、**[Enter recipe as JSON]** (recipe を JSON として入力します) を選択します。プレースホルダ recipe は、次の例のようになります。 ``` { "RecipeFormatVersion": "2020-01-25", "ComponentName": "com.example.HelloWorld", "ComponentVersion": "1.0.0", "ComponentDescription": "My first AWS IoT Greengrass component.", "ComponentPublisher": "Amazon", "ComponentConfiguration": { "DefaultConfiguration": { "Message": "world" } }, "Manifests": [ { "Platform": { "os": "linux" }, "Lifecycle": { "Run": "python3 -u {artifacts:path}/hello_world.py \"{configuration:/Message}\"" }, "Artifacts": [ { "URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py" } ] }, { "Platform": { "os": "windows" }, "Lifecycle": { "Run": "py -3 -u {artifacts:path}/hello_world.py \"{configuration:/Message}\"" }, "Artifacts": [ { "URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py" } ] } ] } ``` 1. 各 `Artifacts` セクションにあるプレースホルダー URI を、`hello_world.py` オブジェクトの S3 URI に置き換えます。 1. **[Create component]** (コンポーネントの作成) を選択します。 1. **com.example.HelloWorld** コンポーネントページで、コンポーネントの **[Status]** (ステータス) が **[Deployable]** (デプロイ可能) になっていることを確認します。 ## ( AWS IoT Greengrass AWS CLI) でコンポーネントを作成する **Hello World コンポーネントをアップロードするには** 1. で S3 バケット AWS アカウント を使用して、 AWS IoT Greengrass コンポーネントアーティファクトをホストします。コンポーネントをコアデバイスにデプロイすると、デバイスがバケットからコンポーネントのアーティファクトをダウンロードします。 既存の S3 バケットを使用するか、次のコマンドを実行してバケットを作成します。このコマンドは、 AWS アカウント ID と を使用してバケットを作成し AWS リージョン 、一意のバケット名を作成します。*123456789012* を AWS アカウント ID に置き換え、*リージョン* AWS リージョン をこのチュートリアルで使用する に置き換えます。 ``` aws s3 mb s3://greengrass-component-artifacts-123456789012-region ``` 以下は、リクエストが成功した場合の出力です。 ``` make_bucket: greengrass-component-artifacts-123456789012-region ``` 1. コアデバイスが S3 バケット内のコンポーネントアーティファクトにアクセスすることを許可します。 各コアデバイスには、 とのやり取り AWS IoT と へのログの送信を許可する[コアデバイス IAM ロール](device-service-role.md)があります AWS クラウド。このデバイスロールは、デフォルトでは S3 バケットへのアクセスを許可しないため、コアデバイスが S3 バケットからコンポーネントアーティファクトを取得できるようにするポリシーを作成して、アタッチする必要があります。 コアデバイスのロールで S3 バケットへのアクセスが既に許可されている場合は、このステップを省略できます。そうでない場合は、次に示す方法で、アクセスを許可する IAM ポリシーを作成し、ロールにアタッチします。 1. `component-artifact-policy.json` という名前のファイルを作成して、次の JSON をファイルにコピーします。このポリシーは、S3 バケット内のすべてのファイルへのアクセスを許可します。amzn-s3-demo-bucket を S3 バケットの名前に置き換えます。 ``` { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "s3:GetObject" ], "Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*" } ] } ``` 1. 次のコマンドを実行して、`component-artifact-policy.json` のポリシードキュメントからポリシーを作成します。 ------ #### [ Linux or Unix ] ``` aws iam create-policy \\ --policy-name MyGreengrassV2ComponentArtifactPolicy \\ --policy-document file://component-artifact-policy.json ``` ------ #### [ Windows Command Prompt (CMD) ] ``` aws iam create-policy ^ --policy-name MyGreengrassV2ComponentArtifactPolicy ^ --policy-document file://component-artifact-policy.json ``` ------ #### [ PowerShell ] ``` aws iam create-policy ` --policy-name MyGreengrassV2ComponentArtifactPolicy ` --policy-document file://component-artifact-policy.json ``` ------ 出力のポリシーメタデータから、ポリシーの Amazon リソースネーム (ARN) をコピーします。この ARN を使用して、次の手順で、このポリシーをコアデバイスのロールにアタッチします。 1. 次のコマンドを実行して、ポリシーをコアデバイスのロールにアタッチします。*GreengrassV2TokenExchangeRole* を、コアデバイスのロール名に置き換えます。 AWS IoT Greengrass Core ソフトウェアのインストール時にこのロール名を指定しました。ポリシー ARN を、前のステップで書き留めた ARN に置き換えます。 ------ #### [ Linux or Unix ] ``` aws iam attach-role-policy \\ --role-name GreengrassV2TokenExchangeRole \\ --policy-arn arn:aws:iam::123456789012:policy/MyGreengrassV2ComponentArtifactPolicy ``` ------ #### [ Windows Command Prompt (CMD) ] ``` aws iam attach-role-policy ^ --role-name GreengrassV2TokenExchangeRole ^ --policy-arn arn:aws:iam::123456789012:policy/MyGreengrassV2ComponentArtifactPolicy ``` ------ #### [ PowerShell ] ``` aws iam attach-role-policy ` --role-name GreengrassV2TokenExchangeRole ` --policy-arn arn:aws:iam::123456789012:policy/MyGreengrassV2ComponentArtifactPolicy ``` ------ 成功した場合は、コマンドからの出力はありません。コアデバイスが、この S3 バケットにアップロードしたアーティファクトにアクセスできるようになりました。 1. Hello World Python スクリプトアーティファクトを S3 バケットにアップロードします。 次のコマンドを実行して、スクリプトが AWS IoT Greengrass コアに存在するバケット内の同じパスにスクリプトをアップロードします。amzn-s3-demo-bucket を S3 バケットの名前に置き換えます。 ------ #### [ Linux or Unix ] ``` aws s3 cp \ artifacts/com.example.HelloWorld/1.0.0/hello_world.py \ s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py ``` ------ #### [ Windows Command Prompt (CMD) ] ``` aws s3 cp ^ artifacts/com.example.HelloWorld/1.0.0/hello_world.py ^ s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py ``` ------ #### [ PowerShell ] ``` aws s3 cp ` artifacts/com.example.HelloWorld/1.0.0/hello_world.py ` s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py ``` ------ リクエストが成功した場合、コマンドは `upload:` で始まる行を出力します。 1. アーティファクトの Amazon S3 URI をコンポーネント recipe に追加します。 Amazon S3 URI は、バケット名とバケット内のアーティファクトオブジェクトへのパスで設定されます。スクリプトアーティファクトの Amazon S3 URI は、前のステップでアーティファクトをアップロードした URI です。この URI は次の例のようになります。amzn-s3-demo-bucket を S3 バケットの名前に置き換えます。 ``` s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py ``` アーティファクトを recipe に追加するには、Amazon S3 URI の構造が含まれる `Artifacts` のリストを追加します。 ------ #### [ JSON ] ``` "Artifacts": [ { "URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py" } ] ``` テキストエディタで recipe ファイルを開きます。 例えば、Linux ベースのシステムでは、次のコマンドを実行し、GNU nano を使用してファイルを作成できます。 ``` nano recipes/com.example.HelloWorld-1.0.0.json ``` アーティファクトを recipe に追加します。recipe ファイルは次の例のようになります。 ``` { "RecipeFormatVersion": "2020-01-25", "ComponentName": "com.example.HelloWorld", "ComponentVersion": "1.0.0", "ComponentDescription": "My first AWS IoT Greengrass component.", "ComponentPublisher": "Amazon", "ComponentConfiguration": { "DefaultConfiguration": { "Message": "world" } }, "Manifests": [ { "Platform": { "os": "linux" }, "Lifecycle": { "Run": "python3 -u {artifacts:path}/hello_world.py \"{configuration:/Message}\"" }, "Artifacts": [ { "URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py" } ] }, { "Platform": { "os": "windows" }, "Lifecycle": { "Run": "py -3 -u {artifacts:path}/hello_world.py \"{configuration:/Message}\"" }, "Artifacts": [ { "URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py" } ] } ] } ``` ------ #### [ YAML ] ``` Artifacts: - URI: s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py ``` テキストエディタで recipe ファイルを開きます。 例えば、Linux ベースのシステムでは、次のコマンドを実行し、GNU nano を使用してファイルを作成できます。 ``` nano recipes/com.example.HelloWorld-1.0.0.yaml ``` アーティファクトを recipe に追加します。recipe ファイルは次の例のようになります。 ``` --- RecipeFormatVersion: '2020-01-25' ComponentName: com.example.HelloWorld ComponentVersion: '1.0.0' ComponentDescription: My first AWS IoT Greengrass component. ComponentPublisher: Amazon ComponentConfiguration: DefaultConfiguration: Message: world Manifests: - Platform: os: linux Lifecycle: Run: | python3 -u {artifacts:path}/hello_world.py "{configuration:/Message}" Artifacts: - URI: s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py - Platform: os: windows Lifecycle: Run: | py -3 -u {artifacts:path}/hello_world.py "{configuration:/Message}" Artifacts: - URI: s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py ``` ------ 1. レシピ AWS IoT Greengrass から にコンポーネントリソースを作成します。次のコマンドを実行して、recipe からコンポーネントを作成します。このコンポーネントをバイナリファイルとして提供します。 ------ #### [ JSON ] ``` aws greengrassv2 create-component-version --inline-recipe fileb://recipes/com.example.HelloWorld-1.0.0.json ``` ------ #### [ YAML ] ``` aws greengrassv2 create-component-version --inline-recipe fileb://recipes/com.example.HelloWorld-1.0.0.yaml ``` ------ リクエストが成功すると、レスポンスは次の例のようになります。 ``` { "arn": "arn:aws:greengrass:region:123456789012:components:com.example.HelloWorld:versions:1.0.0", "componentName": "com.example.HelloWorld", "componentVersion": "1.0.0", "creationTimestamp": "Mon Nov 30 09:04:05 UTC 2020", "status": { "componentState": "REQUESTED", "message": "NONE", "errors": {} } } ``` 次のステップでコンポーネントの状態をチェックするために、出力から `arn` をコピーします。 **注記** Hello World コンポーネントは、[AWS IoT Greengrass コンソール](https://console.aws.amazon.com/greengrass)の **[Components]** (コンポーネント) ページでも確認できます。 1. コンポーネントが作成され、デプロイする準備が整っていることを確認します。コンポーネントを作成すると、その状態は `REQUESTED` になります。次に、 はコンポーネントがデプロイ可能であることを AWS IoT Greengrass 検証します。次のコマンドを実行して、コンポーネントのステータスを照会し、コンポーネントがデプロイ可能であることを確認します。`arn` を、前のステップで書き留めた ARN に置き換えます。 ``` aws greengrassv2 describe-component --arn "arn:aws:greengrass:region:123456789012:components:com.example.HelloWorld:versions:1.0.0" ``` コンポーネントが検証されると、レスポンスでコンポーネントの状態が `DEPLOYABLE` であることが示されます。 ``` { "arn": "arn:aws:greengrass:region:123456789012:components:com.example.HelloWorld:versions:1.0.0", "componentName": "com.example.HelloWorld", "componentVersion": "1.0.0", "creationTimestamp": "2020-11-30T18:04:05.823Z", "publisher": "Amazon", "description": "My first Greengrass component.", "status": { "componentState": "DEPLOYABLE", "message": "NONE", "errors": {} }, "platforms": [ { "os": "linux", "architecture": "all" } ] } ``` Hello World コンポーネントが で使用できるようになりました AWS IoT Greengrass。この Greengrass コアデバイスまたは他のコアデバイスにデプロイして戻すことができます。 # ステップ 6: コンポーネントをデプロイする AWS IoT Greengrass を使用して、コンポーネントを個々のデバイスまたはデバイスのグループにデプロイすることができます。コンポーネントをデプロイすると、AWS IoT Greengrass が各ターゲットデバイスにそのコンポーネントのソフトウェアをインストールして実行します。デプロイするコンポーネントと、各コンポーネントにデプロイする設定の更新を指定します。また、デプロイのターゲットとなるデバイスへのデプロイ方法を管理することもできます。詳細については、「[AWS IoT Greengrass コンポーネントをデバイスにデプロイする](manage-deployments.md)」を参照してください。 このセクションでは、Hello World コンポーネントを Greengrass コアデバイスにデプロイして戻します。 ## コンポーネントをデプロイする (コンソール) 1. [AWS IoT Greengrass コンソール](https://console.aws.amazon.com/greengrass)のナビゲーションメニューで、**[Components]** (コンポーネント) を選択します。 1. **[Components]** (コンポーネント) ページの **[My components]** (マイコンポーネント) タブで、[**com.example.HelloWorld**] を選択します。 1. **com.example.HelloWorld** ページで、**[Deploy]** (デプロイ) を選択します。 1. **[Add to deployment]** (デプロイに追加) で、**[Create new deployment]** (新しいデプロイの作成)、**[Next]** (次へ) の順に選択します。 1. 「**対象を指定する**」ページで、次を実行します: 1. [**名前**] ボックスに **Deployment for MyGreengrassCore** と入力します。 1. **[Deployment target]** (デプロイ対象) で、**[Core device]** (コアデバイス) と、コアデバイスの AWS IoT モノの名前を選択します。このチュートリアルのデフォルト値は *MyGreengrassCore* です。 1. [**次へ**] を選択します。 1. **[Select components]** (コンポーネントを選択) ページの **[My components]** (マイコンポーネント) 内で、**com.example.HelloWorld** コンポーネントが選択されていることを確認して、**[Next]** (次) を選択します。 1. **[Configure components]** (コンポーネントを設定) ページで、**com.example.HelloWorld** を選択したら、次の操作を行います。 1. **[Configure component]** (コンポーネントを設定) を選択します。 1. **[Configuration update]** (設定を更新) の **[Configuration to merge]** (マージの設定) で、次の設定を入力します。 ``` { "Message": "universe" } ``` この設定更新は、このデプロイ内にあるデバイスの Hello World `Message` パラメータを `universe` に設定します。 1. **[確認]** を選択します。 1. [**次へ**] を選択します。 1. **[Configure advanced settings]** (詳細設定) ページはデフォルト設定のままにし、**[Next]** (次へ) を選択します。 1. [**Review**] ページで、[**デプロイ**] を選択します。 1. デプロイが正常に完了すていることを確認します。デプロイには数分かかる場合があります。Hello World のログをチェックして、変更を確認します。Greengrass コアデバイスで、次のコマンドを実行します。 ------ #### [ Linux or Unix ] ``` sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log ``` ------ #### [ Windows Command Prompt (CMD) ] ``` type C:\greengrass\v2\\logs\\com.example.HelloWorld.log ``` ------ #### [ PowerShell ] ``` gc C:\greengrass\v2\\logs\\com.example.HelloWorld.log -Tail 10 -Wait ``` ------ 次の例に示すようなメッセージが表示されます。 ``` Hello, universe! Greetings from your first Greengrass component. ``` **注記** ログメッセージが変更されない場合、デプロイが失敗しているか、コアデバイスに到達していません。これは、コアデバイスがインターネットに接続されていない、あるいは S3 バケットからアーティファクトを取得するために適切な権限がない場合に発生します。コアデバイスで次のコマンドを実行して、AWS IoT Greengrass Core ソフトウェアのログファイルを確認します。このファイルは、Greengrass コアデバイスのデプロイサービスからのログが含まれます。 ``` sudo tail -f /greengrass/v2/logs/greengrass.log ``` ``` type C:\greengrass\v2\\logs\\greengrass.log ``` `type` コマンドは、ファイルのコンテンツを端末に書き込みます。このコマンドを複数回実行して、ファイル内の変更を確認してください。 ``` gc C:\greengrass\v2\\logs\\greengrass.log -Tail 10 -Wait ``` 詳細については、「[トラブルシューティング AWS IoT Greengrass V2](troubleshooting.md)」を参照してください。 ## コンポーネントをデプロイする (AWS CLI) **Hello World コンポーネントをデプロイするには** 1. 開発コンピュータ上で、`hello-world-deployment.json` という名前のファイルを作成して、次の JSON をファイルにコピーします。このファイルは、デプロイするコンポーネントと設定を定義しています。 ``` { "components": { "com.example.HelloWorld": { "componentVersion": "1.0.0", "configurationUpdate": { "merge": "{\"Message\":\"universe\"}" } } } } ``` この設定ファイルは、前の手順で開発してパブリッシュした Hello World コンポーネントのバージョン `1.0.0` をデプロイするように指定します。`configurationUpdate` は、JSON エンコードされた文字列でコンポーネント設定をマージすることを指定しています。この設定更新は、このデプロイ内にあるデバイスの Hello World `Message` パラメータを `universe` に設定します。 1. 次のコマンドを実行して、Greengrass コアデバイスにコンポーネントをデプロイします。個々のデバイスである「モノ」、またはデバイスのグループである「モノのグループ」にデプロイすることができます。*MyGreengrassCore* をコアデバイスの AWS IoT モノの名前に置き換えます。 ------ #### [ Linux or Unix ] ``` aws greengrassv2 create-deployment \ --target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" \ --cli-input-json file://hello-world-deployment.json ``` ------ #### [ Windows Command Prompt (CMD) ] ``` aws greengrassv2 create-deployment ^ --target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" ^ --cli-input-json file://hello-world-deployment.json ``` ------ #### [ PowerShell ] ``` aws greengrassv2 create-deployment ` --target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" ` --cli-input-json file://hello-world-deployment.json ``` ------ コマンドは次の出力例のようなレスポンスを返します。 ``` { "deploymentId": "deb69c37-314a-4369-a6a1-3dff9fce73a9", "iotJobId": "b5d92151-6348-4941-8603-bdbfb3e02b75", "iotJobArn": "arn:aws:iot:region:account-id:job/b5d92151-6348-4941-8603-bdbfb3e02b75" } ``` 1. デプロイが正常に完了すていることを確認します。デプロイには数分かかる場合があります。Hello World のログをチェックして、変更を確認します。Greengrass コアデバイスで、次のコマンドを実行します。 ------ #### [ Linux or Unix ] ``` sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log ``` ------ #### [ Windows Command Prompt (CMD) ] ``` type C:\greengrass\v2\\logs\\com.example.HelloWorld.log ``` ------ #### [ PowerShell ] ``` gc C:\greengrass\v2\\logs\\com.example.HelloWorld.log -Tail 10 -Wait ``` ------ 次の例に示すようなメッセージが表示されます。 ``` Hello, universe! Greetings from your first Greengrass component. ``` **注記** ログメッセージが変更されない場合、デプロイが失敗しているか、コアデバイスに到達していません。これは、コアデバイスがインターネットに接続されていない、あるいは S3 バケットからアーティファクトを取得するために適切な権限がない場合に発生します。コアデバイスで次のコマンドを実行して、AWS IoT Greengrass Core ソフトウェアのログファイルを確認します。このファイルは、Greengrass コアデバイスのデプロイサービスからのログが含まれます。 ``` sudo tail -f /greengrass/v2/logs/greengrass.log ``` ``` type C:\greengrass\v2\\logs\\greengrass.log ``` `type` コマンドは、ファイルのコンテンツを端末に書き込みます。このコマンドを複数回実行して、ファイル内の変更を確認してください。 ``` gc C:\greengrass\v2\\logs\\greengrass.log -Tail 10 -Wait ``` 詳細については、「[トラブルシューティング AWS IoT Greengrass V2](troubleshooting.md)」を参照してください。 # 次のステップ これで、このチュートリアルは終了です。AWS IoT Greengrass Core ソフトウェアと Hello World コンポーネントがデバイス上で実行されています。また、Hello World コンポーネントは AWS IoT Greengrass クラウドサービスで利用できる状態で、他のデバイスにデプロイできます。このチュートリアルで説明しているトピックの詳細については、以下を参照してください。 + [AWS IoT Greengrass コンポーネントを作成する](create-components.md) + [コアデバイスにデプロイするコンポーネントをパブリッシュ](publish-components.md) + [AWS IoT Greengrass コンポーネントをデバイスにデプロイする](manage-deployments.md)