Docker コンテナの実行 - AWS IoT Greengrass
要件Amazon ECR または Docker Hub のパブリックイメージから Docker コンテナを実行するAmazon ECR のプライベートイメージから Docker コンテナを実行Amazon S3 のイメージから Docker コンテナの実行Docker コンテナコンポーネントでプロセス間通信の使用Docker コンテナコンポーネント (Linux) でAWS 認証情報の使用Docker コンテナコンポーネント (Linux) でストリームマネージャーの使用

翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。

Docker コンテナの実行

AWS IoT Greengrass コンポーネントが、次の場所に保存されているイメージの Docker コンテナを実行するように設定できます。

  • Amazon Elastic Container Registry (Amazon ECR) のパブリックイメージリポジトリおよびプライベートイメージリポジトリ

  • パブリック Docker Hub リポジトリ

  • パブリック Docker の信頼レジストリ

  • S3 バケット

カスタムコンポーネントで、Docker イメージ URI をアーティファクトとして含めて、イメージを取得してコアデバイスに実行します。Amazon ECR と Docker Hub イメージの場合、Docker アプリケーションマネージャーコンポーネントを使用して、プライベート Amazon ECR リポジトリ用にイメージのダウンロードと認証情報の管理ができます。

要件

コンポーネントの Docker コンテナを実行するには、次のものが必要です:

  • Greengrass コアデバイス。アカウントをお持ちでない場合は、「チュートリアル: AWS IoT Greengrass V2 の開始方法」を参照してください。

  • Docker Engine 1.9.1 以降が Greengrass コアにインストールされていいること。バージョン 20.10 は、AWS IoT Greengrass Core ソフトウェアとの動作が確認されている最新バージョンです。Docker コンテナを実行するコンポーネントをデプロイする前に、コアデバイスに直接、Docker をインストールしておく必要があります。

    ヒント

    コンポーネントのインストール時に、Docker Engine をインストールするようにコアデバイスを設定することもできます。例えば、次のインストールスクリプトは、Docker イメージをロードする前に Docker Engine をインストールします。このインストールスクリプトは、Ubuntu など、 Debian ベースの Linux ディストリビューションに動作します。このコマンドで Docker Engine をインストールするようにコンポーネントを設定する場合、ライフサイクルスクリプトに RequiresPrivilege を true に設定して、インストールと docker コマンドを実行する必要があります。詳細については、「AWS IoT Greengrass コンポーネントレシピのリファレンス」を参照してください。

    apt-get install docker-ce docker-ce-cli containerd.io && docker load -i {artifacts:path}/hello-world.tar

  • Docker コンテナコンポーネントを実行するシステムユーザーには、ルート権限または管理者権限が必要です。権限がない場合は、ルート権限または管理者権限を持たないユーザーとして実行されるように Docker を設定する必要があります。

    • Linux デバイスでは、ユーザーを docker グループに追加することで、sudo のない docker コマンドを呼び出せます。

    • Windows デバイスでは、ユーザーを docker-users グループ に追加することで、管理者の権限のない docker コマンドを呼び出せます。

    Linux or Unix

    Docker コンテナコンポーネントの実行に使用する ggc_user または非ルートユーザーを docker グループに追加するには、次のコマンドを実行します。

    sudo usermod -aG docker ggc_user

    詳細については、「Docker を非ルートユーザーとして管理する」を参照してください。

    Windows Command Prompt (CMD)

    Docker コンテナコンポーネントの実行に使用する ggc_user またはユーザーを docker-users グループに追加するには、次のコマンドを管理者として実行します。

    net localgroup docker-users ggc_user /add
    Windows PowerShell

    Docker コンテナコンポーネントの実行に使用する ggc_user またはユーザーを docker-users グループに追加するには、次のコマンドを管理者として実行します。

    Add-LocalGroupMember -Group docker-users -Member ggc_user

  • Docker コンテナ内にある Docker コンテナコンポーネントによってアクセスされるボリュームとしてマウントされたファイル。

  • AWS IoT Greengrass Core ソフトウェアがネットワークプロキシを使用するように設定している場合、Docker が同じプロキシサーバーを使用するように設定する必要があります。

これらの要件に加えて、環境に該当する場合、次の要件も満たす必要があります:

  • Docker Compose を使用して Docker コンテナを作成して起動するには、Greengrass コアデバイスに Docker Compose をインストールして、Docker Compose ファイルを S3 バケットにアップロードします。Compose ファイルは、コンポーネントと同じ AWS アカウント と AWS リージョン の S3 バケットに保存する必要があります。カスタムコンポーネントに docker-compose up コマンドを使用する例については、「Amazon ECR または Docker Hub のパブリックイメージから Docker コンテナを実行する」を参照してください。

  • AWS IoT Greengrass をネットワークプロキシの背後で実行する場合、Docker デーモンがプロキシサーバーを使用するように設定してください。

  • Docker イメージが Amazon ECR または Docker Hub に保存されている場合、Docker コンポーネントマネージャーコンポーネントを Docker コンテナコンポーネントの従属関係として含めます。コンポーネントをデプロイする前に、コアデバイスの Docker デーモンを起動する必要があります。

    また、イメージ URI をコンポーネントアーティファクトとして含めます。イメージ URI は、次の例で示すように、形式 docker:registry/image[:tag|@digest] である必要があります。

    • プライベート Amazon ECR イメージ: docker:account-id.dkr.ecr.region.amazonaws.com/repository/image[:tag|@digest]

    • パブリック Amazon ECR イメージ: docker:public.ecr.aws/repository/image[:tag|@digest]

    • パブリック Docker Hub イメージ: docker:name[:tag|@digest]

    パブリックリポジトリに格納されているイメージから Docker コンテナを実行する方法の詳細については、「Amazon ECR または Docker Hub のパブリックイメージから Docker コンテナを実行する」を参照してください。

  • Docker イメージが Amazon ECR プライベートリポジトリに格納されている場合、トークン交換のサービスコンポーネントを従属関係として Docker コンテナコンポーネントに含める必要があります。また、Greengrass デバイスのロールは、以下の IAM ポリシー例で示されているように、ecr:GetAuthorizationToken、ecr:BatchGetImage、ecr:GetDownloadUrlForLayer アクションを許可する必要があります。

    {
  "Version": "2012-10-17",
  "Statement": [
    {
      "Action": [
        "ecr:GetAuthorizationToken",
        "ecr:BatchGetImage",
        "ecr:GetDownloadUrlForLayer"
      ],
      "Resource": [
        "*"
      ],
      "Effect": "Allow"
    }
  ]
}

    Amazon ECR プライベートリポジトリに格納されているイメージから Docker コンテナを実行する方法の情報については、「Amazon ECR のプライベートイメージから Docker コンテナを実行」を参照してください。

  • Amazon ECR プライベートリポジトリに格納されている Docker イメージを使用するには、プライベートリポジトリがコアデバイスと同じ AWS リージョン にある必要があります。

  • Docker イメージまたは Compose ファイルが S3 バケットに保存されている場合、Greengrass デバイスのロールは s3:GetObject 許可を付与して、次の IAM ポリシーの例で示すように、コアデバイスがコンポーネントアーティファクトとしてイメージをダウンロードできるようにする必要があります。

    {
  "Version": "2012-10-17",
  "Statement": [
    {
      "Action": [
        "s3:GetObject"
      ],
      "Resource": [
        "*"
      ],
      "Effect": "Allow"
    }
  ]
}

    Amazon S3 に格納されているイメージから Docker コンテナを実行する方法の情報については、「Amazon S3 のイメージから Docker コンテナの実行」を参照してください。

  • Docker コンテナコンポーネントのプロセス間通信 (IPC)、AWS 認証情報、ストリームマネージャーを使用するには、Docker コンテナの実行時に追加のオプションを指定する必要があります。詳細については、次を参照してください。

Amazon ECR または Docker Hub のパブリックイメージから Docker コンテナを実行する

このセクションでは、Docker Compose を使用して Amazon ECR と Docker Hub に格納されている Docker イメージから Docker コンテナを実行するカスタムコンポーネントを作成する方法について説明します。

Docker Compose を使用して Docker コンテナを実行するには

  1. Docker Compose ファイルを作成して Amazon S3 バケットにアップロードします。Greengrass デバイスのロール がデバイスが Compose ファイルにアクセスできるようにする s3:GetObject 許可を付与することを確認します。次の例に示す Compose ファイルの例には、Amazon ECR の Amazon CloudWatch エージェントイメージと Docker Hub の MySQL イメージが含まれています。

    version: "3"
services:
  cloudwatchagent:
    image: "public.ecr.aws/cloudwatch-agent/cloudwatch-agent:latest"
  mysql:
    image: "mysql:8.0"

  2. AWS IoT Greengrass コアデバイスに カスタムコンポーネントを作成します。次の例に示すレシピの例には、次のプロパティがあります:

    • 従属関係としての Docker アプリケーション マネージャー コンポーネント。このコンポーネントは、AWS IoT Greengrass がパブリック Amazon ECR と Docker Hub リポジトリからイメージをダウンロードできるようにします。

    • パブリック Amazon ECR リポジトリの Docker イメージを指定するコンポーネントアーティファクト。

    • パブリック Docker Hub リポジトリの Docker イメージを指定するコンポーネントアーティファクト。

    • 実行する Docker イメージのコンテナを含む Docker Compose ファイルを指定するコンポーネントアーティファクト。

    • 指定したイメージからコンテナを作成して起動するため、docker-compose up を使用するライフサイクル実行スクリプト。

    JSON
    {
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.MyDockerComposeComponent",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "A component that uses Docker Compose to run images from public Amazon ECR and Docker Hub.",
  "ComponentPublisher": "Amazon",
  "ComponentDependencies": {
    "aws.greengrass.DockerApplicationManager": {
      "VersionRequirement": "~2.0.0"
    }
  },
  "Manifests": [
    {
      "Platform": {
        "os": "all"
      },
      "Lifecycle": {
        "run": "docker-compose -f {artifacts:path}/docker-compose.yaml up"
      },
      "Artifacts": [
        {
          "URI": "docker:public.ecr.aws/cloudwatch-agent/cloudwatch-agent:latest"
        },
        {
          "URI": "docker:mysql:8.0"
        },
        {
          "URI": "s3://DOC-EXAMPLE-BUCKET/folder/docker-compose.yaml"
        }
      ]
    }
  ]
}
    YAML
    ---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.MyDockerComposeComponent
ComponentVersion: '1.0.0'
ComponentDescription: 'A component that uses Docker Compose to run images from public Amazon ECR and Docker Hub.'
ComponentPublisher: Amazon
ComponentDependencies:
  aws.greengrass.DockerApplicationManager:
    VersionRequirement: ~2.0.0
Manifests:
  - Platform:
      os: all
    Lifecycle:
        run: docker-compose -f {artifacts:path}/docker-compose.yaml up
    Artifacts:
      - URI: "docker:public.ecr.aws/cloudwatch-agent/cloudwatch-agent:latest"
      - URI: "docker:mysql:8.0"
      - URI: "s3://DOC-EXAMPLE-BUCKET/folder/docker-compose.yaml"
    注記

    Docker コンテナコンポーネントのプロセス間通信 (IPC)、AWS 認証情報、ストリームマネージャーを使用するには、Docker コンテナの実行時に追加のオプションを指定する必要があります。詳細については、次を参照してください。

  3. コンポーネントをテストしてが正常に作動することを確認します。

    重要

    コンポーネントをデプロイする前に、Docker デーモンをインストールして起動する必要があります。

    コンポーネントをローカルにデプロイした後、Docker コンテナ ls コマンドを実行してコンテナが実行されていることを確認できます。

    docker container ls

  4. コンポーネントの準備ができたら、コンポーネントを AWS IoT Greengrass にアップロードして他のコアデバイスにデプロイします。詳細については、「コアデバイスにデプロイするコンポーネントをパブリッシュ」を参照してください。

Amazon ECR のプライベートイメージから Docker コンテナを実行

このセクションでは、Amazon ECR のプライベートリポジトリに格納されている Docker イメージから、Docker コンテナを実行するカスタムコンポーネントを作成する方法について説明します。

Docker コンテナを実行するには

  1. AWS IoT Greengrass コアデバイスに カスタムコンポーネントを作成します。次のプロパティが含まれる次のレシピの例を使用します:

    • 従属関係としての Docker アプリケーション マネージャー コンポーネント。このコンポーネントは、AWS IoT Greengrass がプライベートリポジトリからイメージをダウンロードするための認証情報を管理できるようにします。

    • 従属関係としてのトークン交換のサービスコンポーネント。このコンポーネントは、AWS IoT Greengrass が Amazon ECR とやり取りするための AWS 認証情報を取得できるようにします。

    • プライベート Amazon ECR リポジトリの Docker イメージを指定するコンポーネントアーティファクト。

    • イメージからコンテナを作成して起動するため、docker 実行を使用するライフサイクル実行スクリプト。

    JSON
    {
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.MyPrivateDockerComponent",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "A component that runs a Docker container from a private Amazon ECR image.",
  "ComponentPublisher": "Amazon",
  "ComponentDependencies": {
    "aws.greengrass.DockerApplicationManager": {
      "VersionRequirement": "~2.0.0"
    },
    "aws.greengrass.TokenExchangeService": {
      "VersionRequirement": "~2.0.0"
    }
  },
  "Manifests": [
    {
      "Platform": {
        "os": "all"
      },
      "Lifecycle": {
        "run": "docker run account-id.dkr.ecr.region.amazonaws.com/repository[:tag|@digest]"
      },
      "Artifacts": [
        {
          "URI": "docker:account-id.dkr.ecr.region.amazonaws.com/repository[:tag|@digest]"
        }
      ]
    }
  ]
}
    YAML
    ---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.MyPrivateDockerComponent
ComponentVersion: '1.0.0'
ComponentDescription: 'A component that runs a Docker container from a private Amazon ECR image.'
ComponentPublisher: Amazon
ComponentDependencies:
  aws.greengrass.DockerApplicationManager:
    VersionRequirement: ~2.0.0
  aws.greengrass.TokenExchangeService:
    VersionRequirement: ~2.0.0
Manifests:
  - Platform:
      os: all
    Lifecycle:
        run: docker run account-id.dkr.ecr.region.amazonaws.com/repository[:tag|@digest]
    Artifacts:
      - URI: "docker:account-id.dkr.ecr.region.amazonaws.com/repository[:tag|@digest]"
    注記

    Docker コンテナコンポーネントのプロセス間通信 (IPC)、AWS 認証情報、ストリームマネージャーを使用するには、Docker コンテナの実行時に追加のオプションを指定する必要があります。詳細については、次を参照してください。

  2. コンポーネントをテストしてが正常に作動することを確認します。

    重要

    コンポーネントをデプロイする前に、Docker デーモンをインストールして起動する必要があります。

    コンポーネントをローカルにデプロイした後、Docker コンテナ ls コマンドを実行してコンテナが実行されていることを確認できます。

    docker container ls

  3. コンポーネントを AWS IoT Greengrass にアップロードして、他のコアデバイスにデプロイします。詳細については、「コアデバイスにデプロイするコンポーネントをパブリッシュ」を参照してください。

Amazon S3 のイメージから Docker コンテナの実行

このセクションでは、Amazon S3 に格納されている Docker イメージのコンポーネントに Docker コンテナを実行する方法について説明します。

Amazon S3 のイメージのコンポーネントに Docker コンテナを実行するには

  1. docker 保存コマンドを実行して、Docker コンテナのバックアップを作成します。このバックアップは、AWS IoT Greengrass でコンテナを実行するコンポーネントアーティファクトとして提供します。hello-worldをイメージの名前に置き換えて、hello-world.tarを作成するアーカイブファイルの名前に置き換えます。

    docker save hello-world > artifacts/com.example.MyDockerComponent/1.0.0/hello-world.tar

  2. AWS IoT Greengrass コアデバイスに カスタムコンポーネントを作成します。次のプロパティが含まれる次のレシピの例を使用します:

    • アーカイブから Docker イメージをロードするため、docker ロードを使用するライフサイクル インストール スクリプト。

    • イメージからコンテナを作成して起動するため、docker 実行を使用するライフサイクル実行スクリプト。--rm オプションは、コンテナの終了時にコンテナのクリーンアップが実行します。

    JSON
    {
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.MyS3DockerComponent",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "A component that runs a Docker container from an image in an S3 bucket.",
  "ComponentPublisher": "Amazon",
  "Manifests": [
    {
      "Platform": {
        "os": "linux"
      },
      "Lifecycle": {
        "install": {
          "Script": "docker load -i {artifacts:path}/hello-world.tar"
        },
        "run": {
          "Script": "docker run --rm hello-world"
        }
      }
    }
  ]
}
    YAML
    ---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.MyS3DockerComponent
ComponentVersion: '1.0.0'
ComponentDescription: 'A component that runs a Docker container from an image in an S3 bucket.'
ComponentPublisher: Amazon
Manifests:
  - Platform:
      os: linux
    Lifecycle:
      install:
        Script: docker load -i {artifacts:path}/hello-world.tar
      run:
        Script: docker run --rm hello-world
    注記

    Docker コンテナコンポーネントのプロセス間通信 (IPC)、AWS 認証情報、ストリームマネージャーを使用するには、Docker コンテナの実行時に追加のオプションを指定する必要があります。詳細については、次を参照してください。

  3. コンポーネントをテストしてが正常に作動することを確認します。

    コンポーネントをローカルにデプロイした後、Docker コンテナ ls コマンドを実行してコンテナが実行されていることを確認できます。

    docker container ls

  4. コンポーネントの準備ができたら、S3 バケットに Docker イメージアーカイブをアップロードし、コンポーネントレシピに URI を追加します。次に、コンポーネントを AWS IoT Greengrass にアップロードして他のコアデバイスに展開できます。詳細については、「コアデバイスにデプロイするコンポーネントをパブリッシュ」を参照してください。

    完了したら、コンポーネントレシピは次の例のようになります。

    JSON
    {
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.MyS3DockerComponent",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "A component that runs a Docker container from an image in an S3 bucket.",
  "ComponentPublisher": "Amazon",
  "Manifests": [
    {
      "Platform": {
        "os": "linux"
      },
      "Lifecycle": {
        "install": {
          "Script": "docker load -i {artifacts:path}/hello-world.tar"
        },
        "run": {
          "Script": "docker run --rm hello-world"
        }
      },
      "Artifacts": [
        {
          "URI": "s3://DOC-EXAMPLE-BUCKET/artifacts/com.example.MyDockerComponent/1.0.0/hello-world.tar"
        }
      ]
    }
  ]
}
    YAML
    ---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.MyS3DockerComponent
ComponentVersion: '1.0.0'
ComponentDescription: 'A component that runs a Docker container from an image in an S3 bucket.'
ComponentPublisher: Amazon
Manifests:
  - Platform:
      os: linux
    Lifecycle:
      install:
        Script: docker load -i {artifacts:path}/hello-world.tar
      run:
        Script: docker run --rm hello-world
    Artifacts:
      - URI: s3://DOC-EXAMPLE-BUCKET/artifacts/com.example.MyDockerComponent/1.0.0/hello-world.tar

Docker コンテナコンポーネントでプロセス間通信の使用

AWS IoT Device SDK で Greengrass プロセス間通信 (IPC) ライブラリを使用して Greengrass nucleus、他の Greengrass コンポーネント、AWS IoT Core と通信できます。詳細については、「AWS IoT Device SDK を使用して Greengrass nucleus、その他のコンポーネント、および AWS IoT Core と通信する」を参照してください。

Docker コンテナコンポーネントで IPC を使用するには、次のパラメータで Docker コンテナを実行する必要があります。

  • IPC ソケットをコンテナに取り付けます。Greengrass nucleus は、AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT 環境変数で IPC ソケットファイルパスを提供します。

  • SVCUID と AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT の環境変数を Greengrass nucleus がコンポーネントに提供する値に設定します。コンポーネントは、これらの環境変数を使用して Greengrass nucleus への接続を認証します。

例 レシピの例: AWS IoT Core (Python) に MQTT メッセージをパブリッシュ

次のレシピは、MQTT メッセージを AWS IoT Core にパブリッシュする Docker コンテナコンポーネントの例を定義します。このレシピには以下のプロパティがあります。

  • accessControl コンポーネントに対して、すべてのトピックについて MQTT メッセージを AWS IoT Core にパブリッシュすることを許可する承認ポリシー。詳細については、「コンポーネントに IPC オペレーションの実行を許可する」と「AWS IoT Core MQTT IPC 認証」を参照してください。

  • Amazon S3 の Docker イメージを TAR アーカイブとして指定するコンポーネントアーティファクト。

  • TAR アーカイブから Docker イメージをロードするライフサイクル インストール スクリプト。

  • イメージから Docker コンテナを実行するライフサイクル実行スクリプト。Docker 実行コマンドは次の引数がありります。

    • -v 引数は Greengrass IPC ソケットをコンテナにマウントします。

    • 最初の 2 つの -e 引数は、Docker コンテナに必要な環境変数を設定します。

    • 追加の -e 引数は、この例で使用される環境変数を設定します。

    • --rm 引数は、終了時にコンテナのクリーンアップを実行します。

JSON
{
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.python.docker.PublishToIoTCore",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "Uses interprocess communication to publish an MQTT message to IoT Core.",
  "ComponentPublisher": "Amazon",
  "ComponentConfiguration": {
    "DefaultConfiguration": {
      "topic": "test/topic/java",
      "message": "Hello, World!",
      "qos": "1",
      "accessControl": {
        "aws.greengrass.ipc.mqttproxy": {
          "com.example.python.docker.PublishToIoTCore:pubsub:1": {
            "policyDescription": "Allows access to publish to IoT Core on all topics.",
            "operations": [
              "aws.greengrass#PublishToIoTCore"
            ],
            "resources": [
              "*"
            ]
          }
        }
      }
    }
  },
  "Manifests": [
    {
      "Platform": {
        "os": "all"
      },
      "Lifecycle": {
        "install": "docker load -i {artifacts:path}/publish-to-iot-core.tar",
        "run": "docker run -v $AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT:$AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT -e SVCUID -e AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT -e MQTT_TOPIC=\"{configuration:/topic}\" -e MQTT_MESSAGE=\"{configuration:/message}\" -e MQTT_QOS=\"{configuration:/qos}\" --rm publish-to-iot-core"
      },
      "Artifacts": [
        {
          "URI": "s3://DOC-EXAMPLE-BUCKET/artifacts/com.example.python.docker.PublishToIoTCore/1.0.0/publish-to-iot-core.tar"
        }
      ]
    }
  ]
}
YAML
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.python.docker.PublishToIoTCore
ComponentVersion: 1.0.0
ComponentDescription: Uses interprocess communication to publish an MQTT message to IoT Core.
ComponentPublisher: Amazon
ComponentConfiguration:
  DefaultConfiguration:
    topic: 'test/topic/java'
    message: 'Hello, World!'
    qos: '1'
    accessControl:
      aws.greengrass.ipc.mqttproxy:
        'com.example.python.docker.PublishToIoTCore:pubsub:1':
          policyDescription: Allows access to publish to IoT Core on all topics.
          operations:
            - 'aws.greengrass#PublishToIoTCore'
          resources:
            - '*'
Manifests:
  - Platform:
      os: all
    Lifecycle:
      install: 'docker load -i {artifacts:path}/publish-to-iot-core.tar'
      run: |
        docker run \
          -v $AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT:$AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT \
          -e SVCUID \
          -e AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT \
          -e MQTT_TOPIC="{configuration:/topic}" \
          -e MQTT_MESSAGE="{configuration:/message}" \
          -e MQTT_QOS="{configuration:/qos}" \
          --rm publish-to-iot-core
    Artifacts:
      - URI: s3://DOC-EXAMPLE-BUCKET/artifacts/com.example.python.docker.PublishToIoTCore/1.0.0/publish-to-iot-core.tar

Docker コンテナコンポーネント (Linux) でAWS 認証情報の使用

トークン交換のサービスコンポーネントを使用して Greengrass コンポーネントの AWS サービスとやり取りできます。このコンポーネントは、ローカル コンテナ サーバーを使用してコアデバイスのトークン交換ロールの AWS 認証情報を提供します。詳細については、「AWS サービスとやり取り」を参照してください。

注記

このセクションの例は Linux コアデバイスにのみ使えます。

Docker コンテナコンポーネントのトークン交換サービスの AWS 認証情報を使用するには、次のパラメータで Docker コンテナを実行する必要があります。

  • --network=host 引数を使用して、ホストネットワークへのアクセスを提供します。このオプションは、Docker コンテナがローカルトークン交換サービスに接続して AWS 認証情報を取得できるようにします。この引数は、Linux 用 Docker にのみ機能します。

    警告

    このオプションは、コンテナがホストのすべてのローカル ネットワーク インターフェイスにアクセスできるようにするため、このオプションは、ホストネットワークにこのアクセスなしで Docker コンテナを実行した場合よりも安全性が低くなります。このオプションを使用する Docker コンテナコンポーネントを開発して実行するときに、この点に注意してください。詳細については、「Docker マニュアル」の「ネットワーク: ホスト」を参照してください。

  • AWS_CONTAINER_CREDENTIALS_FULL_URI と AWS_CONTAINER_AUTHORIZATION_TOKEN の環境変数を Greengrass nucleus がコンポーネントに提供する値に設定します。AWSSDK はこれらの環境変数を使用して AWS 認証情報を取得します。

例 レシピの例: Docker コンテナコンポーネント (Python) で S3 バケットを一覧表示

次のレシピは、AWS アカウント の S3 バケットを一覧表示する Docker コンテナコンポーネントの例を定義します。このレシピには以下のプロパティがあります。

  • 従属関係としてのトークン交換のサービスコンポーネント。この依存関係は、コンポーネントが AWS 認証情報を取得して他の AWS サービスとやり取りできるようにします。

  • Amazon S3 の Docker イメージを TAR アーカイブとして指定するコンポーネントアーティファクト。

  • TAR アーカイブから Docker イメージをロードするライフサイクル インストール スクリプト。

  • イメージから Docker コンテナを実行するライフサイクル実行スクリプト。Docker 実行コマンドは次の引数がありります。

    • --network=host 引数は、コンテナがホストネットワークにアクセスを提供するため、コンテナがトークン交換サービスに接続できます。

    • -e 引数は、Docker コンテナの必要な環境変数を設定します。

    • --rm 引数は、終了時にコンテナのクリーンアップを実行します。

JSON
{
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.python.docker.ListS3Buckets",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "Uses the token exchange service to lists your S3 buckets.",
  "ComponentPublisher": "Amazon",
  "ComponentDependencies": {
    "aws.greengrass.TokenExchangeService": {
      "VersionRequirement": "^2.0.0",
      "DependencyType": "HARD"
    }
  },
  "Manifests": [
    {
      "Platform": {
        "os": "linux"
      },
      "Lifecycle": {
        "install": "docker load -i {artifacts:path}/list-s3-buckets.tar",
        "run": "docker run --network=host -e AWS_CONTAINER_AUTHORIZATION_TOKEN -e AWS_CONTAINER_CREDENTIALS_FULL_URI --rm list-s3-buckets"
      },
      "Artifacts": [
        {
          "URI": "s3://DOC-EXAMPLE-BUCKET/artifacts/com.example.python.docker.ListS3Buckets/1.0.0/list-s3-buckets.tar"
        }
      ]
    }
  ]
}
YAML
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.python.docker.ListS3Buckets
ComponentVersion: 1.0.0
ComponentDescription: Uses the token exchange service to lists your S3 buckets.
ComponentPublisher: Amazon
ComponentDependencies:
  aws.greengrass.TokenExchangeService:
    VersionRequirement: ^2.0.0
    DependencyType: HARD
Manifests:
  - Platform:
      os: linux
    Lifecycle:
      install: 'docker load -i {artifacts:path}/list-s3-buckets.tar'
      run: |
        docker run \
          --network=host \
          -e AWS_CONTAINER_AUTHORIZATION_TOKEN \
          -e AWS_CONTAINER_CREDENTIALS_FULL_URI \
          --rm list-s3-buckets
    Artifacts:
      - URI: s3://DOC-EXAMPLE-BUCKET/artifacts/com.example.python.docker.ListS3Buckets/1.0.0/list-s3-buckets.tar

Docker コンテナコンポーネント (Linux) でストリームマネージャーの使用

ストリーム マネージャー コンポーネント を使用して Greengrass コンポーネントのデータストリームを管理します。このコンポーネントは、データストリーム処理と大量の IoT データを AWS クラウド に転送できるようにします。AWS IoT Greengrass は、ストリームマネージャーコンポーネントとやり取りするために使用するストリームマネージャー SDK を提供します。詳細については、「Greengrass コアデバイスでのデータストリームの管理」を参照してください。

注記

このセクションの例は Linux コアデバイスにのみ使えます。

Docker コンテナコンポーネントでストリームマネージャー SDK を使用するには、次のパラメータで Docker コンテナを実行する必要があります。

  • --network=host 引数を使用して、ホストネットワークへのアクセスを提供します。このオプションは、Docker コンテナがローカル TLS 接続を介してストリームマネージャーコンポーネントとやり取りできるようにします。この引数は Linux 用 Docker にのみ使えます

    警告

    このオプションは、コンテナがホストのすべてのローカル ネットワーク インターフェイスにアクセスできるようにするため、このオプションは、ホストネットワークにこのアクセスなしで Docker コンテナを実行した場合よりも安全性が低くなります。このオプションを使用する Docker コンテナコンポーネントを開発して実行するときに、この点に注意してください。詳細については、「Docker マニュアル」の「ネットワーク: ホスト」を参照してください。

  • 認証を要求する (デフォルト動作) ようにストリーム マネージャー コンポーネントを設定する場合、AWS_CONTAINER_CREDENTIALS_FULL_URI 環境変数を Greengrass nucleus がコンポーネントに提供する値に設定します。詳細については、「ストリームマネージャーの設定」を参照してください。

  • ストリーム マネージャー コンポーネントがデフォルト以外のポートを使用するように設定する場合は、プロセス間通信 (IPC) を使用してストリーム マネージャー コンポーネント設定からポートを取得します。IPC を使用するには、追加オプションを指定して Docker コンテナを実行する必要があります。詳細については、次を参照してください。

例 レシピの例: Docker コンテナコンポーネント (Python) で S3 バケットにファイルのストリーミング

次のレシピは、ファイルを作成して S3 バケットにストリーミングする Docker コンテナコンポーネントの例を定義します。このレシピには以下のプロパティがあります。

  • 従属関係としてのストリーム マネージャー コンポーネント。この依存関係により、コンポーネントはストリームマネージャー SDK を使用してストリームマネージャーコンポーネントとやり取りできます。

  • Amazon S3 の Docker イメージを TAR アーカイブとして指定するコンポーネントアーティファクト。

  • TAR アーカイブから Docker イメージをロードするライフサイクル インストール スクリプト。

  • イメージから Docker コンテナを実行するライフサイクル実行スクリプト。Docker 実行コマンドは次の引数がありります。

    • --network=host 引数は、コンテナにホストネットワークへのアクセスを提供するため、コンテナがストリームマネージャーコンポーネントに接続できます。

    • 最初の -e 引数は、Docker コンテナの必要な AWS_CONTAINER_AUTHORIZATION_TOKEN 環境変数を設定します。

    • 追加の -e 引数は、この例で使用される環境変数を設定します。

    • -v 引数は、コンポーネントの作業フォルダをコンテナにマウントします。この例では、ストリームマネージャーを使用して、Amazon S3 にアップロードするファイルを作業フォルダに作成します。

    • --rm 引数は、終了時にコンテナのクリーンアップを実行します。

JSON
{
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.python.docker.StreamFileToS3",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "Creates a text file and uses stream manager to stream the file to S3.",
  "ComponentPublisher": "Amazon",
  "ComponentDependencies": {
    "aws.greengrass.StreamManager": {
      "VersionRequirement": "^2.0.0",
      "DependencyType": "HARD"
    }
  },
  "ComponentConfiguration": {
    "DefaultConfiguration": {
      "bucketName": ""
    }
  },
  "Manifests": [
    {
      "Platform": {
        "os": "linux"
      },
      "Lifecycle": {
        "install": "docker load -i {artifacts:path}/stream-file-to-s3.tar",
        "run": "docker run --network=host -e AWS_CONTAINER_AUTHORIZATION_TOKEN -e BUCKET_NAME=\"{configuration:/bucketName}\" -e WORK_PATH=\"{work:path}\" -v {work:path}:{work:path} --rm stream-file-to-s3"
      },
      "Artifacts": [
        {
          "URI": "s3://DOC-EXAMPLE-BUCKET/artifacts/com.example.python.docker.StreamFileToS3/1.0.0/stream-file-to-s3.tar"
        }
      ]
    }
  ]
}
YAML
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.python.docker.StreamFileToS3
ComponentVersion: 1.0.0
ComponentDescription: Creates a text file and uses stream manager to stream the file to S3.
ComponentPublisher: Amazon
ComponentDependencies:
  aws.greengrass.StreamManager:
    VersionRequirement: ^2.0.0
    DependencyType: HARD
ComponentConfiguration:
  DefaultConfiguration:
    bucketName: ''
Manifests:
  - Platform:
      os: linux
    Lifecycle:
      install: 'docker load -i {artifacts:path}/stream-file-to-s3.tar'
      run: |
        docker run \
          --network=host \
          -e AWS_CONTAINER_AUTHORIZATION_TOKEN \
          -e BUCKET_NAME="{configuration:/bucketName}" \
          -e WORK_PATH="{work:path}" \
          -v {work:path}:{work:path} \
          --rm stream-file-to-s3
    Artifacts:
      - URI: s3://DOC-EXAMPLE-BUCKET/artifacts/com.example.python.docker.StreamFileToS3/1.0.0/stream-file-to-s3.tar