チュートリアル: AWS IoT Greengrass V2 の開始方法 - AWS IoT Greengrass

チュートリアル: AWS IoT Greengrass V2 の開始方法

この基礎的なチュートリアルでは、AWS IoT Greengrass V2 の基本的な機能について知ることができます。このチュートリアルでは、以下の作業を行います。

  1. Raspberry Piなどの Linux デバイスや Windows デバイスに AWS IoT Greengrass Core ソフトウェアをインストールして設定します。このデバイスは Greengrass コアデバイスです。

  2. Greengrass コアデバイス上で、Hello World コンポーネントを開発します。コンポーネントは、Greengrass コアデバイス上で動作するソフトウェアです。

  3. このコンポーネントを AWS クラウド にある AWS IoT Greengrass V2 にアップロードします。

  4. このコンポーネントを、AWS クラウド から Greengrass コアデバイスにデプロイします。

注記

このチュートリアルでは、開発環境をセットアップする方法と、AWS IoT Greengrass の機能について説明します。実稼働デバイスをセットアップおよび設定する方法の詳細については、以下を参照してください。

このチュートリアルは 20~30 分を要します。

前提条件

この入門チュートリアルを完了するには、以下が必要です。

  • AWS アカウント。アカウントをお持ちでない場合は、「ステップ 1: AWS アカウントを設定する」を参照してください。

  • AWS IoT Greengrass V2 をサポートする AWS リージョン を使用します。サポートされているリージョンのリストについては、「AWS 全般のリファレンス」の「AWS IoT Greengrass V2 エンドポイントとクォータ」を参照してください。

  • 管理者権限を持つ AWS Identity and Access Management (IAM) ユーザー。

  • インターネットに接続された Windows、macOS、または Unix のような開発用コンピュータ。

  • Greengrass コアデバイスとしてセットアップするデバイス。Raspberry Pi OS を搭載した Raspberry Pi (以前の Raspbian) または Windows 10 デバイスなど。このデバイスに対する管理者権限を持っているか、sudo を通してなどの方法で、管理者権限を取得できる必要があります。このデバイスにはインターネット接続が必要です。

    また、AWS IoT Greengrass Core ソフトウェアをインストールして実行するための要件を満たしている、別のデバイスを使用することもできます。詳細については、「サポートされているプラットフォームと要件」を参照してください。

    開発用コンピュータがこれらの要件を満たしている場合は、このチュートリアルで Greengrass コアデバイスとしてセットアップできます。

  • デバイス上のすべてのユーザーに対して Python 3.5 以降がインストールされており、PATH 環境変数に追加されていること。Windows の場合は、すべてのユーザーに対して Python Launcher for Windows ランチャーがインストールされている必要があります。

    重要

    Windows では、デフォルトでは Python がすべてのユーザーにインストールされません。Python をインストールするときには、インストールをカスタマイズして、AWS IoT Greengrass Core ソフトウェアが Python スクリプトを実行するように設定する必要があります。たとえば、グラフィカル Python インストーラを使用する場合には、次の操作を行います。

    1. Install launcher for all users (recommended) (すべてのユーザーにランチャーをインストールする (推奨)) を選択します。

    2. Customize installation を選択します。

    3. を選択します。。Next

    4. Install for all users を選択します。

    5. Add Python to environment variables を選択します。

    6. [Install] (インストール) を選択します。

    詳細については、「Python 3 ドキュメント」の「Windows で Python を使用する」を参照してください。

  • 開発コンピュータおよびデバイスに 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 のインストール、更新、アンインストール」と「AWS CLI の設定」を参照してください。

    注記

    32 ビットのオペレーティングシステムを備えた Raspberry Pi などの、32 ビット ARM デバイスを使用する場合は、AWS CLI V1 をインストールします。AWS CLIV2 は 32 ビット ARM デバイスでは利用できません。詳細については、「AWS CLI バージョン 1 のインストール、更新、およびアンインストール」を参照してください。

ステップ 1: AWS アカウントを設定する

以下がない場合は、以下のステップを実行して AWS アカウント を作成します。

AWS アカウント にサインアップするには

  1. https://portal.aws.amazon.com/billing/signup を開きます。

  2. オンラインの手順に従います。

    サインアップ手順の一環として、通話呼び出しを受け取り、電話のキーパッドを用いて検証コードを入力するように求められます。

自分用の管理者ユーザーを作成し、そのユーザーを管理者グループに追加するには (コンソール)

  1. [Root user] (ルートユーザー) を選択して AWS アカウント の E メールアドレスを入力し、アカウント所有者として IAM コンソールにサインインします。次のページでパスワードを入力します。

    注記

    次の IAM の Administrator ユーザーの使用に関するベストプラクティスに従って、ルートユーザーの認証情報は安全な場所に保管しておくことを強くお勧めします。ルートユーザーとしてのサインインは、いくつかのアカウントとサービスの管理タスクの実行にのみ使用してください。

  2. ナビゲーションペインで [Users] (ユーザー)、[Add users] (ユーザーを追加) の順に選択します。

  3. [User name] (ユーザー名) に「Administrator」と入力します。

  4. AWS Management Console アクセス の横にあるチェックボックスを選択します。[Custom password] (カスタムパスワード) を選択し、テキストボックスに新しいパスワードを入力します。

  5. (オプション) AWS では、デフォルトで、新しいユーザーは初回サインイン時に新しいパスワードを作成する必要があります。[User must create a new password at next sign-in (ユーザーは次回のサインイン時に新しいパスワードを作成する必要がある)] の隣にあるチェックボックスのチェックを外して、新しいユーザーがサインインしてからパスワードをリセットできるようにできます。

  6. [Next: Permissions (次へ: アクセス許可)] を選択します。

  7. [Set permissions] (許可の設定) で、[Add user to group] (ユーザーをグループに追加) を選択します。

  8. [Create group] (グループの作成) を選択します。

  9. [Create group] (グループの作成) ダイアログボックスで、[Group name] (グループ名) に「Administrators」と入力します。

  10. [Filter policies] (フィルターポリシー) を選択し、次に [AWS managed - job function] (マネージド - ジョブ機能) を選択してテーブルのコンテンツをフィルタリングします。

  11. ポリシーリストで、[AdministratorAccess] のチェックボックスをオンにします。その後、[Create group] (グループの作成) を選択します。

    注記

    AdministratorAccess 許可を使用して、AWS Billing and Cost Management コンソールを使用する前に、IAM ユーザーおよびロールの請求へのアクセスをアクティブ化する必要があります。これを行うには、請求コンソールへのアクセス権の委任に関するチュートリアルのステップ 1 の手順に従ってください。

  12. グループのリストに戻り、新しいグループのチェックボックスをオンにします。必要に応じて [Refresh] (更新) を選択し、リスト内のグループを表示します。

  13. [次へ: タグ] を選択します。

  14. (オプション) タグをキーバリューペアとしてアタッチして、メタデータをユーザーに追加します。IAM でのタグの使用の詳細については、「IAM ユーザーガイド」の「IAM リソースのタグ付け」を参照してください。

  15. [Next: Review] (次のステップ: 確認) を選択して、新しいユーザーに追加されるグループメンバーシップのリストを表示します。続行する準備ができたら、[Create user] (ユーザーの作成) を選択します。

この同じプロセスにより、さらにグループとユーザーを作成し、そのユーザーに対し AWS アカウント のリソースへのアクセス権を付与できます。ポリシーを使用して特定の AWS リソースに対するユーザーの許可を制限する方法については、「アクセス管理」と「ポリシーの例」を参照してください。

ステップ2: 環境の構築

このセクションのステップに従って、AWS IoT Greengrass コアデバイスとして使用する Linux または Windows デバイスをセットアップします。

これらのステップでは、Raspberry Pi OS を備えた Raspberry Pi を使用していることを前提としています。別のデバイスまたはオペレーティングシステムを使用する場合は、お使いのデバイスに該当するドキュメントを参照してください。

AWS IoT Greengrass V2 の Raspberry Pi をセットアップするには

  1. Raspberry Pi で SSH を有効にして、リモート接続します。詳細については、「Raspberry Pi ドキュメント」の「SSH (セキュアシェル)」を参照してください。

  2. Raspberry Pi の IP アドレスを検索して SSH で接続します。これを行うには、Raspberry Pi 上で次のコマンドを実行します。

    hostname -I
  3. SSH で Raspberry Pi に接続します。

    開発用コンピュータに次のコマンドを実行します。username をサインインするユーザーの名前に置き換えて、pi-ip-address を前のステップで検索した IP アドレスに置き換えます。

    ssh username@pi-ip-address

    Raspberry Pi のデフォルトのユーザー名とパスワードはそれぞれ piraspberry です。

    重要

    開発コンピュータで Microsoft Windows の以前のバージョンを使用している場合、ssh コマンドがないか、ssh があっても Raspberry Pi に接続できない可能性があります。Raspberry Pi に接続するには、無料のオープンソース SSH クライアントである PuTTY をインストールすることができます。「PuTTY ドキュメント」を参照して、Raspberry Pi に接続します。

  4. 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)

AWS IoT Greengrass V2 の Linux デバイスをセットアップするには

  1. AWS IoT Greengrass Core ソフトウェアを実行するために必要な Java ランタイムをインストールします。Amazon Corretto 11 または OpenJDK 11 を使用することをお勧めします。次のコマンドは、デバイスに 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

    インストールが完了したら、次のコマンドを実行して 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)
  2. (オプション) デバイスにコンポーネントを実行するデフォルトのシステムユーザーおよびグループを作成します。AWS IoT Greengrass Core ソフトウェアインストーラは、--component-default-user インストーラ引数でこのユーザーとグループを作成させるという選択もあります。詳細については、「インストーラ引数」を参照してください。

    sudo useradd --system --create-home ggc_user sudo groupadd --system ggc_group
  3. AWS IoT Greengrass Core ソフトウェア (通常は root) を実行するユーザーが、sudo を任意のユーザーと任意のグループに実行する許可があることを確認してください。

    1. /etc/sudoers ファイルを開くには、次のコマンドを実行します。

      sudo visudo
    2. ユーザーの権限が次の例のようになっていることを確認します。

      root ALL=(ALL:ALL) ALL
  4. (オプション) コンテナ化された Lambda 関数を実行するには、cgroups v1 を有効にし、メモリとデバイスの cgroups を有効にしてマウントする必要があります。コンテナ化された Lambda 関数を実行する予定がない場合、この手順を省略できます。

    これらの cgroups オプションを有効にするには、次の Linux カーネルパラメータを使用してデバイスを起動します。

    cgroup_enable=memory cgroup_memory=1 systemd.unified_cgroup_hierarchy=0

    デバイスのカーネルパラメータを確認および設定するための情報については、オペレーティングシステムおよびブートローダーのドキュメントを参照してください。指示に従って、カーネルパラメータを永続的に設定します。

    ヒント: Raspberry Pi にカーネルパラメータを設定する

    デバイスが Raspberry Pi の場合、次の手順を実行して Linux カーネルパラメータを表示と更新できます。

    1. /boot/cmdline.txt ファイルを開きます。このファイルでは、Raspberry Pi の起動時に適用する Linux カーネルパラメータを指定します。

      例えば、Linux ベースのシステムでは、次のコマンドを実行し、GNU nano を使用してファイルを開きます。

      sudo nano /boot/cmdline.txt
    2. /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 ファイルにこれらのパラメータが含まれていない場合、あるいは異なる値を持つこれらのパラメータが含まれている場合、これらのパラメータと値を含むようにファイルを更新してください。

    3. /boot/cmdline.txt ファイルを更新した場合、Raspberry Pi を再起動して変更を適用します。

      sudo reboot
  5. デバイスの要件 にある要件リストで示されているように、その他の必要となる依存関係をすべてデバイスにインストールします。

AWS IoT Greengrass V2 の Windows デバイスをセットアップするには

  1. AWS IoT Greengrass Core ソフトウェアを実行するために必要な Java ランタイムをインストールします。Amazon Corretto 11 または OpenJDK 11 を使用することをお勧めします。

  2. PATH システム変数で Java が使用可能か確認し、そうでない場合は追加します。AWS IoT Greengrass Core ソフトウェアは LocalSystem アカウントで実行されるため、ユーザーの PATH ユーザー変数ではなく、PATH システム変数に Java を追加する必要があります。次を実行してください。

    1. Windows キーを押してスタートメニューを開きます。

    2. environment variables を入力して、スタートメニューからシステムオプションを検索します。

    3. スタートメニューの検索結果から [Edit the system environment variables] (システム環境変数を編集) をクリックして、[System properties] (システムプロパティ) ウィンドウを開きます。

    4. [Environment variables...] (環境変数...) を選択して、[Environment Variables] (環境可変) ウィンドウを開きます。

    5. [System variables] (システム変数) で、[Path] (パス) 、[Edit] (編集) の順に選択します。[Edit environment variable] (環境変数の編集) ウィンドウでは、個別の行に各パスを表示できます。

    6. Java インストールの bin フォルダへのパスが存在しているかを確認します。このパスは、次の例のように表示されます。

      C:\Program Files\Amazon Corretto\jdk11.0.13_8\bin
    7. [Path] (パス) で Java インストールの bin フォルダが で見つからない場合は、[New] (新規) を選択してこれを追加した上で、[OK] を選択します。

  3. 管理者として Windows コマンドプロンプト cmd.exe を開きます。

  4. 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
  5. PsExec ユーティリティを Microsoft からダウンロードしてデバイスにインストールします。

  6. 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 ソフトウェアをインストールする

このセクションの手順に従って、Raspberry Pi をローカル開発に使用できる AWS IoT Greengrass コアデバイスとして設定します。このセクションでは、以下を実行するインストーラをダウンロードして実行し、デバイスの AWS IoT Greengrass Core ソフトウェアを設定します。

  • Greengrass nucleus コンポーネントをインストールします。nucleus は必須コンポーネントであり、デバイス上で AWS IoT Greengrass Core ソフトウェアを実行するための最小要件となります。詳細については、「Greengrass nucleus コンポーネント」を参照してください。

  • デバイスを AWS IoT モノとして登録し、デバイスの AWS への接続を許可するデジタル証明書をダウンロードします。詳細については、「AWS IoT Greengrass のデバイス認証と認可」を参照してください。

  • デバイスの AWS IoTモノ をモノグループに追加します。モノグループは、AWS IoT モノのグループまたはフリートです。モノグループを使用すると、Greengrass コアデバイスのフリートを管理できます。ソフトウェアコンポーネントをデバイスにデプロイするとき、個々のデバイスまたはデバイスのグループのどちらにデプロイするのかを選択することができます。詳細については、「AWS IoT Core デベロッパーガイド」の「AWS IoT でデバイスを管理する」を参照してください。

  • Greengrass コアデバイスが AWS サービスとやり取りを許可する IAM ロールを作成します。デフォルトでは、このロールはデバイスが AWS IoT とやり取りし、Amazon CloudWatch Logs にログを送信することを許可します。詳細については、「コアデバイスが AWS サービスを操作できるように認証する」を参照してください。

  • AWS IoT Greengrass コマンドラインインターフェイス (greengrass-cli) をインストールします。これを使用することで、コアデバイスで開発するカスタムコンポーネントをテストすることができます。詳細については、「Greengrass コマンドラインインターフェイス」を参照してください。

  1. AWS IoT Greengrass コンソールにサインインします。

  2. [Get started with Greengrass] (Greengrass の使用を開始する) で、[Set up one core device] (1 つのコアデバイスをセットアップする) を選択します。

  3. [Step 1: Register a Greengrass core device] (ステップ 1: Greengrass コアデバイスを登録する) にある [Core device name] (コアデバイス名) に、Greengrass コアデバイスの AWS IoT モノの名前を入力します。モノが存在しない場合、インストーラによって作成されます。

  4. [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] (グループなし) を選択した場合、インストーラはコアデバイスをモノグループに追加しません。

  5. [Step 3: Install the Greengrass Core software] (ステップ 3: Greengrass Coreソフトウェアをインストールする) で、以下のステップを実行します。

    1. コアデバイスのオペレーティングシステムを選択します。Linux または Windows のいずれかです。

    2. デバイスに AWS 認証情報を提供して、インストーラがコアデバイスの AWS IoT と IAM リソースをプロビジョニングできるようにします。セキュリティを強化するには、プロビジョニングに必要な最小限の許可のみを与える IAM ロールの一時的な認証情報を取得することをお勧めします。詳細については、「インストーラがリソースをプロビジョニングするための最小限の IAM ポリシー」を参照してください。

      注記

      インストーラが認証情報を保存したり保管することはありません。

      デバイスに、次のいずれかを実行して、認証情報を取得して AWS IoT Greengrass Core ソフトウェアのインストーラを利用できるようにしてください。

      • IAM ユーザーからの長期的な認証情報を使用する:

        1. IAM ユーザーのアクセスキー ID とシークレットアクセスキーを提供します。長期認証情報を取得する方法の詳細については、「IAM ユーザーガイド」の「IAM ユーザーのアクセスキー管理」を参照してください。

        2. 次のコマンドを実行して、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"
      • (推奨) IAM ロールから一時的なセキュリティ認証情報を使用します。

        1. 継承する IAM ロールから、アクセスキー ID、シークレットアクセスキー、セッショントークンを提供します。これらの認証情報を取得する方法の詳細については、「IAM ユーザーガイド」の「一時的なセキュリティ認証情報のリクエスト」を参照してください。

        2. 次のコマンドを実行して、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="
    3. [Run the installer] (インストーラの実行) で、以下のステップを実行します。

      1. [Download the installer] (インストーラをダウンロードする) で、[Copy] (コピー) を選択して、コアデバイス上でコピーしたコマンドを実行します。このコマンドは、AWS IoT Greengrass Core ソフトウェアの最新バージョンをダウンロードし、デバイスで解凍します。

      2. [Run installer] (インストーラを実行する) で、[Copy] (コピー) を選択して、コアデバイス上でコピーしたコマンドを実行します。このコマンドでは、AWS IoT Greengrass Core ソフトウェアインストーラを実行し、コアデバイスの AWS リソースを設定するために、前のステップで指定した AWS IoT モノとモノグループ名を使用します。

        また、このコマンドは次を行います。

        • AWS IoT Greengrass Core ソフトウェアを、ブート時に実行されるシステムサービスとして設定します。Linux デバイスでは、これは Systemd init システムが必要です。

          重要

          Windows コアデバイスでは、AWS IoT Greengrass Core ソフトウェアをシステムサービスとして設定する必要があります

        • AWS IoT Greengrass CLI コンポーネントをデプロイします。このコンポーネントは、コアデバイスでカスタム 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 がない場合には、インストーラはソフトウェアをシステムサービスとして設定せず、nucleus をシステムサービスとして設定できたことを示す成功メッセージは表示されません。

AWS IoT Greengrass Core ソフトウェアをインストールして設定するには

  1. Greengrass コアデバイスで、次のコマンドを実行してホームディレクトリに切り替えます。

    Linux or Unix
    cd ~
    Windows Command Prompt (CMD)
    cd %USERPROFILE%
    PowerShell
    cd ~
  2. コアデバイス上で、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 ソフトウェアのライセンス契約に同意したものと見なされます。

  3. 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
  4. 次のコマンドを実行して、AWS IoT Greengrass Core ソフトウェアのインストーラを起動します。このコマンドは次のことを行います。

    • コアデバイスの動作に必要な AWS リソースを作成します。

    • AWS IoT Greengrass Core ソフトウェアを、ブート時に実行されるシステムサービスとして設定します。Linux デバイスでは、これは Systemd init システムが必要です。

      重要

      Windows コアデバイスでは、AWS IoT Greengrass Core ソフトウェアをシステムサービスとして設定する必要があります

    • AWS IoT Greengrass CLI コンポーネントをデプロイします。このコンポーネントは、コアデバイスでカスタム Greengrass コンポーネントを開発できるようにするためのコマンドラインツールです。

    • コアデバイスでソフトウェアコンポーネントを実行するために ggc_user システムユーザーを使用するように指定します。Linux デバイスでは、このコマンドも ggc_group システムグループを使用するように指定し、さらにインストーラによってシステムユーザーとグループが、ユーザーに代わって作成されます。

    コマンドの引数値を次のように置き換えます。

    1. /greengrass/v2 または C:\greengrass\v2: AWS IoT Greengrass Core ソフトウェアのインストールに使用するルートフォルダへのパス。

    2. GreengrassInstaller。AWS IoT Greengrass Core ソフトウェアのインストーラを展開したフォルダへのパス。

    3. リージョン。リソースを検索または作成する AWS リージョン。

    4. MyGreengrassCore。Greengrass コアデバイスの AWS IoT モノの名前。モノが存在しない場合、インストーラによって作成されます。インストーラは、証明書をダウンロードして AWS IoT モノとして認証します。詳細については、「AWS IoT Greengrass のデバイス認証と認可」を参照してください。

      注記

      モノの名前にコロン (:) 記号を含むことができません。

    5. MyGreengrassCoreGroup。Greengrass コアデバイスの AWS IoT モノグループの名前。モノグループが存在しない場合、インストーラはそのグループを作成してモノを追加します。モノグループが存在してアクティブなデプロイがある場合、コアデバイスはデプロイで指定されたソフトウェアをダウンロードして実行します。

      注記

      モノグループ名にコロン (:) 記号を含めることはできません。

    6. GreengrassV2IoTThingPolicy。Greengrass コアデバイスが AWS IoT および AWS IoT Greengrass と通信できるようにする AWS IoT ポリシーの名前。AWS IoT ポリシーが存在しない場合、インストーラが許可を与える AWS IoT ポリシーをこの名前で作成します。ユースケースに合わせて、このポリシーのアクセス許可を制限することができます。詳細については、「AWS IoT Greengrass V2 コアデバイス向けの最低限の AWS IoT ポリシー」を参照してください。

    7. GreengrassV2TokenExchangeRole。Greengrass コアデバイスが一時的に AWS 認証情報を取得できるようにする IAM ロールの名前。ロールが存在しない場合、インストーラがロールを作成し、GreengrassV2TokenExchangeRoleAccess という名前のポリシーを作成してアタッチします。詳細については、「コアデバイスが AWS サービスを操作できるように認証する」を参照してください。

    8. GreengrassCoreTokenExchangeRoleAlias。Greengrass コアデバイスが後で一時的な認証情報を取得できるようにする IAM ロールのエイリアス。ロールエイリアスが存在しない場合、インストーラがロールエイリアスを作成し、指定した IAM ロールを指します。詳細については、「コアデバイスが AWS サービスを操作できるように認証する」を参照してください。

    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 オプションでメモリ割り当てを制御する」を参照してください。

    このコマンドを実行すると、インストーラが成功したことを示す次のメッセージが表示されます。

    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 がない場合には、インストーラはソフトウェアをシステムサービスとして設定せず、nucleus をシステムサービスとして設定できたことを示す成功メッセージは表示されません。

(オプション) Greengrass ソフトウェアを実行する (Linux)

ソフトウェアをシステムサービスとしてインストールした場合、インストーラがソフトウェアを実行します。実行されない場合は、ソフトウェアを手動で実行する必要があります。インストーラがソフトウェアをシステムサービスとして設定しているかどうかを確認するには、インストーラの出力に次の行がないか探します。

Successfully set up Nucleus as a system service

このメッセージが表示されていない場合は、次の手順に従ってソフトウェアを実行します。

  1. 次のコマンドを使用してソフトウェアを起動します。

    sudo /greengrass/v2/alts/current/distro/bin/loader

    正常に起動すると、ソフトウェアは次のメッセージを出力します。

    Launched Nucleus successfully.
  2. AWS IoT Greengrass Core ソフトウェアを実行したままの状態にしておくため、現在のコマンドシェルは開いたままにしておく必要があります。SSH を使用してコアデバイスに接続する場合は、開発コンピュータで次のコマンドを実行して 2 番目の SSH セッションを開き、コアデバイス上で別のコマンドを実行するために使用することができます。username をサインインするユーザーの名前に置き換えて、pi-ip-address をデバイスの IP アドレスに置き換えます。

    ssh username@pi-ip-address

Greengrass システムサービスとやり取りする方法の詳細については、「Greengrass nucleus をシステムサービスとして設定する」を参照してください。

デバイス上の Greengrass CLI のインストールを確認する

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 のトラブルシューティング」を参照してください。

また、次のコマンドを実行して、デバイスに AWS IoT Greengrass CLI を手動でデプロイすることもできます。

  • リージョンを使用する 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.7.0" } }'
Windows Command Prompt (CMD)
aws greengrassv2 create-deployment ^ --target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" ^ --components "{\"aws.greengrass.Cli\":{\"componentVersion\":\"2.7.0\"}}"
PowerShell
aws greengrassv2 create-deployment ` --target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" ` --components '{\"aws.greengrass.Cli\":{\"componentVersion\":\"2.7.0\"}}'
ヒント

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 コアデバイス間で再利用することができます。すべてのコンポーネントは、レシピとアーティファクトで設定されます。

  • レシピ

    すべてのコンポーネントには、メタデータを定義するレシピファイルが含まれています。レシピでは、コンポーネントの設定パラメータ、コンポーネントの依存関係、ライフサイクル、プラットフォームの互換性も指定します。コンポーネントのライフサイクルは、コンポーネントのインストール、実行、およびシャットダウンを行うコマンドを定義します。詳細については、「AWS IoT Greengrass コンポーネントレシピのリファレンス」を参照してください。

    レシピは JSON または YAML 形式で定義できます。

  • アーティファクト

    コンポーネントは、コンポーネントバイナリであるアーティファクトを必要な数だけ持つことができます。アーティファクトには、スクリプト、コンパイルされたコード、静的リソース、およびコンポーネントが消費するその他のファイルが含まれます。コンポーネントはコンポーネントの依存関係からアーティファクトを消費することもできます。

AWS IoT Greengrass では、AWS クラウドを操作することなく、Greengrass CLI を使用して Greengrass コアデバイス上でローカルでコンポーネントを開発しテストすることができます。ローカルコンポーネントを完了すると、コンポーネントのレシピとアーティファクトを使用して、そのコンポーネントを AWS クラウドの AWS IoT Greengrass サービスを作成し、すべての Greengrass コアデバイスにデプロイすることができます。コンポーネントの詳細については、「AWS IoT Greengrass コンポーネントを開発する」を参照してください。

このセクションでは、基本的な Hello World コンポーネントをコアデバイス上でローカルに作成して実行する方法を説明します。

デバイスで Hello World コンポーネントを開発するには

  1. レシピとアーティファクトのサブフォルダを含むコンポーネントのフォルダを作成します。Greengrass コアデバイスで次のコマンドを実行してこれらのフォルダを作成し、コンポーネントフォルダに変更します。~/greengrassv2 または %USERPROFILE%\greengrassv2 をローカル開発に使用するフォルダへのパスに置き換えます。

    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
  2. テキストエディタを使用して、コンポーネントのメタデータ、パラメータ、依存関係、ライフサイクル、プラットフォーム機能を定義するレシピファイルを作成します。レシピファイル名にコンポーネントのバージョンを含めるようにして、どのレシピがどのコンポーネントバージョンを反映しているのかを特定できるようにします。レシピには 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 は、コンポーネントの最初のメジャーリリースを表しています。詳細については、「セマンティックバージョンの仕様」を参照してください。

  3. ファイルに次のレシピを貼り付けます。

    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}"

    このレシピの ComponentConfiguration セクションはパラメータである Message を定義しており、デフォルトでは world になります。Manifests セクションはマニフェストを定義しており、これは、プラットフォームのライフサイクル指示とアーティファクトのセットです。たとえば、複数のマニフェストを定義して、さまざまなプラットフォームに対して異なるインストール手順を指定することができます。マニフェストでは、Lifecycle セクションは、Greengrass コアデバイスに Message パラメータ値を引数として Hello World スクリプトを実行するように指示します。

  4. 次のコマンドを実行して、コンポーネントアーティファクト用のフォルダを作成します。

    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
    重要

    アーティファクトフォルダのパスには、次のフォーマットを使用する必要があります。レシピで指定したコンポーネント名とバージョンを含めてください。

    artifacts/componentName/componentVersion/
  5. テキストエディタを使用して、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)
  6. ローカル AWS IoT Greengrass CLI を使用して Greengrass コアデバイスのコンポーネントを管理します。

    次のコマンドを実行して、AWS IoT Greengrass コアにコンポーネントをデプロイします。/greengrass/v2 または C:\greengrass\v2 をAWS IoT Greengrass V2 ルートフォルダと置き換えて、~/greengrassv2 または %USERPROFILE%\ Greengrassv2 をコンポーネント開発フォルダに置き換えます。

    Linux or Unix
    sudo /greengrass/v2/bin/greengrass-cli deployment create \ --recipeDir ~/greengrassv2/recipes \ --artifactDir ~/greengrassv2/artifacts \ --merge "com.example.HelloWorld=1.0.0"
    Windows Command Prompt (CMD)
    C:\greengrass\v2\bin\greengrass-cli deployment create ^ --recipeDir %USERPROFILE%\greengrassv2\recipes ^ --artifactDir %USERPROFILE%\greengrassv2\artifacts ^ --merge "com.example.HelloWorld=1.0.0"
    PowerShell
    C:\greengrass\v2\bin\greengrass-cli deployment create ` --recipeDir ~/greengrassv2/recipes ` --artifactDir ~/greengrassv2/artifacts ` --merge "com.example.HelloWorld=1.0.0"

    このコマンドは、recipes ではレシピ、artifacts では Python スクリプトを使用するコンポーネントを追加します。--merge オプションは指定したコンポーネントとバージョンを追加または更新します。

  7. AWS IoT Greengrass Core ソフトウェアは、コンポーネントプロセスからの標準出力を 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 コマンドは、ファイルのコンテンツを端末に書き込みます。このコマンドを複数回実行して、ファイル内の変更を確認してください。

    type コマンドは、ファイルのコンテンツを端末に書き込みます。このコマンドを複数回実行して、ファイル内の変更を確認してください。

    PowerShell
    gc C:\greengrass\v2\logs\com.example.HelloWorld.log -Tail 10 -Wait

    次の例に示すようなメッセージが表示されます。

    Hello, world!
    注記

    ファイルが存在しない場合、ローカルデプロイがまだ完了していない可能性があります。ファイルが 15 秒以内に表示されない場合は、デプロイが失敗している可能性があります。これは、レシピが有効でない場合などに発生します。次のコマンドを実行して、AWS IoT Greengrass コアのログファイルを確認します。このファイルは、Greengrass コアデバイスのデプロイサービスからのログが含まれます。

    Linux or Unix
    sudo tail -f /greengrass/v2/logs/greengrass.log
    Windows Command Prompt (CMD)
    type C:\greengrass\v2\logs\greengrass.log

    type コマンドは、ファイルのコンテンツを端末に書き込みます。このコマンドを複数回実行して、ファイル内の変更を確認してください。

    type コマンドは、ファイルのコンテンツを端末に書き込みます。このコマンドを複数回実行して、ファイル内の変更を確認してください。

    PowerShell
    gc C:\greengrass\v2\logs\greengrass.log -Tail 10 -Wait
  8. ローカルコンポーネントを変更して、コードを繰り返してテストします。テキストエディタで 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)
  9. 次のコマンドを実行して、変更内容でコンポーネントを更新します。

    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 コンポーネントを更新します。

  10. 次のコマンドを実行して、コンポーネントを再起動します。コンポーネントを再起動すると、コアデバイスは最新の変更を使用します。

    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"
  11. ログをもう一度確認して、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 コマンドは、ファイルのコンテンツを端末に書き込みます。このコマンドを複数回実行して、ファイル内の変更を確認してください。

    type コマンドは、ファイルのコンテンツを端末に書き込みます。このコマンドを複数回実行して、ファイル内の変更を確認してください。

    PowerShell
    gc C:\greengrass\v2\logs\com.example.HelloWorld.log -Tail 10 -Wait

    次の例に示すようなメッセージが表示されます。

    Hello, world! Greetings from your first Greengrass component.
  12. コンポーネントの設定パラメータを更新して、さまざまな設定をテストできます。コンポーネントをデプロイするときに、設定の更新を指定して、コアデバイス上のコンポーネントの設定を変更する方法を定義することができます。デフォルト値にリセットする設定値と、コアデバイスにマージする新しい設定値を指定することができます。詳細については、「コンポーネント設定の更新」を参照してください。

    次を実行してください。

    1. テキストエディタを使用して、hello-world-config-update.json という名前のファイルを作成し、設定の更新を含めます。

      例えば、Linux ベースのシステムでは、次のコマンドを実行し、GNU nano を使用してファイルを作成できます。

      nano hello-world-config-update.json
    2. 次の JSON オブジェクトをファイルにコピーして貼り付けます。この JSON オブジェクトは、friend の値を Message パラメータにマージして、その値を更新する設定更新を定義しています。この設定更新では、リセットする値は指定されていません。マージの更新によって既存の値が置き換えられるため、Message パラメータをリセットする必要はありません。

      { "com.example.HelloWorld": { "MERGE": { "Message": "friend" } } }
    3. 次のコマンドを実行して、設定の更新を 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
    4. ログをもう一度確認して、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 コマンドは、ファイルのコンテンツを端末に書き込みます。このコマンドを複数回実行して、ファイル内の変更を確認してください。

      type コマンドは、ファイルのコンテンツを端末に書き込みます。このコマンドを複数回実行して、ファイル内の変更を確認してください。

      PowerShell
      gc C:\greengrass\v2\logs\com.example.HelloWorld.log -Tail 10 -Wait

      次の例に示すようなメッセージが表示されます。

      Hello, friend! Greetings from your first Greengrass component.
  13. コンポーネントのテストが完了したら、コアデバイスから削除します。以下のコマンドを実行します。

    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 コンソールで直接作成することもできます。AWS IoT Greengrass はコンポーネントをホストするコンポーネント管理サービスを提供するため、個々のデバイスやデバイスのフリートにデプロイすることができます。コンポーネントを AWS IoT Greengrass サービスにアップロードするには、以下のステップを実行します。

  • コンポーネントのアーティファクトを S3 バケットにのアップロードします。

  • 各アーティファクトの Amazon Simple Storage Service (Amazon S3) URI をコンポーネントレシピに追加します。

  • コンポーネントレシピから、AWS IoT Greengrass にコンポーネントを作成します。

このセクションでは、Greengrass コアデバイスでこれらの手順を実行して、Hello World コンポーネントを AWS IoT Greengrass サービスにアップロードします。

  1. AWS アカウントの S3 バケットを使用して、AWS IoT Greengrass コンポーネントアーティファクトをホストします。コンポーネントをコアデバイスにデプロイすると、デバイスがバケットからコンポーネントのアーティファクトをダウンロードします。

    既存の S3 バケットを使用するか、新しいバケットを作成することができます。

    1. Amazon S3 コンソール[Buckets] (バケット)、[Create bucket] (バケットの作成) の順に選択します。

    2. [Bucket name] (バケット名) に、一意のバケット名前を入力します。たとえば、greengrass-component-artifacts-123456789012-region を使用できます。123456789012 を AWS アカウントの ID、region をこのチュートリアルで使用する AWS リージョンに置き換えます。

    3. AWS リージョンの場合は、このチュートリアルで使用する AWS リージョンを選択します。

    4. [Create bucket] (バケットの作成) を選択します。

    5. [Buckets] (バケット) で作成したバケットを選択し、hello_world.py スクリプトをバケット内の artifacts/com.example.HelloWorld/1.0.0 フォルダにアップロードします。オブジェクトを S3 バケットにアップロードする際の詳細については、「Amazon Simple Storage Service ユーザーガイド」の「オブジェクトをアップロードする」を参照してください。

    6. S3 バケット内にある hello_world.py オブジェクトの S3 URI をコピーします。この URI は次の例のようになります。DOC-EXAMPLE-BUCKET を S3 バケットの名前に置き換えます。

      s3://DOC-EXAMPLE-BUCKET/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
  2. コアデバイスが S3 バケット内のコンポーネントアーティファクトにアクセスすることを許可します。

    各コアデバイスは、AWS IoT とやり取りや AWS クラウドへのログ送信を可能にするコアデバイス IAM ロールを有しています。このデバイスロールは、デフォルトでは S3 バケットへのアクセスを許可しないため、コアデバイスが S3 バケットからコンポーネントアーティファクトを取得できるようにするポリシーを作成して、アタッチする必要があります。

    デバイスのロールで S3 バケットへのアクセスが既に許可されている場合は、このステップを省略できます。そうでない場合は、次に示す方法で、アクセスを許可する IAM ポリシーを作成し、ロールにアタッチします。

    1. [IAM console] (IAM コンソール) ナビゲーションメニューで、[Policies] (ポリシー) を選択し、[Create policy] (ポリシーの作成) を選択します。

    2. JSON タブで、プレースホルダーコンテンツを以下のポリシーに置き換えます。DOC-EXAMPLE-BUCKET をコアデバイスでダウンロードするコンポーネントアーティファクトが含まれる S3 バケットの名前に置き換えます。

      { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "s3:GetObject" ], "Resource": "arn:aws:s3:::DOC-EXAMPLE-BUCKET/*" } ] }
    3. [次へ: タグ]、[次へ: 確認] の順に選択します。

    4. [Name] (名前) に「MyGreengrassV2ComponentArtifactPolicy」と入力します。

    5. [Create policy] を選択します。

    6. [IAM console] (IAM コンソール) ナビゲーションメニューで、[Role] (ロール) をクリックし、コアデバイスのロールの名前を選択します。このロール名は、AWS IoT Greengrass Core ソフトウェアをインストールしたときに指定したものです。名前を指定していない場合、デフォルトで GreengrassV2TokenExchangeRole が設定されます。

    7. [Permissions] (アクセス許可) タブを選択し、[Add permissions] (アクセス許可の追加) を選択してから、[Attach policies] (ポリシーの添付) を選択します。

    8. [Add permissions] (アクセス許可の追加) ページで、作成した MyGreengrassV2ComponentArtifactPolicy ポリシーの横にあるチェックボックスを選択し、[Attach policies] (ポリシーの添付) を選択します。

  3. コンポーネントレシピを使用して、AWS IoT Greengrass コンソールにコンポーネントを作成します。

    1. AWS IoT Greengrass コンソールのナビゲーションメニューで、[Components] (コンポーネント) 、[Create component] (コンポーネントを作成) の順に選択します。

    2. [Component information] (コンポーネント情報) で、[Enter recipe as JSON] (レシピを 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}\"" }, "Artifacts": [ { "URI": "s3://DOC-EXAMPLE-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://DOC-EXAMPLE-BUCKET/artifacts/com.example.HelloWorld/1.0.0/hello_world.py" } ] } ] }
    3. Artifacts セクションにあるプレースホルダー URI を、hello_world.py オブジェクトの S3 URI に置き換えます。

    4. [Create component] (コンポーネントの作成) を選択します。

    5. com.example.HelloWorld コンポーネントページで、コンポーネントの [Status] (ステータス) が [Deployable] (デプロイ可能) になっていることを確認します。

Hello World コンポーネントをアップロードするには

  1. AWS アカウント の S3 バケットを使用して、AWS IoT Greengrass コンポーネントアーティファクトをホストします。コンポーネントをコアデバイスにデプロイすると、デバイスがバケットからコンポーネントのアーティファクトをダウンロードします。

    既存の S3 バケットを使用するか、次のコマンドを実行してバケットを作成します。このコマンドは、AWS アカウント IDと AWS リージョン を使用してバケットを作成し、一意のバケット名を形成します。123456789012 を AWS アカウント ID、region をこのチュートリアルで使用する AWS リージョン に置き換えます。

    aws s3 mb s3://greengrass-component-artifacts-123456789012-region

    以下は、リクエストが成功した場合の出力です。

    make_bucket: greengrass-component-artifacts-123456789012-region
  2. コアデバイスが S3 バケット内のコンポーネントアーティファクトにアクセスすることを許可します。

    各コアデバイスは、AWS IoT とやり取りや AWS クラウド へのログ送信を可能にするコアデバイス IAM ロールを有しています。このデバイスロールは、デフォルトでは S3 バケットへのアクセスを許可しないため、コアデバイスが S3 バケットからコンポーネントアーティファクトを取得できるようにするポリシーを作成して、アタッチする必要があります。

    コアデバイスのロールで S3 バケットへのアクセスが既に許可されている場合は、このステップを省略できます。そうでない場合は、次に示す方法で、アクセスを許可する IAM ポリシーを作成し、ロールにアタッチします。

    1. component-artifact-policy.json という名前のファイルを作成して、次の JSON をファイルにコピーします。このポリシーは、S3 バケット内のすべてのファイルへのアクセスを許可します。DOC-EXAMPLE-BUCKET を S3 バケットの名前に置き換えます。

      { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "s3:GetObject" ], "Resource": "arn:aws:s3:::DOC-EXAMPLE-BUCKET/*" } ] }
    2. 次のコマンドを実行して、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 を使用して、次の手順で、このポリシーをコアデバイスのロールにアタッチします。

    3. 次のコマンドを実行して、ポリシーをコアデバイスのロールにアタッチします。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 バケットにアップロードしたアーティファクトにアクセスできるようになりました。

  3. Hello World Python スクリプトアーティファクトを S3 バケットにアップロードします。

    次のコマンドを実行して、AWS IoT Greengrass コア内のスクリプトが存在するバケット内の同じパスにスクリプトをアップロードします。DOC-EXAMPLE-BUCKET を S3 バケットの名前に置き換えます。

    Linux or Unix
    aws s3 cp \ artifacts/com.example.HelloWorld/1.0.0/hello_world.py \ s3://DOC-EXAMPLE-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://DOC-EXAMPLE-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://DOC-EXAMPLE-BUCKET/artifacts/com.example.HelloWorld/1.0.0/hello_world.py

    リクエストが成功した場合、コマンドは upload: で始まる行を出力します。

  4. アーティファクトの Amazon S3 URI をコンポーネントレシピに追加します。

    Amazon S3 URI は、バケット名とバケット内のアーティファクトオブジェクトへのパスで設定されます。スクリプトアーティファクトの Amazon S3 URI は、前のステップでアーティファクトをアップロードした URI です。この URI は次の例のようになります。DOC-EXAMPLE-BUCKET を S3 バケットの名前に置き換えます。

    s3://DOC-EXAMPLE-BUCKET/artifacts/com.example.HelloWorld/1.0.0/hello_world.py

    アーティファクトをレシピに追加するには、Amazon S3 URI の構造が含まれる Artifacts のリストを追加します。

    JSON
    "Artifacts": [ { "URI": "s3://DOC-EXAMPLE-BUCKET/artifacts/com.example.HelloWorld/1.0.0/hello_world.py" } ]

    テキストエディタでレシピファイルを開きます。

    例えば、Linux ベースのシステムでは、次のコマンドを実行し、GNU nano を使用してファイルを作成できます。

    nano recipes/com.example.HelloWorld-1.0.0.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}\"" }, "Artifacts": [ { "URI": "s3://DOC-EXAMPLE-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://DOC-EXAMPLE-BUCKET/artifacts/com.example.HelloWorld/1.0.0/hello_world.py" } ] } ] }
    YAML
    Artifacts: - URI: s3://DOC-EXAMPLE-BUCKET/artifacts/com.example.HelloWorld/1.0.0/hello_world.py

    テキストエディタでレシピファイルを開きます。

    例えば、Linux ベースのシステムでは、次のコマンドを実行し、GNU nano を使用してファイルを作成できます。

    nano recipes/com.example.HelloWorld-1.0.0.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}" Artifacts: - URI: s3://DOC-EXAMPLE-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://DOC-EXAMPLE-BUCKET/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
  5. レシピから、AWS IoT Greengrass コンポーネントを作成します。次のコマンドを実行して、レシピからコンポーネントを作成します。このコンポーネントをバイナリファイルとして提供します。

    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 コンソール[Components] (コンポーネント) ページでも確認できます。

  6. コンポーネントが作成され、デプロイする準備が整っていることを確認します。コンポーネントを作成すると、その状態は 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 コンポーネントのデプロイ」を参照してください。

このセクションでは、Hello World コンポーネントを Greengrass コアデバイスにデプロイして戻します。

  1. AWS IoT Greengrass コンソールのナビゲーションメニューで、[Components] (コンポーネント) を選択します。

  2. [Components] (コンポーネント) ページの [My components] (マイコンポーネント) タブで、[com.example.HelloWorld] を選択します。

  3. com.example.HelloWorld ページで、[Deploy] (デプロイ) を選択します。

  4. [Add to deployment] (デプロイに追加) で、[Create new deployment] (新しいデプロイの作成)、[Next] (次へ) の順に選択します。

  5. [Specify device state] (ターゲットを指定) ページで、次を実行します。

    1. [名前] ボックスに Deployment for MyGreengrassCore と入力します。

    2. [Deployment target] (デプロイ対象) で、[Core device] (コアデバイス) と、コアデバイスの AWS IoT モノの名前を選択します。このチュートリアルのデフォルト値は MyGreengrassCore です。

    3. [Next] を選択します。

  6. [Select components] (コンポーネントを選択) ページの [My components] (マイコンポーネント) 内で、com.example.HelloWorld コンポーネントが選択されていることを確認して、[Next] (次) を選択します。

  7. [Configure components] (コンポーネントを設定) ページで、com.example.HelloWorld を選択したら、次の操作を行います。

    1. [Configure component] (コンポーネントを設定) を選択します。

    2. [Configuration update] (設定を更新) の [Configuration to merge] (マージの設定) で、次の設定を入力します。

      { "Message": "universe" }

      この設定更新は、このデプロイ内にあるデバイスの Hello World Message パラメータを universe に設定します。

    3. [Confirm] (確認) を選択します。

    4. [Next] を選択します。

  8. [Configure advanced settings] (詳細設定) ページはデフォルト設定のままにし、[Next] (次へ) を選択します。

  9. [Review] ページで、[デプロイ] を選択します。

  10. デプロイが正常に完了すていることを確認します。デプロイには数分かかる場合があります。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

    type コマンドは、ファイルのコンテンツを端末に書き込みます。このコマンドを複数回実行して、ファイル内の変更を確認してください。

    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 コアデバイスのデプロイサービスからのログが含まれます。

    Linux or Unix
    sudo tail -f /greengrass/v2/logs/greengrass.log
    Windows Command Prompt (CMD)
    type C:\greengrass\v2\logs\greengrass.log

    type コマンドは、ファイルのコンテンツを端末に書き込みます。このコマンドを複数回実行して、ファイル内の変更を確認してください。

    PowerShell
    gc C:\greengrass\v2\logs\greengrass.log -Tail 10 -Wait

    詳細については、「AWS IoT Greengrass V2 のトラブルシューティング」を参照してください。

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 に設定します。

  2. 次のコマンドを実行して、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" }
  3. デプロイが正常に完了すていることを確認します。デプロイには数分かかる場合があります。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

    type コマンドは、ファイルのコンテンツを端末に書き込みます。このコマンドを複数回実行して、ファイル内の変更を確認してください。

    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 コアデバイスのデプロイサービスからのログが含まれます。

    Linux or Unix
    sudo tail -f /greengrass/v2/logs/greengrass.log
    Windows Command Prompt (CMD)
    type C:\greengrass\v2\logs\greengrass.log

    type コマンドは、ファイルのコンテンツを端末に書き込みます。このコマンドを複数回実行して、ファイル内の変更を確認してください。

    PowerShell
    gc C:\greengrass\v2\logs\greengrass.log -Tail 10 -Wait

    詳細については、「AWS IoT Greengrass V2 のトラブルシューティング」を参照してください。

次のステップ

これで、このチュートリアルは終了です。AWS IoT Greengrass Core ソフトウェアと Hello World コンポーネントがデバイス上で実行されています。また、Hello World コンポーネントは AWS IoT Greengrass クラウドサービスで利用できる状態で、他のデバイスにデプロイできます。このチュートリアルで説明しているトピックの詳細については、以下を参照してください。