Exécuter un conteneur Docker - AWS IoT Greengrass
PrérequisExécuter un conteneur Docker à partir d'une image publique dans Amazon ECR ou Docker HubExécuter un conteneur Docker à partir d'une image privée dans Amazon ECRExécuter un conteneur Docker à partir d'une image dans Amazon S3Utiliser la communication interprocessus dans les composants du conteneur DockerUtiliser les AWS informations d'identification dans les composants du conteneur Docker (Linux)Utiliser le gestionnaire de flux dans les composants du conteneur Docker (Linux)

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Exécuter un conteneur Docker

Vous pouvez configurer AWS IoT Greengrass des composants pour exécuter un conteneur Docker à partir d'images stockées aux emplacements suivants :

  • Référentiels d'images publics et privés dans Amazon Elastic Container Registry (Amazon ECR)

  • Référentiel Docker Hub public

  • Registre public de confiance Docker

  • Compartiment S3

Dans votre composant personnalisé, incluez l'URI de l'image Docker en tant qu'artefact pour récupérer l'image et l'exécuter sur le périphérique principal. Pour les images Amazon ECR et Docker Hub, vous pouvez utiliser le composant du gestionnaire d'applications Docker pour télécharger les images et gérer les informations d'identification des référentiels Amazon ECR privés.

Prérequis

Pour exécuter un conteneur Docker dans un composant, vous avez besoin des éléments suivants :

  • Un appareil Greengrass Core. Si vous n'en avez pas, veuillez consulter Didacticiel : Commencer avec AWS IoT Greengrass V2.

  • Docker Engine 1.9.1 ou version ultérieure installé sur le périphérique principal de Greengrass. La version 20.10 est la dernière version vérifiée pour fonctionner avec le logiciel AWS IoT Greengrass Core. Vous devez installer Docker directement sur le périphérique principal avant de déployer des composants qui exécutent des conteneurs Docker.

    Astuce

    Vous pouvez également configurer le périphérique principal pour installer Docker Engine lors de l'installation du composant. Par exemple, le script d'installation suivant installe Docker Engine avant de charger l'image Docker. Ce script d'installation fonctionne sur les distributions Linux basées sur Debian, telles qu'Ubuntu. Si vous configurez le composant pour installer Docker Engine à l'aide de cette commande, vous devrez peut-être le RequiresPrivilege définir true dans le script de cycle de vie pour exécuter l'installation et docker les commandes. Pour plus d’informations, consultez AWS IoT Greengrass référence de recette de composant.

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

  • L'utilisateur du système qui exécute un composant de conteneur Docker doit disposer des autorisations root ou administrateur, ou vous devez configurer Docker pour l'exécuter en tant qu'utilisateur non root ou non administrateur.

    • Sur les appareils Linux, vous pouvez ajouter un utilisateur au docker groupe sans lequel vous pouvez appeler docker des commandessudo.

    • Sur les appareils Windows, vous pouvez ajouter un utilisateur au docker-users groupe pour appeler des docker commandes sans privilèges d'administrateur.

    Linux or Unix

    Pour ajouter ggc_user au docker groupe l'utilisateur non root que vous utilisez pour exécuter les composants du conteneur Docker, exécutez la commande suivante.

    sudo usermod -aG docker ggc_user

    Pour plus d'informations, consultez Gérer Docker en tant qu'utilisateur non root.

    Windows Command Prompt (CMD)

    Pour ajouter ggc_user au docker-users groupe l'utilisateur que vous utilisez pour exécuter les composants du conteneur Docker, exécutez la commande suivante en tant qu'administrateur.

    net localgroup docker-users ggc_user /add
    Windows PowerShell

    Pour ajouter ggc_user au docker-users groupe l'utilisateur que vous utilisez pour exécuter les composants du conteneur Docker, exécutez la commande suivante en tant qu'administrateur.

    Add-LocalGroupMember -Group docker-users -Member ggc_user

  • Fichiers accessibles par le composant de conteneur Docker montés sous forme de volume dans le conteneur Docker.

  • Si vous configurez le logiciel AWS IoT Greengrass Core pour utiliser un proxy réseau, vous devez configurer Docker pour qu'il utilise le même serveur proxy.

Outre ces exigences, vous devez également satisfaire aux exigences suivantes si elles s'appliquent à votre environnement :

  • Pour utiliser Docker Compose pour créer et démarrer vos conteneurs Docker, installez Docker Compose sur votre appareil principal Greengrass et téléchargez votre fichier Docker Compose dans un compartiment S3. Vous devez stocker votre fichier Compose dans un compartiment S3 au même Compte AWS endroit Région AWS que le composant. Pour un exemple d'utilisation de la docker-compose up commande dans un composant personnalisé, consultezExécuter un conteneur Docker à partir d'une image publique dans Amazon ECR ou Docker Hub.

  • Si vous utilisez un AWS IoT Greengrass proxy réseau, configurez le daemon Docker pour qu'il utilise un serveur proxy.

  • Si vos images Docker sont stockées dans Amazon ECR ou Docker Hub, incluez le composant du gestionnaire de composants Docker en tant que dépendance dans votre composant conteneur Docker. Vous devez démarrer le démon Docker sur l'appareil principal avant de déployer votre composant.

    Incluez également les URI de l'image en tant qu'artefacts de composant. Les URI des images doivent être au format docker:registry/image[:tag|@digest] indiqué dans les exemples suivants :

    • Image Amazon ECR privée : docker:account-id.dkr.ecr.region.amazonaws.com/repository/image[:tag|@digest]

    • Image Amazon ECR publique : docker:public.ecr.aws/repository/image[:tag|@digest]

    • Image publique du Docker Hub : docker:name[:tag|@digest]

    Pour plus d'informations sur l'exécution de conteneurs Docker à partir d'images stockées dans des référentiels publics, consultez. Exécuter un conteneur Docker à partir d'une image publique dans Amazon ECR ou Docker Hub

  • Si vos images Docker sont stockées dans un référentiel privé Amazon ECR, vous devez inclure le composant du service d'échange de jetons en tant que dépendance dans le composant conteneur Docker. En outre, le rôle d'appareil Greengrass doit autoriser les ecr:GetDownloadUrlForLayer actions ecr:GetAuthorizationTokenecr:BatchGetImage, et, comme indiqué dans l'exemple de politique IAM suivant. 

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

    Pour plus d'informations sur l'exécution de conteneurs Docker à partir d'images stockées dans un référentiel privé Amazon ECR, consultez. Exécuter un conteneur Docker à partir d'une image privée dans Amazon ECR

  • Pour utiliser des images Docker stockées dans un référentiel privé Amazon ECR, celui-ci doit se trouver dans le même emplacement Région AWS que le périphérique principal.

  • Si vos images Docker ou vos fichiers Compose sont stockés dans un compartiment S3, le rôle d'appareil Greengrass doit autoriser s3:GetObject les appareils principaux à télécharger les images en tant qu'artefacts de composants, comme illustré dans l'exemple de politique IAM suivant. 

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

    Pour plus d'informations sur l'exécution de conteneurs Docker à partir d'images stockées dans Amazon S3, consultezExécuter un conteneur Docker à partir d'une image dans Amazon S3.

  • Pour utiliser la communication interprocessus (IPC), les AWS informations d'identification ou le gestionnaire de flux dans votre composant de conteneur Docker, vous devez spécifier des options supplémentaires lorsque vous exécutez le conteneur Docker. Pour plus d’informations, consultez les ressources suivantes :

Exécuter un conteneur Docker à partir d'une image publique dans Amazon ECR ou Docker Hub

Cette section décrit comment créer un composant personnalisé qui utilise Docker Compose pour exécuter un conteneur Docker à partir d'images Docker stockées sur Amazon ECR et Docker Hub.

Pour exécuter un conteneur Docker à l'aide de Docker Compose

  1. Créez et chargez un fichier Docker Compose dans un compartiment Amazon S3. Assurez-vous que le rôle d'appareil Greengrass s3:GetObject autorise l'appareil à accéder au fichier Compose. L'exemple de fichier Compose présenté dans l'exemple suivant inclut l'image Amazon CloudWatch Agent d'Amazon ECR et l'image MySQL de Docker Hub.

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

  2. Créez un composant personnalisé sur votre appareil AWS IoT Greengrass principal. L'exemple de recette présenté dans l'exemple suivant possède les propriétés suivantes :

    • Le composant du gestionnaire d'applications Docker en tant que dépendance. Ce composant permet AWS IoT Greengrass de télécharger des images depuis les référentiels publics Amazon ECR et Docker Hub.

    • Artefact de composant qui spécifie une image Docker dans un référentiel Amazon ECR public.

    • Artefact de composant qui spécifie une image Docker dans un référentiel Docker Hub public.

    • Artefact de composant qui spécifie le fichier Docker Compose qui inclut les conteneurs pour les images Docker que vous souhaitez exécuter.

    • Script d'exécution du cycle de vie qui utilise docker-compose up pour créer et démarrer un conteneur à partir des images spécifiées.

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

    Pour utiliser la communication interprocessus (IPC), les AWS informations d'identification ou le gestionnaire de flux dans votre composant de conteneur Docker, vous devez spécifier des options supplémentaires lorsque vous exécutez le conteneur Docker. Pour plus d’informations, consultez les ressources suivantes :

  3. Testez le composant pour vérifier qu'il fonctionne comme prévu.

    Important

    Vous devez installer et démarrer le daemon Docker avant de déployer le composant.

    Après avoir déployé le composant localement, vous pouvez exécuter la commande docker container ls pour vérifier que votre conteneur fonctionne.

    docker container ls

  4. Lorsque le composant est prêt, téléchargez-le AWS IoT Greengrass vers pour le déployer sur d'autres appareils principaux. Pour plus d’informations, consultez Publiez des composants à déployer sur vos appareils principaux.

Exécuter un conteneur Docker à partir d'une image privée dans Amazon ECR

Cette section décrit comment créer un composant personnalisé qui exécute un conteneur Docker à partir d'une image Docker stockée dans un référentiel privé sur Amazon ECR.

Pour exécuter un conteneur Docker

  1. Créez un composant personnalisé sur votre appareil AWS IoT Greengrass principal. Utilisez l'exemple de recette suivant, qui possède les propriétés suivantes :

    • Le composant du gestionnaire d'applications Docker en tant que dépendance. Ce composant permet AWS IoT Greengrass de gérer les informations d'identification pour télécharger des images depuis des référentiels privés.

    • Le composant du service d'échange de jetons en tant que dépendance. Ce composant permet de AWS IoT Greengrass récupérer les AWS informations d'identification pour interagir avec Amazon ECR.

    • Artefact de composant qui spécifie une image Docker dans un référentiel Amazon ECR privé.

    • Script d'exécution du cycle de vie qui utilise docker run pour créer et démarrer un conteneur à partir de l'image.

    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]"
    Note

    Pour utiliser la communication interprocessus (IPC), les AWS informations d'identification ou le gestionnaire de flux dans votre composant de conteneur Docker, vous devez spécifier des options supplémentaires lorsque vous exécutez le conteneur Docker. Pour plus d’informations, consultez les ressources suivantes :

  2. Testez le composant pour vérifier qu'il fonctionne comme prévu.

    Important

    Vous devez installer et démarrer le daemon Docker avant de déployer le composant.

    Après avoir déployé le composant localement, vous pouvez exécuter la commande docker container ls pour vérifier que votre conteneur fonctionne.

    docker container ls

  3. Téléchargez le composant AWS IoT Greengrass vers pour le déployer sur d'autres appareils principaux. Pour plus d’informations, consultez Publiez des composants à déployer sur vos appareils principaux.

Exécuter un conteneur Docker à partir d'une image dans Amazon S3

Cette section décrit comment exécuter un conteneur Docker dans un composant à partir d'une image Docker stockée dans Amazon S3.

Pour exécuter un conteneur Docker dans un composant à partir d'une image dans Amazon S3

  1. Exécutez la commande docker save pour créer une sauvegarde d'un conteneur Docker. Vous fournissez cette sauvegarde en tant qu'artefact de composant sur AWS IoT Greengrass lequel exécuter le conteneur. Remplacez hello-world par le nom de l'image et remplacez hello-world.tar par le nom du fichier d'archive à créer.

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

  2. Créez un composant personnalisé sur votre appareil AWS IoT Greengrass principal. Utilisez l'exemple de recette suivant, qui possède les propriétés suivantes :

    • Script d'installation du cycle de vie qui utilise le chargement de docker pour charger une image Docker à partir d'une archive.

    • Script d'exécution du cycle de vie qui utilise docker run pour créer et démarrer un conteneur à partir de l'image. L'--rmoption nettoie le conteneur à sa sortie.

    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
    Note

    Pour utiliser la communication interprocessus (IPC), les AWS informations d'identification ou le gestionnaire de flux dans votre composant de conteneur Docker, vous devez spécifier des options supplémentaires lorsque vous exécutez le conteneur Docker. Pour plus d’informations, consultez les ressources suivantes :

  3. Testez le composant pour vérifier qu'il fonctionne comme prévu.

    Après avoir déployé le composant localement, vous pouvez exécuter la commande docker container ls pour vérifier que votre conteneur fonctionne.

    docker container ls

  4. Lorsque le composant est prêt, téléchargez l'archive d'images Docker dans un compartiment S3 et ajoutez son URI à la recette du composant. Vous pouvez ensuite télécharger le composant pour le AWS IoT Greengrass déployer sur d'autres appareils principaux. Pour plus d’informations, consultez Publiez des composants à déployer sur vos appareils principaux.

    Lorsque vous avez terminé, la recette du composant doit ressembler à l'exemple suivant.

    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

Utiliser la communication interprocessus dans les composants du conteneur Docker

Vous pouvez utiliser la bibliothèque de communication interprocessus (IPC) Greengrass dans le Kit SDK des appareils AWS IoT pour communiquer avec le noyau de Greengrass, les autres composants de Greengrass et. AWS IoT Core Pour plus d’informations, consultez Utilisez le Kit SDK des appareils AWS IoT pour communiquer avec le noyau de Greengrass, les autres composants et AWS IoT Core.

Pour utiliser IPC dans un composant de conteneur Docker, vous devez exécuter le conteneur Docker avec les paramètres suivants :

  • Montez le socket IPC dans le conteneur. Le noyau Greengrass fournit le chemin du fichier du socket IPC dans la AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT variable d'environnement.

  • Définissez les variables d'AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENTenvironnement SVCUID et sur les valeurs que le noyau Greengrass fournit aux composants. Votre composant utilise ces variables d'environnement pour authentifier les connexions au noyau Greengrass.

Exemple de recette : publier un message MQTT sur AWS IoT Core (Python)

La recette suivante définit un exemple de composant de conteneur Docker qui publie un message MQTT sur. AWS IoT Core Cette recette possède les propriétés suivantes :

  • Une politique d'autorisation (accessControl) qui permet au composant de publier des messages MQTT AWS IoT Core sur tous les sujets. Pour plus d'informations, consultez Autoriser les composants à effectuer des opérations IPC et autorisation AWS IoT Core MQTT IPC.

  • Artefact de composant qui spécifie une image Docker en tant qu'archive TAR dans Amazon S3.

  • Script d'installation du cycle de vie qui charge l'image Docker depuis l'archive TAR.

  • Script d'exécution du cycle de vie qui exécute un conteneur Docker à partir de l'image. La commande Docker run comporte les arguments suivants :

    • L'-vargument monte le socket IPC Greengrass dans le conteneur.

    • Les deux premiers -e arguments définissent les variables d'environnement requises dans le conteneur Docker.

    • Les -e arguments supplémentaires définissent les variables d'environnement utilisées dans cet exemple.

    • L'--rmargument nettoie le conteneur à sa sortie.

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

Utiliser les AWS informations d'identification dans les composants du conteneur Docker (Linux)

Vous pouvez utiliser le composant de service d'échange de jetons pour interagir avec les AWS services des composants Greengrass. Ce composant fournit des AWS informations d'identification provenant du rôle d'échange de jetons du périphérique principal à l'aide d'un serveur de conteneurs local. Pour plus d’informations, consultez Interagissez avec les AWS services.

Note

L'exemple présenté dans cette section ne fonctionne que sur les appareils principaux de Linux.

Pour utiliser les AWS informations d'identification du service d'échange de jetons dans un composant de conteneur Docker, vous devez exécuter le conteneur Docker avec les paramètres suivants :

  • Fournissez un accès au réseau hôte à l'aide de l'--network=hostargument. Cette option permet au conteneur Docker de se connecter au service d'échange de jetons local pour récupérer les AWS informations d'identification. Cet argument ne fonctionne que sur Docker pour Linux.

    Avertissement

    Cette option permet au conteneur d'accéder à toutes les interfaces réseau locales de l'hôte. Elle est donc moins sécurisée que si vous exécutez des conteneurs Docker sans cet accès au réseau hôte. Tenez-en compte lorsque vous développez et exécutez des composants de conteneur Docker qui utilisent cette option. Pour plus d'informations, consultez Network : host dans la documentation Docker.

  • Définissez les variables d'AWS_CONTAINER_AUTHORIZATION_TOKENenvironnement AWS_CONTAINER_CREDENTIALS_FULL_URI et sur les valeurs que le noyau Greengrass fournit aux composants. AWS Les SDK utilisent ces variables d'environnement pour récupérer les AWS informations d'identification.

Exemple de recette : répertorier les compartiments S3 dans un composant de conteneur Docker (Python)

La recette suivante définit un exemple de composant de conteneur Docker qui répertorie les compartiments S3 de votre. Compte AWS Cette recette possède les propriétés suivantes :

  • Le composant du service d'échange de jetons en tant que dépendance. Cette dépendance permet au composant de récupérer des AWS informations d'identification pour interagir avec d'autres AWS services.

  • Artefact de composant qui spécifie une image Docker sous forme d'archive tar dans Amazon S3.

  • Script d'installation du cycle de vie qui charge l'image Docker depuis l'archive TAR.

  • Script d'exécution du cycle de vie qui exécute un conteneur Docker à partir de l'image. La commande Docker run comporte les arguments suivants :

    • L'--network=hostargument fournit au conteneur l'accès au réseau hôte, afin que le conteneur puisse se connecter au service d'échange de jetons.

    • L'-eargument définit les variables d'environnement requises dans le conteneur Docker.

    • L'--rmargument nettoie le conteneur à sa sortie.

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

Utiliser le gestionnaire de flux dans les composants du conteneur Docker (Linux)

Vous pouvez utiliser le composant gestionnaire de flux pour gérer les flux de données dans les composants Greengrass. Ce composant vous permet de traiter des flux de données et de transférer de gros volumes de données IoT vers le AWS Cloud. AWS IoT Greengrass fournit un SDK de gestion de flux que vous utilisez pour interagir avec le composant de gestionnaire de flux. Pour plus d’informations, consultez Gérez les flux de données sur les appareils principaux de Greengrass.

Note

L'exemple présenté dans cette section ne fonctionne que sur les appareils principaux de Linux.

Pour utiliser le SDK du gestionnaire de flux dans un composant de conteneur Docker, vous devez exécuter le conteneur Docker avec les paramètres suivants :

  • Fournissez un accès au réseau hôte à l'aide de l'--network=hostargument. Cette option permet au conteneur Docker d'interagir avec le composant du gestionnaire de flux via une connexion TLS locale. Cet argument ne fonctionne que sur Docker pour Linux

    Avertissement

    Cette option permet au conteneur d'accéder à toutes les interfaces réseau locales de l'hôte. Elle est donc moins sécurisée que si vous exécutez des conteneurs Docker sans cet accès au réseau hôte. Tenez-en compte lorsque vous développez et exécutez des composants de conteneur Docker qui utilisent cette option. Pour plus d'informations, consultez Network : host dans la documentation Docker.

  • Si vous configurez le composant du gestionnaire de flux pour exiger une authentification, qui est le comportement par défaut, définissez la variable d'AWS_CONTAINER_CREDENTIALS_FULL_URIenvironnement sur la valeur que le noyau Greengrass fournit aux composants. Pour plus d'informations, consultez la section Configuration du gestionnaire de flux.

  • Si vous configurez le composant du gestionnaire de flux pour utiliser un port autre que celui par défaut, utilisez la communication interprocessus (IPC) pour obtenir le port à partir de la configuration du composant du gestionnaire de flux. Vous devez exécuter le conteneur Docker avec des options supplémentaires pour utiliser IPC. Pour plus d’informations, consultez les ressources suivantes :

Exemple de recette : Diffuser un fichier vers un compartiment S3 dans un composant de conteneur Docker (Python)

La recette suivante définit un exemple de composant de conteneur Docker qui crée un fichier et le diffuse vers un compartiment S3. Cette recette possède les propriétés suivantes :

  • Le composant du gestionnaire de flux en tant que dépendance. Cette dépendance permet au composant d'utiliser le SDK du gestionnaire de flux pour interagir avec le composant du gestionnaire de flux.

  • Artefact de composant qui spécifie une image Docker en tant qu'archive TAR dans Amazon S3.

  • Script d'installation du cycle de vie qui charge l'image Docker depuis l'archive TAR.

  • Script d'exécution du cycle de vie qui exécute un conteneur Docker à partir de l'image. La commande Docker run comporte les arguments suivants :

    • L'--network=hostargument fournit au conteneur l'accès au réseau hôte, afin que le conteneur puisse se connecter au composant du gestionnaire de flux.

    • Le premier -e argument définit la variable d'AWS_CONTAINER_AUTHORIZATION_TOKENenvironnement requise dans le conteneur Docker.

    • Les -e arguments supplémentaires définissent les variables d'environnement utilisées dans cet exemple.

    • L'-vargument monte le dossier de travail du composant dans le conteneur. Cet exemple crée un fichier dans le dossier de travail pour le télécharger sur Amazon S3 à l'aide du gestionnaire de flux.

    • L'--rmargument nettoie le conteneur à sa sortie.

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