Avis de fin de support : le 7 octobre 2026, AWS le support de. AWS IoT Greengrass Version 1 Après le 7 octobre 2026, vous ne pourrez plus accéder aux AWS IoT Greengrass V1 ressources. Pour plus d'informations, rendez-vous sur [Migrer depuis AWS IoT Greengrass Version 1](https://docs.aws.amazon.com/greengrass/v2/developerguide/migrate-from-v1.html). 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. # Connecteur de déploiement d'applications Docker Le connecteur de déploiement d'applications Greengrass Docker facilite l'exécution de vos images Docker sur un noyau. AWS IoT Greengrass Le connecteur utilise Docker Compose pour démarrer une application Docker multi-conteneur à partir d'un fichier `docker-compose.yml`. Plus précisément, le connecteur exécute des commandes `docker-compose` pour gérer les conteneurs Docker sur un appareil principal (noyau) unique. Pour de plus amples informations, veuillez consulter [Overview of Docker Composer](https://docs.docker.com/compose/) dans la documentation Docker. Le connecteur peut accéder aux images Docker stockées dans des registres de conteneurs Docker, tels qu'Amazon Elastic Container Registry (Amazon ECR), Docker Hub et des registres Docker sécurisés privés. Après avoir déployé le groupe Greengrass, le connecteur extrait les dernières images et démarre les conteneurs Docker. Il exécute la `docker-compose up` commande `docker-compose pull` et. Le connecteur publie ensuite l'état de la commande dans une [rubrique MQTT en sortie](#docker-app-connector-data-output). Il enregistre également des informations d'état concernant l'exécution des conteneurs Docker. Cela vous permet de surveiller les journaux de vos applications sur Amazon CloudWatch. Pour de plus amples informations, veuillez consulter [Surveillance à l'aide de AWS IoT Greengrass journaux](greengrass-logs-overview.md). Le connecteur démarre également les conteneurs Docker à chaque redémarrage du démon Greengrass. Le nombre de conteneurs Docker pouvant s'exécuter sur le noyau dépend de votre matériel. Les conteneurs Docker s'exécutent en dehors du domaine Greengrass sur l'appareil principal (noyau), de sorte qu'ils ne peuvent pas accéder à la communication inter-processus (IPC) du noyau. Cependant, vous pouvez configurer certains canaux de communication avec des composants Greengrass, tels que les fonctions Lambda locales. Pour de plus amples informations, veuillez consulter [Communication avec les conteneurs Docker](#docker-app-connector-communicating). Vous pouvez utiliser le connecteur pour des scénarios tels que l'hébergement d'un serveur web ou d'un serveur MySQL sur votre appareil principal (noyau). Les services locaux de vos applications Docker peuvent communiquer entre eux, avec d'autres processus dans l'environnement local et avec des services cloud. Par exemple, vous pouvez exécuter un serveur Web sur le cœur qui envoie des demandes provenant de fonctions Lambda à un service Web dans le cloud. Ce connecteur s'exécute en mode d'isolation [No container (Aucun conteneur)](lambda-group-config.md#no-container-mode), de sorte que vous pouvez le déployer dans un groupe Greengrass qui s'exécute sans conteneurisation Greengrass. Ce connecteur possède les versions suivantes. | Version | ARN | | --- | --- | | 7 | `arn:aws:greengrass:region::/connectors/DockerApplicationDeployment/versions/7` | | 6 | `arn:aws:greengrass:region::/connectors/DockerApplicationDeployment/versions/6` | | 5 | `arn:aws:greengrass:region::/connectors/DockerApplicationDeployment/versions/5` | | 4 | `arn:aws:greengrass:region::/connectors/DockerApplicationDeployment/versions/4` | | 3 | `arn:aws:greengrass:region::/connectors/DockerApplicationDeployment/versions/3` | | 2 | `arn:aws:greengrass:region::/connectors/DockerApplicationDeployment/versions/2` | | 1 | `arn:aws:greengrass:region::/connectors/DockerApplicationDeployment/versions/1` | Pour obtenir des informations sur les changements apportés aux versions, veuillez consulter le [Journal des modifications](#docker-app-connector-changelog). ## Exigences Ce connecteur possède les critères suivants : + AWS IoT Greengrass Logiciel de base v1.10 ou version ultérieure. **Note** Ce connecteur n'est pas pris en charge sur OpenWrt les distributions. + [Python](https://www.python.org/) version 3.7 ou 3.8 installé sur le périphérique principal et ajouté à la variable d'environnement PATH. **Note** Pour utiliser Python 3.8, exécutez la commande suivante pour créer un lien symbolique entre le dossier d'installation par défaut de Python 3.7 et les fichiers binaires Python 3.8 installés. ``` sudo ln -s path-to-python-3.8/python3.8 /usr/bin/python3.7 ``` Ceci configure votre appareil de sorte qu'il réponde aux exigence de Python pour AWS IoT Greengrass. + Un minimum de 36 Mo de RAM sur le noyau Greengrass pour que le connecteur surveille les conteneurs Docker en cours d'exécution. La mémoire totale requise dépend du nombre de conteneurs Docker qui s'exécutent sur le noyau. + [Docker Engine](https://docs.docker.com/install/) 1.1.9.1 ou version ultérieure installé sur le noyau Greengrass. La version 19.0.3 est la dernière version vérifiée pour fonctionner avec le connecteur. L'exécutable `docker` doit se trouver dans le répertoire `/usr/local/bin` ou `/usr/bin`. **Important** Nous vous recommandons d'installer un magasin d'informations d'identification pour sécuriser les copies locales de vos informations d'identification Docker. Pour de plus amples informations, veuillez consulter [Remarque de sécurité](#docker-app-connector-security). Pour plus d'informations sur l'installation de Docker sur les distributions Amazon Linux, consultez [les bases de Docker pour Amazon ECS dans le manuel Amazon](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/docker-basics.html) *Elastic Container Service Developer Guide*. + [Docker Compose](https://docs.docker.com/compose/install/) installé sur le noyau Greengrass. L'exécutable `docker-compose` doit se trouver dans le répertoire `/usr/local/bin` ou `/usr/bin`. Les versions suivantes de Docker Compose sont vérifiées pour fonctionner avec le connecteur. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/greengrass/v1/developerguide/docker-app-connector.html) + Un seul fichier Docker Compose (par exemple,`docker-compose.yml`), stocké dans Amazon Simple Storage Service (Amazon S3). Le format doit être compatible avec la version de Docker Compose installée sur le noyau. Vous devez tester le fichier avant de l'utiliser sur votre noyau. Si vous modifiez le fichier après avoir déployé le groupe Greengrass, vous devez redéployer le groupe pour mettre à jour votre copie locale sur le noyau. + Un utilisateur Linux autorisé à appeler le démon Docker local et à écrire dans le répertoire qui stocke la copie locale de votre fichier Compose. Pour de plus amples informations, veuillez consulter [Configuration de l'utilisateur Docker sur le noyau](#docker-app-connector-linux-user). + [Rôle de groupe Greengrass](group-role.md) configuré pour autoriser l'action `s3:GetObject` sur le compartiment S3 qui contient votre fichier Compose. Cette autorisation est illustrée dans l'exemple de politique IAM suivant. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "AllowAccessToComposeFileS3Bucket", "Action": [ "s3:GetObject", "s3:GetObjectVersion" ], "Effect": "Allow", "Resource": "arn:aws:s3:::bucket-name/*" } ] } ``` ------ **Note** Si votre compartiment S3 est activé pour la gestion des versions, le rôle doit être configuré pour autoriser également l'`s3:GetObjectVersion`action. Pour plus d'informations, consultez la section [Utilisation du versionnement](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html) dans le *guide de l'utilisateur d'Amazon Simple Storage Service*. Pour l'exigence de rôle de groupe, vous devez configurer le rôle de manière à accorder les autorisations requises et à vous assurer que le rôle a été ajouté au groupe. Pour plus d’informations, consultez [Gestion du rôle de groupe Greengrass (console)](group-role.md#manage-group-role-console) ou [Gestion du rôle de groupe Greengrass (interface de ligne de commande)](group-role.md#manage-group-role-cli). + Si votre fichier Docker Compose fait référence à une image Docker stockée dans Amazon ECR, le [rôle de groupe Greengrass est configuré pour autoriser](group-role.md) ce qui suit : + `ecr:GetDownloadUrlForLayer`et `ecr:BatchGetImage` des actions sur vos référentiels Amazon ECR contenant les images Docker. + Action `ecr:GetAuthorizationToken` sur vos ressources. Les référentiels doivent se trouver dans le même Compte AWS emplacement Région AWS que le connecteur. **Important** Les autorisations associées au rôle de groupe peuvent être assumées par toutes les fonctions et connecteurs Lambda du groupe Greengrass. Pour de plus amples informations, veuillez consulter [Remarque de sécurité](#docker-app-connector-security). Ces autorisations sont affichées dans l'exemple de stratégie suivant. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "AllowGetEcrRepositories", "Effect": "Allow", "Action": [ "ecr:GetDownloadUrlForLayer", "ecr:BatchGetImage" ], "Resource": [ "arn:aws:ecr:us-east-1:123456789012:repository/repository-name" ] }, { "Sid": "AllowGetEcrAuthToken", "Effect": "Allow", "Action": "ecr:GetAuthorizationToken", "Resource": "*" } ] } ``` ------ Pour plus d'informations, consultez les [exemples de politiques de dépôt Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/RepositoryPolicyExamples.html) dans le guide de l'*utilisateur Amazon ECR.* Pour l'exigence de rôle de groupe, vous devez configurer le rôle de manière à accorder les autorisations requises et à vous assurer que le rôle a été ajouté au groupe. Pour plus d’informations, consultez [Gestion du rôle de groupe Greengrass (console)](group-role.md#manage-group-role-console) ou [Gestion du rôle de groupe Greengrass (interface de ligne de commande)](group-role.md#manage-group-role-cli). + Si votre fichier Docker Compose fait référence à une image Docker provenant d'[AWS Marketplace](https://aws.amazon.com/marketplace), le connecteur requiert également le respect des conditions suivantes : + Vous devez être abonné aux produits en AWS Marketplace conteneur. Pour de plus amples informations, veuillez consulter [Rechercher et s'abonner à des produits de conteneur](https://docs.aws.amazon.com/marketplace/latest/buyerguide/buyer-finding-and-subscribing-to-container-products.html) dans le *Guide des abonnés AWS Marketplace *. + AWS IoT Greengrass doit être configuré pour prendre en charge les secrets locaux, comme décrit dans la section [Exigences relatives aux secrets](secrets.md#secrets-reqs). Le connecteur utilise cette fonctionnalité uniquement pour récupérer vos secrets AWS Secrets Manager, et non pour les stocker. + Vous devez créer un secret dans Secrets Manager pour chaque AWS Marketplace registre qui stocke une image Docker référencée dans votre fichier Compose. Pour de plus amples informations, veuillez consulter [Accès aux images Docker à partir de référentiels privés](#access-private-repositories). + Si votre fichier Docker Compose fait référence à une image Docker provenant de référentiels privés dans des registres autres qu'Amazon ECR, tels que Docker Hub, le connecteur répond également aux exigences suivantes : + AWS IoT Greengrass doit être configuré pour prendre en charge les secrets locaux, comme décrit dans la section [Exigences relatives aux secrets](secrets.md#secrets-reqs). Le connecteur utilise cette fonctionnalité uniquement pour récupérer vos secrets AWS Secrets Manager, et non pour les stocker. + Vous devez créer un secret dans Secrets Manager pour chaque dépôt privé qui stocke une image Docker référencée dans votre fichier Compose. Pour de plus amples informations, veuillez consulter [Accès aux images Docker à partir de référentiels privés](#access-private-repositories). + Le démon Docker doit être en cours d'exécution lorsque vous déployez un groupe Greengrass contenant ce connecteur. ### Accès aux images Docker à partir de référentiels privés Si vous utilisez des informations d'identification pour accéder à vos images Docker, vous devez autoriser le connecteur à y accéder. La façon dont vous procédez dépend de l'emplacement de l'image Docker. Pour les images Docker stockées sur Amazon ECR, vous autorisez l'obtention de votre jeton d'autorisation dans le rôle du groupe Greengrass. Pour de plus amples informations, veuillez consulter [Exigences](#docker-app-connector-req). Pour les images Docker stockées dans d'autres référentiels ou registres privés, vous devez créer un secret AWS Secrets Manager pour stocker vos informations de connexion. Cela inclut les images Docker auxquelles vous vous êtes abonné. AWS Marketplace Créez un secret pour chaque référentiel. Si vous mettez à jour vos secrets dans Secrets Manager, les modifications se répercuteront sur le cœur la prochaine fois que vous déploierez le groupe. **Note** Secrets Manager est un service que vous pouvez utiliser pour stocker et gérer en toute sécurité vos informations d'identification, clés et autres secrets dans le AWS Cloud. Pour plus d'informations, voir [Qu'est-ce que c'est AWS Secrets Manager ?](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) dans le *guide de AWS Secrets Manager l'utilisateur*. Chaque secret doit contenir les clés suivantes : | Clé | Valeur | | --- | --- | | `username` | Nom d'utilisateur utilisé pour accéder au référentiel ou au registre. | | `password` | Mot de passe utilisé pour accéder au référentiel ou au registre. | | `registryUrl` | Point de terminaison du registre. Il doit correspondre à l'URL de registre correspondante dans le fichier Compose. | **Note** Pour autoriser AWS IoT Greengrass l'accès à un secret par défaut, le nom du secret doit commencer par *greengrass-*. Sinon, c'est votre rôle de service Greengrass qui doit accorder l'accès. Pour de plus amples informations, veuillez consulter [AWS IoT Greengrass Autoriser l'obtention de valeurs secrètes](secrets.md#secrets-config-service-role). **Pour obtenir les informations de connexion pour les images Docker à partir d' AWS Marketplace** 1. Obtenez votre mot de passe pour les images Docker à AWS Marketplace l'aide de la `aws ecr get-login-password` commande. Pour plus d’informations, consultez [get-login-password](https://docs.aws.amazon.com/cli/latest/reference/ecr/get-login.html) dans la *Référence des commandes de l’AWS CLI *. ``` aws ecr get-login-password ``` 1. Récupérez l'URL de registre pour l'image Docker. Ouvrez le AWS Marketplace site Web et ouvrez la page de lancement du produit conteneur. Sous **Images du conteneur**, choisissez **Afficher les détails de l'image du conteneur** pour localiser le nom d'utilisateur et l'URL du registre. Utilisez le nom d'utilisateur, le mot de passe et l'URL de registre récupérés pour créer un secret pour chaque AWS Marketplace registre qui stocke les images Docker référencées dans votre fichier Compose. **Pour créer des secrets (console)** Dans la AWS Secrets Manager console, choisissez **Autre type de secrets**. Sous **Spécifiez les paires clé/valeur à stocker pour ce secret**, ajoutez des lignes pour `username`, `password` et `registryUrl`. Pour plus d'informations, consultez la section [Création d'un secret de base](https://docs.aws.amazon.com/secretsmanager/latest/userguide/manage_create-basic-secret.html) dans le *guide de AWS Secrets Manager l'utilisateur*. ![\[Création d'un secret avec des clés de nom d'utilisateur (username), de mot de passe (password) et registryUrl.\]](http://docs.aws.amazon.com/fr_fr/greengrass/v1/developerguide/images/connectors/secret-docker-trusted-registry.png) **Pour créer des secrets (interface de ligne de commande)** Dans le AWS CLI, utilisez la `create-secret` commande Secrets Manager, comme indiqué dans l'exemple suivant. Pour plus d'informations, voir [create-secret](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/create-secret.html) dans la référence des *AWS CLI commandes*. ``` aws secretsmanager create-secret --name greengrass-MySecret --secret-string [{"username":"Mary_Major"},{"password":"abc123xyz456"},{"registryUrl":"https://docker.io"}] ``` **Important** Il est de votre responsabilité de sécuriser le répertoire `DockerComposeFileDestinationPath` qui stocke votre fichier Docker Compose et les informations d'identification de vos images Docker provenant de référentiels privés. Pour de plus amples informations, veuillez consulter [Remarque de sécurité](#docker-app-connector-security). ## Parameters Ce connecteur fournit les paramètres suivants : ------ #### [ Version 7 ] `DockerComposeFileS3Bucket` Nom du compartiment S3 contenant votre fichier Docker Compose. Lorsque vous créez le bucket, assurez-vous de suivre les [règles relatives aux noms de bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/BucketRestrictions.html) décrites dans le *guide de l'utilisateur d'Amazon Simple Storage Service*. Nom d'affichage dans la AWS IoT console : **fichier Docker Compose dans S3** Dans la console, la propriété **Docker Compose file in S3 (Fichier Docker Compose dans S3)** combine les paramètres `DockerComposeFileS3Version`, `DockerComposeFileS3Bucket` et `DockerComposeFileS3Key`. Nécessaire : `true` Type : `string` Schéma valide `[a-zA-Z0-9\\-\\.]{3,63}` `DockerComposeFileS3Key` La clé d'objet de votre fichier Docker Compose dans Amazon S3. Pour plus d'informations, notamment les directives de dénomination des clés d'objet, consultez la section [Clé d'objet et métadonnées](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingMetadata.html) dans le *guide de l'utilisateur d'Amazon Simple Storage Service*. Dans la console, la propriété **Docker Compose file in S3 (Fichier Docker Compose dans S3)** combine les paramètres `DockerComposeFileS3Version`, `DockerComposeFileS3Bucket` et `DockerComposeFileS3Key`. Nécessaire : `true` Type : `string` Schéma valide `.+` `DockerComposeFileS3Version` Version d'objet de votre fichier Docker Compose dans Amazon S3. Pour plus d'informations, notamment les directives relatives à la dénomination des clés d'objet, consultez la section [Utilisation du versionnement](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html) dans le *guide de l'utilisateur d'Amazon Simple Storage Service*. Dans la console, la propriété **Docker Compose file in S3 (Fichier Docker Compose dans S3)** combine les paramètres `DockerComposeFileS3Version`, `DockerComposeFileS3Bucket` et `DockerComposeFileS3Key`. Nécessaire : `false` Type : `string` Schéma valide `.+` `DockerComposeFileDestinationPath` Chemin absolu du répertoire local utilisé pour stocker une copie du fichier Docker Compose. Il doit s'agir d'un répertoire existant. L'utilisateur spécifié pour `DockerUserId` doit avoir l'autorisation de créer un fichier dans ce répertoire. Pour de plus amples informations, veuillez consulter [Configuration de l'utilisateur Docker sur le noyau AWS IoT Greengrass](#docker-app-connector-linux-user). Ce répertoire stocke votre fichier Docker Compose et les informations d'identification de vos images Docker provenant de référentiels privés. Il est de votre responsabilité de sécuriser ce répertoire. Pour de plus amples informations, veuillez consulter [Remarque de sécurité](#docker-app-connector-security). Nom d'affichage dans la AWS IoT console : **chemin du répertoire pour le fichier Compose local** Nécessaire : `true` Type : `string` Schéma valide `\/.*\/?` Exemple : `/home/username/myCompose` `DockerUserId` UID de l'utilisateur Linux sous lequel le connecteur s'exécute. Cet utilisateur doit appartenir au groupe Linux `docker` sur l'appareil principal (noyau) et disposer d'autorisations d'écriture dans le répertoire `DockerComposeFileDestinationPath`. Pour de plus amples informations, veuillez consulter [Configuration de l'utilisateur Docker sur le noyau](#docker-app-connector-linux-user). Nous vous recommandons d'éviter l'exécution en tant que racine à moins que cela ne soit absolument nécessaire. Si vous spécifiez l'utilisateur root, vous devez autoriser les fonctions Lambda à s'exécuter en tant que root sur le AWS IoT Greengrass noyau. Pour de plus amples informations, veuillez consulter [Exécution d'une fonction Lambda en tant que root](lambda-group-config.md#lambda-running-as-root). Nom affiché dans la AWS IoT console : ID **utilisateur Docker** Nécessaire : `false` Type : `string` Schéma valide : `^[0-9]{1,5}$` `AWSSecretsArnList` Les Amazon Resource Names (ARNs) des secrets AWS Secrets Manager qui contiennent les informations de connexion utilisées pour accéder à vos images Docker dans des référentiels privés. Pour de plus amples informations, veuillez consulter [Accès aux images Docker à partir de référentiels privés](#access-private-repositories). Nom affiché dans la AWS IoT console : **Informations d'identification pour les référentiels privés** Obligatoire : `false`. Ce paramètre est requis pour accéder aux images Docker stockées dans des référentiels privés. Type : `array` de `string` Modèle valide : `[( ?,? ?"(arn:(aws(-[a-z]+)):secretsmanager:[a-z0-9-]+:[0-9]{12}:secret:([a-zA-Z0-9\]+/)[a-zA-Z0-9/_+=,.@-]+-[a-zA-Z0-9]+)")]` `DockerContainerStatusLogFrequency` Fréquence (en secondes) à laquelle le connecteur enregistre les informations d'état sur les conteneurs Docker en cours d'exécution sur le noyau. La valeur par défaut est de 300 secondes (5 minutes). Nom affiché dans la AWS IoT console : **Fréquence de journalisation** Nécessaire : `false` Type : `string` Modèle valide : `^[1-9]{1}[0-9]{0,3}$` `ForceDeploy` Indique s'il faut forcer le déploiement de Docker en cas d'échec dû au nettoyage incorrect du dernier déploiement. La valeur par défaut est `False`. Nom affiché dans la AWS IoT console : **Forcer le déploiement** Nécessaire : `false` Type : `string` Modèle valide : `^(true|false)$` `DockerPullBeforeUp` Indique si le déployeur doit s'exécuter `docker-compose pull` avant de s'exécuter en raison `docker-compose up` d'un pull-down-up comportement. La valeur par défaut est `True`. Nom affiché dans la AWS IoT console : **Docker Pull Before Up** Nécessaire : `false` Type : `string` Modèle valide : `^(true|false)$` `StopContainersOnNewDeployment` Indique si le connecteur doit arrêter les conteneurs docker gérés par Docker Deployer lorsque GGC est arrêté (GGC s'arrête lorsqu'un nouveau groupe est déployé ou que le noyau est arrêté). La valeur par défaut est `True`. Nom affiché dans la AWS IoT console : **Docker s'arrête lors d'un nouveau déploiement** Nous vous recommandons de conserver la `True` valeur par défaut de ce paramètre. Le paramètre to permet `False` à votre conteneur Docker de continuer à fonctionner même après avoir arrêté le AWS IoT Greengrass noyau ou lancé un nouveau déploiement. Si vous définissez ce paramètre sur`False`, vous devez vous assurer que vos conteneurs Docker sont maintenus si nécessaire en cas de modification ou d'ajout de nom de `docker-compose` service. Pour plus d'informations, consultez la documentation `docker-compose` du fichier de composition. Nécessaire : `false` Type : `string` Modèle valide : `^(true|false)$` `DockerOfflineMode` Indique s'il faut utiliser le fichier Docker Compose existant lors du AWS IoT Greengrass démarrage hors ligne. La valeur par défaut est `False`. Nécessaire : `false` Type : `string` Modèle valide : `^(true|false)$` ------ #### [ Version 6 ] `DockerComposeFileS3Bucket` Nom du compartiment S3 contenant votre fichier Docker Compose. Lorsque vous créez le bucket, assurez-vous de suivre les [règles relatives aux noms de bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/BucketRestrictions.html) décrites dans le *guide de l'utilisateur d'Amazon Simple Storage Service*. Nom d'affichage dans la AWS IoT console : **fichier Docker Compose dans S3** Dans la console, la propriété **Docker Compose file in S3 (Fichier Docker Compose dans S3)** combine les paramètres `DockerComposeFileS3Version`, `DockerComposeFileS3Bucket` et `DockerComposeFileS3Key`. Nécessaire : `true` Type : `string` Schéma valide `[a-zA-Z0-9\\-\\.]{3,63}` `DockerComposeFileS3Key` La clé d'objet de votre fichier Docker Compose dans Amazon S3. Pour plus d'informations, notamment les directives de dénomination des clés d'objet, consultez la section [Clé d'objet et métadonnées](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingMetadata.html) dans le *guide de l'utilisateur d'Amazon Simple Storage Service*. Dans la console, la propriété **Docker Compose file in S3 (Fichier Docker Compose dans S3)** combine les paramètres `DockerComposeFileS3Version`, `DockerComposeFileS3Bucket` et `DockerComposeFileS3Key`. Nécessaire : `true` Type : `string` Schéma valide `.+` `DockerComposeFileS3Version` Version d'objet de votre fichier Docker Compose dans Amazon S3. Pour plus d'informations, notamment les directives relatives à la dénomination des clés d'objet, consultez la section [Utilisation du versionnement](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html) dans le *guide de l'utilisateur d'Amazon Simple Storage Service*. Dans la console, la propriété **Docker Compose file in S3 (Fichier Docker Compose dans S3)** combine les paramètres `DockerComposeFileS3Version`, `DockerComposeFileS3Bucket` et `DockerComposeFileS3Key`. Nécessaire : `false` Type : `string` Schéma valide `.+` `DockerComposeFileDestinationPath` Chemin absolu du répertoire local utilisé pour stocker une copie du fichier Docker Compose. Il doit s'agir d'un répertoire existant. L'utilisateur spécifié pour `DockerUserId` doit avoir l'autorisation de créer un fichier dans ce répertoire. Pour de plus amples informations, veuillez consulter [Configuration de l'utilisateur Docker sur le noyau AWS IoT Greengrass](#docker-app-connector-linux-user). Ce répertoire stocke votre fichier Docker Compose et les informations d'identification de vos images Docker provenant de référentiels privés. Il est de votre responsabilité de sécuriser ce répertoire. Pour de plus amples informations, veuillez consulter [Remarque de sécurité](#docker-app-connector-security). Nom d'affichage dans la AWS IoT console : **chemin du répertoire pour le fichier Compose local** Nécessaire : `true` Type : `string` Schéma valide `\/.*\/?` Exemple : `/home/username/myCompose` `DockerUserId` UID de l'utilisateur Linux sous lequel le connecteur s'exécute. Cet utilisateur doit appartenir au groupe Linux `docker` sur l'appareil principal (noyau) et disposer d'autorisations d'écriture dans le répertoire `DockerComposeFileDestinationPath`. Pour de plus amples informations, veuillez consulter [Configuration de l'utilisateur Docker sur le noyau](#docker-app-connector-linux-user). Nous vous recommandons d'éviter l'exécution en tant que racine à moins que cela ne soit absolument nécessaire. Si vous spécifiez l'utilisateur root, vous devez autoriser les fonctions Lambda à s'exécuter en tant que root sur le AWS IoT Greengrass noyau. Pour de plus amples informations, veuillez consulter [Exécution d'une fonction Lambda en tant que root](lambda-group-config.md#lambda-running-as-root). Nom affiché dans la AWS IoT console : ID **utilisateur Docker** Nécessaire : `false` Type : `string` Modèle valide : `^[0-9]{1,5}$` `AWSSecretsArnList` Les Amazon Resource Names (ARNs) des secrets AWS Secrets Manager qui contiennent les informations de connexion utilisées pour accéder à vos images Docker dans des référentiels privés. Pour de plus amples informations, veuillez consulter [Accès aux images Docker à partir de référentiels privés](#access-private-repositories). Nom affiché dans la AWS IoT console : **Informations d'identification pour les référentiels privés** Obligatoire : `false`. Ce paramètre est requis pour accéder aux images Docker stockées dans des référentiels privés. Type : `array` de `string` Modèle valide : `[( ?,? ?"(arn:(aws(-[a-z]+)):secretsmanager:[a-z0-9-]+:[0-9]{12}:secret:([a-zA-Z0-9\]+/)[a-zA-Z0-9/_+=,.@-]+-[a-zA-Z0-9]+)")]` `DockerContainerStatusLogFrequency` Fréquence (en secondes) à laquelle le connecteur enregistre les informations d'état sur les conteneurs Docker en cours d'exécution sur le noyau. La valeur par défaut est de 300 secondes (5 minutes). Nom affiché dans la AWS IoT console : **Fréquence de journalisation** Nécessaire : `false` Type : `string` Modèle valide : `^[1-9]{1}[0-9]{0,3}$` `ForceDeploy` Indique s'il faut forcer le déploiement de Docker en cas d'échec dû au nettoyage incorrect du dernier déploiement. La valeur par défaut est `False`. Nom affiché dans la AWS IoT console : **Forcer le déploiement** Nécessaire : `false` Type : `string` Modèle valide : `^(true|false)$` `DockerPullBeforeUp` Indique si le déployeur doit s'exécuter `docker-compose pull` avant de s'exécuter en raison `docker-compose up` d'un pull-down-up comportement. La valeur par défaut est `True`. Nom affiché dans la AWS IoT console : **Docker Pull Before Up** Nécessaire : `false` Type : `string` Modèle valide : `^(true|false)$` `StopContainersOnNewDeployment` Indique si le connecteur doit arrêter les conteneurs docker gérés par Docker Deployer lorsque GGC est arrêté (lorsqu'un nouveau déploiement de groupe est effectué ou que le noyau est arrêté). La valeur par défaut est `True`. Nom affiché dans la AWS IoT console : **Docker s'arrête lors d'un nouveau déploiement** Nous vous recommandons de conserver la `True` valeur par défaut de ce paramètre. Le paramètre to permet `False` à votre conteneur Docker de continuer à fonctionner même après avoir arrêté le AWS IoT Greengrass noyau ou lancé un nouveau déploiement. Si vous définissez ce paramètre sur`False`, vous devez vous assurer que vos conteneurs Docker sont maintenus si nécessaire en cas de modification ou d'ajout de nom de `docker-compose` service. Pour plus d'informations, consultez la documentation `docker-compose` du fichier de composition. Nécessaire : `false` Type : `string` Modèle valide : `^(true|false)$` ------ #### [ Version 5 ] `DockerComposeFileS3Bucket` Nom du compartiment S3 contenant votre fichier Docker Compose. Lorsque vous créez le bucket, assurez-vous de suivre les [règles relatives aux noms de bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/BucketRestrictions.html) décrites dans le *guide de l'utilisateur d'Amazon Simple Storage Service*. Nom d'affichage dans la AWS IoT console : **fichier Docker Compose dans S3** Dans la console, la propriété **Docker Compose file in S3 (Fichier Docker Compose dans S3)** combine les paramètres `DockerComposeFileS3Version`, `DockerComposeFileS3Bucket` et `DockerComposeFileS3Key`. Nécessaire : `true` Type : `string` Schéma valide `[a-zA-Z0-9\\-\\.]{3,63}` `DockerComposeFileS3Key` La clé d'objet de votre fichier Docker Compose dans Amazon S3. Pour plus d'informations, notamment les directives de dénomination des clés d'objet, consultez la section [Clé d'objet et métadonnées](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingMetadata.html) dans le *guide de l'utilisateur d'Amazon Simple Storage Service*. Dans la console, la propriété **Docker Compose file in S3 (Fichier Docker Compose dans S3)** combine les paramètres `DockerComposeFileS3Version`, `DockerComposeFileS3Bucket` et `DockerComposeFileS3Key`. Nécessaire : `true` Type : `string` Schéma valide `.+` `DockerComposeFileS3Version` Version d'objet de votre fichier Docker Compose dans Amazon S3. Pour plus d'informations, notamment les directives relatives à la dénomination des clés d'objet, consultez la section [Utilisation du versionnement](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html) dans le *guide de l'utilisateur d'Amazon Simple Storage Service*. Dans la console, la propriété **Docker Compose file in S3 (Fichier Docker Compose dans S3)** combine les paramètres `DockerComposeFileS3Version`, `DockerComposeFileS3Bucket` et `DockerComposeFileS3Key`. Nécessaire : `false` Type : `string` Schéma valide `.+` `DockerComposeFileDestinationPath` Chemin absolu du répertoire local utilisé pour stocker une copie du fichier Docker Compose. Il doit s'agir d'un répertoire existant. L'utilisateur spécifié pour `DockerUserId` doit avoir l'autorisation de créer un fichier dans ce répertoire. Pour de plus amples informations, veuillez consulter [Configuration de l'utilisateur Docker sur le noyau AWS IoT Greengrass](#docker-app-connector-linux-user). Ce répertoire stocke votre fichier Docker Compose et les informations d'identification de vos images Docker provenant de référentiels privés. Il est de votre responsabilité de sécuriser ce répertoire. Pour de plus amples informations, veuillez consulter [Remarque de sécurité](#docker-app-connector-security). Nom d'affichage dans la AWS IoT console : **chemin du répertoire pour le fichier Compose local** Nécessaire : `true` Type : `string` Schéma valide `\/.*\/?` Exemple : `/home/username/myCompose` `DockerUserId` UID de l'utilisateur Linux sous lequel le connecteur s'exécute. Cet utilisateur doit appartenir au groupe Linux `docker` sur l'appareil principal (noyau) et disposer d'autorisations d'écriture dans le répertoire `DockerComposeFileDestinationPath`. Pour de plus amples informations, veuillez consulter [Configuration de l'utilisateur Docker sur le noyau](#docker-app-connector-linux-user). Nous vous recommandons d'éviter l'exécution en tant que racine à moins que cela ne soit absolument nécessaire. Si vous spécifiez l'utilisateur root, vous devez autoriser les fonctions Lambda à s'exécuter en tant que root sur le AWS IoT Greengrass noyau. Pour de plus amples informations, veuillez consulter [Exécution d'une fonction Lambda en tant que root](lambda-group-config.md#lambda-running-as-root). Nom affiché dans la AWS IoT console : ID **utilisateur Docker** Nécessaire : `false` Type : `string` Modèle valide : `^[0-9]{1,5}$` `AWSSecretsArnList` Les Amazon Resource Names (ARNs) des secrets AWS Secrets Manager qui contiennent les informations de connexion utilisées pour accéder à vos images Docker dans des référentiels privés. Pour de plus amples informations, veuillez consulter [Accès aux images Docker à partir de référentiels privés](#access-private-repositories). Nom affiché dans la AWS IoT console : **Informations d'identification pour les référentiels privés** Obligatoire : `false`. Ce paramètre est requis pour accéder aux images Docker stockées dans des référentiels privés. Type : `array` de `string` Modèle valide : `[( ?,? ?"(arn:(aws(-[a-z]+)):secretsmanager:[a-z0-9-]+:[0-9]{12}:secret:([a-zA-Z0-9\]+/)[a-zA-Z0-9/_+=,.@-]+-[a-zA-Z0-9]+)")]` `DockerContainerStatusLogFrequency` Fréquence (en secondes) à laquelle le connecteur enregistre les informations d'état sur les conteneurs Docker en cours d'exécution sur le noyau. La valeur par défaut est de 300 secondes (5 minutes). Nom affiché dans la AWS IoT console : **Fréquence de journalisation** Nécessaire : `false` Type : `string` Modèle valide : `^[1-9]{1}[0-9]{0,3}$` `ForceDeploy` Indique s'il faut forcer le déploiement de Docker en cas d'échec dû au nettoyage incorrect du dernier déploiement. La valeur par défaut est `False`. Nom affiché dans la AWS IoT console : **Forcer le déploiement** Nécessaire : `false` Type : `string` Modèle valide : `^(true|false)$` `DockerPullBeforeUp` Indique si le déployeur doit s'exécuter `docker-compose pull` avant de s'exécuter en raison `docker-compose up` d'un pull-down-up comportement. La valeur par défaut est `True`. Nom affiché dans la AWS IoT console : **Docker Pull Before Up** Nécessaire : `false` Type : `string` Modèle valide : `^(true|false)$` ------ #### [ Versions 2 - 4 ] `DockerComposeFileS3Bucket` Nom du compartiment S3 contenant votre fichier Docker Compose. Lorsque vous créez le bucket, assurez-vous de suivre les [règles relatives aux noms de bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/BucketRestrictions.html) décrites dans le *guide de l'utilisateur d'Amazon Simple Storage Service*. Nom d'affichage dans la AWS IoT console : **fichier Docker Compose dans S3** Dans la console, la propriété **Docker Compose file in S3 (Fichier Docker Compose dans S3)** combine les paramètres `DockerComposeFileS3Version`, `DockerComposeFileS3Bucket` et `DockerComposeFileS3Key`. Nécessaire : `true` Type : `string` Schéma valide `[a-zA-Z0-9\\-\\.]{3,63}` `DockerComposeFileS3Key` La clé d'objet de votre fichier Docker Compose dans Amazon S3. Pour plus d'informations, notamment les directives de dénomination des clés d'objet, consultez la section [Clé d'objet et métadonnées](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingMetadata.html) dans le *guide de l'utilisateur d'Amazon Simple Storage Service*. Dans la console, la propriété **Docker Compose file in S3 (Fichier Docker Compose dans S3)** combine les paramètres `DockerComposeFileS3Version`, `DockerComposeFileS3Bucket` et `DockerComposeFileS3Key`. Nécessaire : `true` Type : `string` Schéma valide `.+` `DockerComposeFileS3Version` Version d'objet de votre fichier Docker Compose dans Amazon S3. Pour plus d'informations, notamment les directives relatives à la dénomination des clés d'objet, consultez la section [Utilisation du versionnement](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html) dans le *guide de l'utilisateur d'Amazon Simple Storage Service*. Dans la console, la propriété **Docker Compose file in S3 (Fichier Docker Compose dans S3)** combine les paramètres `DockerComposeFileS3Version`, `DockerComposeFileS3Bucket` et `DockerComposeFileS3Key`. Nécessaire : `false` Type : `string` Schéma valide `.+` `DockerComposeFileDestinationPath` Chemin absolu du répertoire local utilisé pour stocker une copie du fichier Docker Compose. Il doit s'agir d'un répertoire existant. L'utilisateur spécifié pour `DockerUserId` doit avoir l'autorisation de créer un fichier dans ce répertoire. Pour de plus amples informations, veuillez consulter [Configuration de l'utilisateur Docker sur le noyau AWS IoT Greengrass](#docker-app-connector-linux-user). Ce répertoire stocke votre fichier Docker Compose et les informations d'identification de vos images Docker provenant de référentiels privés. Il est de votre responsabilité de sécuriser ce répertoire. Pour de plus amples informations, veuillez consulter [Remarque de sécurité](#docker-app-connector-security). Nom d'affichage dans la AWS IoT console : **chemin du répertoire pour le fichier Compose local** Nécessaire : `true` Type : `string` Schéma valide `\/.*\/?` Exemple : `/home/username/myCompose` `DockerUserId` UID de l'utilisateur Linux sous lequel le connecteur s'exécute. Cet utilisateur doit appartenir au groupe Linux `docker` sur l'appareil principal (noyau) et disposer d'autorisations d'écriture dans le répertoire `DockerComposeFileDestinationPath`. Pour de plus amples informations, veuillez consulter [Configuration de l'utilisateur Docker sur le noyau](#docker-app-connector-linux-user). Nous vous recommandons d'éviter l'exécution en tant que racine à moins que cela ne soit absolument nécessaire. Si vous spécifiez l'utilisateur root, vous devez autoriser les fonctions Lambda à s'exécuter en tant que root sur le AWS IoT Greengrass noyau. Pour de plus amples informations, veuillez consulter [Exécution d'une fonction Lambda en tant que root](lambda-group-config.md#lambda-running-as-root). Nom affiché dans la AWS IoT console : ID **utilisateur Docker** Nécessaire : `false` Type : `string` Modèle valide : `^[0-9]{1,5}$` `AWSSecretsArnList` Les Amazon Resource Names (ARNs) des secrets AWS Secrets Manager qui contiennent les informations de connexion utilisées pour accéder à vos images Docker dans des référentiels privés. Pour de plus amples informations, veuillez consulter [Accès aux images Docker à partir de référentiels privés](#access-private-repositories). Nom affiché dans la AWS IoT console : **Informations d'identification pour les référentiels privés** Obligatoire : `false`. Ce paramètre est requis pour accéder aux images Docker stockées dans des référentiels privés. Type : `array` de `string` Modèle valide : `[( ?,? ?"(arn:(aws(-[a-z]+)):secretsmanager:[a-z0-9-]+:[0-9]{12}:secret:([a-zA-Z0-9\]+/)[a-zA-Z0-9/_+=,.@-]+-[a-zA-Z0-9]+)")]` `DockerContainerStatusLogFrequency` Fréquence (en secondes) à laquelle le connecteur enregistre les informations d'état sur les conteneurs Docker en cours d'exécution sur le noyau. La valeur par défaut est de 300 secondes (5 minutes). Nom affiché dans la AWS IoT console : **Fréquence de journalisation** Nécessaire : `false` Type : `string` Modèle valide : `^[1-9]{1}[0-9]{0,3}$` `ForceDeploy` Indique s'il faut forcer le déploiement de Docker en cas d'échec dû au nettoyage incorrect du dernier déploiement. La valeur par défaut est `False`. Nom affiché dans la AWS IoT console : **Forcer le déploiement** Nécessaire : `false` Type : `string` Modèle valide : `^(true|false)$` ------ #### [ Version 1 ] `DockerComposeFileS3Bucket` Nom du compartiment S3 contenant votre fichier Docker Compose. Lorsque vous créez le bucket, assurez-vous de suivre les [règles relatives aux noms de bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/BucketRestrictions.html) décrites dans le *guide de l'utilisateur d'Amazon Simple Storage Service*. Nom d'affichage dans la AWS IoT console : **fichier Docker Compose dans S3** Dans la console, la propriété **Docker Compose file in S3 (Fichier Docker Compose dans S3)** combine les paramètres `DockerComposeFileS3Version`, `DockerComposeFileS3Bucket` et `DockerComposeFileS3Key`. Nécessaire : `true` Type : `string` Schéma valide `[a-zA-Z0-9\\-\\.]{3,63}` `DockerComposeFileS3Key` La clé d'objet de votre fichier Docker Compose dans Amazon S3. Pour plus d'informations, notamment les directives de dénomination des clés d'objet, consultez la section [Clé d'objet et métadonnées](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingMetadata.html) dans le *guide de l'utilisateur d'Amazon Simple Storage Service*. Dans la console, la propriété **Docker Compose file in S3 (Fichier Docker Compose dans S3)** combine les paramètres `DockerComposeFileS3Version`, `DockerComposeFileS3Bucket` et `DockerComposeFileS3Key`. Nécessaire : `true` Type : `string` Schéma valide `.+` `DockerComposeFileS3Version` Version d'objet de votre fichier Docker Compose dans Amazon S3. Pour plus d'informations, notamment les directives relatives à la dénomination des clés d'objet, consultez la section [Utilisation du versionnement](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html) dans le *guide de l'utilisateur d'Amazon Simple Storage Service*. Dans la console, la propriété **Docker Compose file in S3 (Fichier Docker Compose dans S3)** combine les paramètres `DockerComposeFileS3Version`, `DockerComposeFileS3Bucket` et `DockerComposeFileS3Key`. Nécessaire : `false` Type : `string` Schéma valide `.+` `DockerComposeFileDestinationPath` Chemin absolu du répertoire local utilisé pour stocker une copie du fichier Docker Compose. Il doit s'agir d'un répertoire existant. L'utilisateur spécifié pour `DockerUserId` doit avoir l'autorisation de créer un fichier dans ce répertoire. Pour de plus amples informations, veuillez consulter [Configuration de l'utilisateur Docker sur le noyau AWS IoT Greengrass](#docker-app-connector-linux-user). Ce répertoire stocke votre fichier Docker Compose et les informations d'identification de vos images Docker provenant de référentiels privés. Il est de votre responsabilité de sécuriser ce répertoire. Pour de plus amples informations, veuillez consulter [Remarque de sécurité](#docker-app-connector-security). Nom d'affichage dans la AWS IoT console : **chemin du répertoire pour le fichier Compose local** Nécessaire : `true` Type : `string` Schéma valide `\/.*\/?` Exemple : `/home/username/myCompose` `DockerUserId` UID de l'utilisateur Linux sous lequel le connecteur s'exécute. Cet utilisateur doit appartenir au groupe Linux `docker` sur l'appareil principal (noyau) et disposer d'autorisations d'écriture dans le répertoire `DockerComposeFileDestinationPath`. Pour de plus amples informations, veuillez consulter [Configuration de l'utilisateur Docker sur le noyau](#docker-app-connector-linux-user). Nous vous recommandons d'éviter l'exécution en tant que racine à moins que cela ne soit absolument nécessaire. Si vous spécifiez l'utilisateur root, vous devez autoriser les fonctions Lambda à s'exécuter en tant que root sur le AWS IoT Greengrass noyau. Pour de plus amples informations, veuillez consulter [Exécution d'une fonction Lambda en tant que root](lambda-group-config.md#lambda-running-as-root). Nom affiché dans la AWS IoT console : ID **utilisateur Docker** Nécessaire : `false` Type : `string` Modèle valide : `^[0-9]{1,5}$` `AWSSecretsArnList` Les Amazon Resource Names (ARNs) des secrets AWS Secrets Manager qui contiennent les informations de connexion utilisées pour accéder à vos images Docker dans des référentiels privés. Pour de plus amples informations, veuillez consulter [Accès aux images Docker à partir de référentiels privés](#access-private-repositories). Nom affiché dans la AWS IoT console : **Informations d'identification pour les référentiels privés** Obligatoire : `false`. Ce paramètre est requis pour accéder aux images Docker stockées dans des référentiels privés. Type : `array` de `string` Modèle valide : `[( ?,? ?"(arn:(aws(-[a-z]+)):secretsmanager:[a-z0-9-]+:[0-9]{12}:secret:([a-zA-Z0-9\]+/)[a-zA-Z0-9/_+=,.@-]+-[a-zA-Z0-9]+)")]` `DockerContainerStatusLogFrequency` Fréquence (en secondes) à laquelle le connecteur enregistre les informations d'état sur les conteneurs Docker en cours d'exécution sur le noyau. La valeur par défaut est de 300 secondes (5 minutes). Nom affiché dans la AWS IoT console : **Fréquence de journalisation** Nécessaire : `false` Type : `string` Modèle valide : `^[1-9]{1}[0-9]{0,3}$` ------ ### Exemple de création de connecteur (AWS CLI) La commande CLI suivante crée une `ConnectorDefinition` version initiale contenant le connecteur de déploiement d'applications Greengrass Docker. ``` aws greengrass create-connector-definition --name MyGreengrassConnectors --initial-version '{ "Connectors": [ { "Id": "MyDockerAppplicationDeploymentConnector", "ConnectorArn": "arn:aws:greengrass:region::/connectors/DockerApplicationDeployment/versions/5", "Parameters": { "DockerComposeFileS3Bucket": "amzn-s3-demo-bucket", "DockerComposeFileS3Key": "production-docker-compose.yml", "DockerComposeFileS3Version": "123", "DockerComposeFileDestinationPath": "/home/username/myCompose", "DockerUserId": "1000", "AWSSecretsArnList": "[\"arn:aws:secretsmanager:region:account-id:secret:greengrass-secret1-hash\",\"arn:aws:secretsmanager:region:account-id:secret:greengrass-secret2-hash\"]", "DockerContainerStatusLogFrequency": "30", "ForceDeploy": "True", "DockerPullBeforeUp": "True" } } ] }' ``` **Note** La fonction Lambda de ce connecteur a un cycle de [vie](lambda-functions.md#lambda-lifecycle) prolongé. ## Données d’entrée Ce connecteur ne nécessite ni n'accepte les données d'entrée. ## Données de sortie Ce connecteur publie l'état de la commande `docker-compose up` sous forme de données de sortie. **Filtre de rubrique dans l'abonnement** `dockerapplicationdeploymentconnector/message/status` **Exemple de sortie : réussite** ``` { "status":"success", "GreengrassDockerApplicationDeploymentStatus":"Successfully triggered docker-compose up", "S3Bucket":"amzn-s3-demo-bucket", "ComposeFileName":"production-docker-compose.yml", "ComposeFileVersion":"123" } ``` **Exemple de sortie : échec** ``` { "status":"fail", "error_message":"description of error", "error":"InvalidParameter" } ``` Le type d'erreur peut être `InvalidParameter` ou `InternalError`. ## Configuration de l'utilisateur Docker sur le noyau AWS IoT Greengrass Le connecteur de déploiement de l'application Greengrass Docker s'exécute sous le nom d'utilisateur que vous spécifiez pour le paramètre. `DockerUserId` Si vous ne spécifiez pas de valeur, le connecteur s'exécute en tant que `ggc_user` (identité d'accès Greengrass par défaut). Pour que le connecteur puisse interagir avec le démon Docker, l'utilisateur Docker doit appartenir au groupe Linux `docker` sur le noyau. L'utilisateur Docker doit également disposer d'autorisations d'écriture dans le répertoire `DockerComposeFileDestinationPath`. C'est à cet emplacement que le connecteur stocke votre fichier `docker-compose.yml` local et les informations d'identification Docker. **Note** Nous vous recommandons de créer un utilisateur Linux au lieu d'utiliser la valeur par défaut `ggc_user`. Sinon, toute fonction Lambda du groupe Greengrass peut accéder au fichier Compose et aux informations d'identification Docker. Nous vous recommandons d'éviter l'exécution en tant que racine à moins que cela ne soit absolument nécessaire. Si vous spécifiez l'utilisateur root, vous devez autoriser les fonctions Lambda à s'exécuter en tant que root sur le AWS IoT Greengrass noyau. Pour de plus amples informations, veuillez consulter [Exécution d'une fonction Lambda en tant que root](lambda-group-config.md#lambda-running-as-root). 1. Créez l’utilisateur. Vous pouvez exécuter la commande `useradd` et inclure l'option facultative `-u` pour attribuer un UID. Par exemple : ``` sudo useradd -u 1234 user-name ``` 1. Ajoutez l'utilisateur au groupe `docker` sur le noyau. Par exemple : ``` sudo usermod -aG docker user-name ``` Pour de plus amples informations, notamment sur la création du groupe `docker`, veuillez consulter [Manage Docker as a non-root user](https://docs.docker.com/install/linux/linux-postinstall/#manage-docker-as-a-non-root-user) dans la documentation Docker. 1. Accordez à l'utilisateur les autorisations en écriture dans le répertoire spécifié pour le paramètre `DockerComposeFileDestinationPath`. Par exemple : 1. Pour définir l'utilisateur en tant que propriétaire du répertoire Cet exemple utilise l'UID de l'étape 1. ``` chown 1234 docker-compose-file-destination-path ``` 1. Pour accorder les autorisations en lecture et en écriture au propriétaire ``` chmod 700 docker-compose-file-destination-path ``` Pour de plus amples informations, veuillez consulter [How To Manage File And Folder Permissions In Linux](https://www.linux.com/tutorials/how-manage-file-and-folder-permissions-linux/) dans la documentation Linux Foundation. 1. Si vous n'avez pas attribué d'UID lors de la création de l'utilisateur, ou si vous avez utilisé un utilisateur existant, exécutez la commande `id` pour rechercher l'UID. ``` id -u user-name ``` Vous utilisez l'UID pour configurer le paramètre `DockerUserId` pour le connecteur. ## Informations d'utilisation Lorsque vous utilisez le connecteur de déploiement d'applications Greengrass Docker, vous devez connaître les informations d'utilisation spécifiques à l'implémentation suivantes. + **Préfixe fixe pour les noms de projets.** Le connecteur ajoute le préfixe `greengrassdockerapplicationdeployment` aux noms des conteneurs Docker qu'il démarre. Le connecteur utilise ce préfixe comme nom de projet dans les commandes `docker-compose` qu'il exécute. + **Comportement de journalisation.** Le connecteur écrit des informations d'état et de dépannage dans un fichier journal. Vous pouvez configurer AWS IoT Greengrass pour envoyer des CloudWatch journaux à Logs et pour écrire des journaux localement. Pour de plus amples informations, veuillez consulter [Journalisation des connecteurs](connectors.md#connectors-logging). Voici le chemin d'accès au journal local du connecteur : ``` /greengrass-root/ggc/var/log/user/region/aws/DockerApplicationDeployment.log ``` Vous devez disposer des autorisations root pour accéder aux journaux locaux. + **Mise à jour des images Docker.** Docker met en cache les images sur l'appareil principal (noyau). Si vous mettez à jour une image Docker et que vous souhaitez propager la modification à l'appareil principal (noyau), assurez-vous de modifier la balise de l'image dans le fichier Compose. Les modifications prennent effet après le déploiement du groupe Greengrass. + **Délai d'attente de 10 minutes pour les opérations de nettoyage.** Lorsque le daemon Greengrass s'arrête lors d'un redémarrage, la `docker-compose down` commande est lancée. Tous les conteneurs Docker disposent d'un maximum de 10 minutes après `docker-compose down` leur lancement pour effectuer toute opération de nettoyage. Si le nettoyage n'est pas terminé dans les 10 minutes, vous devez nettoyer les conteneurs restants manuellement. Pour de plus amples informations, veuillez consulter [docker rm](https://docs.docker.com/engine/reference/commandline/rm/) dans la documentation de l'interface de ligne de commande Docker. + **Exécution de commandes Docker.** Pour résoudre les problèmes, vous pouvez exécuter des commandes Docker dans une fenêtre de terminal sur l'appareil principal (noyau). Par exemple, exécutez la commande suivante pour afficher les conteneurs Docker qui ont été démarrés par le connecteur : ``` docker ps --filter name="greengrassdockerapplicationdeployment" ``` + **ID de ressource réservée.** Le connecteur utilise l'ID `DOCKER_DEPLOYER_SECRET_RESOURCE_RESERVED_ID_index` pour les ressources Greengrass qu'il crée dans le groupe Greengrass. La ressource IDs doit être unique dans le groupe. N'attribuez donc pas d'ID de ressource susceptible d'entrer en conflit avec cet ID de ressource réservé. + **Mode hors ligne.** Lorsque vous définissez le paramètre de `DockerOfflineMode` configuration sur`True`, le connecteur Docker peut fonctionner en *mode hors ligne*. Cela peut se produire lorsqu'un déploiement de groupe Greengrass redémarre alors que l'appareil principal est hors ligne et que le connecteur ne peut pas établir de connexion avec Amazon S3 ou Amazon ECR pour récupérer le fichier Docker Compose. Lorsque le mode hors ligne est activé, le connecteur tente de télécharger votre fichier Compose et d'exécuter des `docker login` commandes comme il le ferait pour un redémarrage normal. Si ces tentatives échouent, le connecteur recherche un fichier Compose stocké localement dans le dossier spécifié à l'aide du `DockerComposeFileDestinationPath` paramètre. S'il existe un fichier Compose local, le connecteur suit la séquence normale de `docker-compose` commandes et extrait des images locales. Si le fichier Compose ou les images locales ne sont pas présents, le connecteur échoue. Le comportement des `StopContainersOnNewDeployment` paramètres `ForceDeploy` et reste le même en mode hors ligne. ## Communication avec les conteneurs Docker AWS IoT Greengrass prend en charge les canaux de communication suivants entre les composants Greengrass et les conteneurs Docker : + Les fonctions Greengrass Lambda peuvent utiliser REST APIs pour communiquer avec les processus dans les conteneurs Docker. Vous pouvez configurer un serveur dans un conteneur Docker qui ouvre un port. Les fonctions Lambda peuvent communiquer avec le conteneur sur ce port. + Les processus dans les conteneurs Docker peuvent échanger des messages MQTT via le courtier de messages Greengrass local. Vous pouvez configurer le conteneur Docker en tant qu'appareil client dans le groupe Greengrass, puis créer des abonnements pour permettre au conteneur de communiquer avec les fonctions Lambda de Greengrass, les appareils clients et les autres connecteurs du groupe, AWS IoT ou avec le service parallèle local. Pour de plus amples informations, veuillez consulter [Configurer la communication MQTT avec les conteneurs Docker](#docker-app-connector-mqtt-communication). + Les fonctions Greengrass Lambda peuvent mettre à jour un fichier partagé pour transmettre des informations aux conteneurs Docker. Vous pouvez utiliser le fichier Compose pour effectuer un montage lié du chemin d'accès du fichier partagé pour un conteneur Docker. ### Configurer la communication MQTT avec les conteneurs Docker Vous pouvez configurer un conteneur Docker en tant que périphérique client et l'ajouter à un groupe Greengrass. Ensuite, vous pouvez créer des abonnements permettant la communication MQTT entre le conteneur Docker et les composants Greengrass ou AWS IoT. Dans la procédure suivante, vous créez un abonnement qui permet à l'appareil du conteneur Docker de recevoir des messages de mise à jour shadow à partir du service shadow local. Vous pouvez suivre ce modèle pour créer d'autres abonnements. **Note** Cette procédure suppose que vous avez déjà créé un groupe Greengrass et un noyau Greengrass (v1.10 ou version ultérieure). Pour plus d'informations sur la création d'un groupe et d'un noyau Greengrass, consultez. [Commencer avec AWS IoT Greengrass](gg-gs.md) **Pour configurer un conteneur Docker en tant qu'appareil client et l'ajouter à un groupe Greengrass** 1. Créez un dossier sur l'appareil principal pour stocker les certificats et les clés utilisés pour authentifier l'appareil Greengrass. Le chemin d'accès du fichier doit être monté sur le conteneur Docker que vous souhaitez démarrer. L'extrait suivant montre comment monter un chemin d'accès de fichier dans votre fichier Compose. Dans cet exemple, *path-to-device-certs* représente le dossier que vous avez créé à cette étape. ``` version: '3.3' services: myService: image: user-name/repo:image-tag volumes: - /path-to-device-certs/:/path-accessible-in-container ``` 1. Dans le volet de navigation de la AWS IoT console, sous **Gérer**, développez les **appareils Greengrass**, puis choisissez **Groups (V1)**. 1. Choisissez le groupe cible. 1. Sur la page de configuration du groupe, choisissez **Appareils clients**, puis sélectionnez **Associer**. 1. Dans le mode **Associer un appareil client à ce groupe**, choisissez **Create new AWS IoT thing**. La page **Créer des objets** s'ouvre dans un nouvel onglet. 1. Sur la page **Créer des objets**, choisissez **Créer un objet unique**, puis cliquez sur **Suivant**. 1. Sur la page **Spécifier les propriétés de l'objet**, entrez le nom de l'appareil, puis choisissez **Suivant**. 1. Sur la page **Configurer le certificat de l'appareil**, choisissez **Next**. 1. Sur la page **Attacher des politiques au certificat**, effectuez l'une des opérations suivantes : + Sélectionnez une politique existante qui accorde les autorisations requises par les appareils clients, puis choisissez **Create thing**. Un modal s'ouvre dans lequel vous pouvez télécharger les certificats et les clés que l'appareil utilise pour se connecter au AWS Cloud et au noyau. + Créez et joignez une nouvelle politique qui accorde des autorisations aux appareils clients. Procédez comme suit : 1. Choisissez **Create Policy** (Créer une politique). La page **Créer une stratégie** s'ouvre dans un nouvel onglet. 1. Sur la page **Create policy** (Créer une stratégie), procédez comme suit : 1. Dans **Nom de la stratégie**, entrez un nom qui décrit la stratégie, tel que**GreengrassV1ClientDevicePolicy**. 1. Dans l'onglet **Déclarations de politique**, sous **Document de stratégie**, sélectionnez **JSON**. 1. Entrez le document de politique suivant. Cette politique permet à l'appareil client de découvrir les cœurs de Greengrass et de communiquer sur tous les sujets MQTT. Pour plus d'informations sur la façon de restreindre l'accès à cette politique, consultez[Authentification et autorisation de l'appareil pour AWS IoT Greengrass](device-auth.md). ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "iot:Publish", "iot:Subscribe", "iot:Connect", "iot:Receive" ], "Resource": [ "*" ] }, { "Effect": "Allow", "Action": [ "greengrass:*" ], "Resource": [ "*" ] } ] } ``` ------ 1. Choisissez **Create (Créer)** pour créer la politique. 1. Retournez à l'onglet du navigateur avec la page **Joindre les politiques au certificat** ouverte. Procédez comme suit : 1. Dans la liste des **politiques**, sélectionnez la politique que vous avez créée, telle que **GreengrassV1ClientDevicePolicy**. Si vous ne voyez pas la politique, cliquez sur le bouton d'actualisation. 1. Choisissez **Créer objet**. Un modal s'ouvre dans lequel vous pouvez télécharger les certificats et les clés que l'appareil utilise pour se connecter au AWS Cloud et au noyau. 1. Dans le modal **Télécharger les certificats et les clés**, téléchargez les certificats de l'appareil. **Important** Avant de choisir **OK**, téléchargez les ressources de sécurité. Procédez comme suit : 1. Pour le **certificat de l'appareil**, choisissez **Télécharger** pour télécharger le certificat de l'appareil. 1. Pour **le fichier de clé publique**, choisissez **Télécharger** pour télécharger la clé publique du certificat. 1. Pour **Fichier de clé privée**, choisissez **Télécharger** pour télécharger le fichier de clé privée pour le certificat. 1. Passez en revue [l'authentification du serveur](https://docs.aws.amazon.com/iot/latest/developerguide/server-authentication.html) dans le *guide du AWS IoT développeur* et choisissez le certificat CA racine approprié. Nous vous recommandons d'utiliser les points de terminaison Amazon Trust Services (ATS) et les certificats CA racine ATS. Sous **Certificats de l'autorité de certification racine**, choisissez **Télécharger** pour un certificat de l'autorité de certification racine. 1. Sélectionnez **Exécuté**. Notez l'ID de certificat commun aux noms de fichiers du certificat et des clés de l'appareil. Vous en aurez besoin ultérieurement. 1. Copiez les certificats et les clés dans le dossier que vous avez créé à l'étape 1. Ensuite, créez un abonnement dans le groupe. Pour cet exemple, vous créez un abonnement qui permet à l'appareil du conteneur Docker de recevoir des messages MQTT à partir du service shadow local. **Note** La taille maximale d'un document shadow est de 8 Ko. Pour plus d'informations, consultez la section sur [AWS IoT les quotas](https://docs.aws.amazon.com/iot/latest/developerguide/limits-iot.html) dans le *guide du AWS IoT développeur*. **Pour créer un abonnement permettant à l'appareil de conteneur Docker de recevoir des messages MQTT du service shadow local** 1. Sur la page de configuration du groupe, choisissez l'onglet **Abonnements**, puis choisissez **Ajouter un abonnement**. 1. Sur la page **Sélectionnez la source et la cible**, configurez la source et la cible comme suit : 1. Dans **Sélectionner une source**, choisissez **Services**, puis **Service shadow local**. 1. Pour **Sélectionnez une cible**, choisissez **Appareils**, puis choisissez votre appareil. 1. Choisissez **Suivant**. 1. Sur la page **Filtrer vos données à l'aide d'une rubrique****, dans Filtrer** par rubrique**\$1aws/things/*MyDockerDevice*/shadow/update/accepted**, sélectionnez, puis cliquez sur **Suivant**. *MyDockerDevice*Remplacez-le par le nom de l'appareil que vous avez créé précédemment. 1. Choisissez **Finish** (Terminer). Incluez l'extrait de code suivant dans l'image Docker que vous référencez dans votre fichier Compose. C'est le code de l'appareil Greengrass. Ajoutez également du code dans votre conteneur Docker pour démarrer l'appareil Greengrass à l'intérieur du conteneur. Il peut s'exécuter comme un processus distinct dans l'image ou dans un thread distinct. ``` import os import sys import time import uuid from AWSIoTPythonSDK.core.greengrass.discovery.providers import DiscoveryInfoProvider from AWSIoTPythonSDK.exception.AWSIoTExceptions import DiscoveryInvalidRequestException from AWSIoTPythonSDK.MQTTLib import AWSIoTMQTTClient # Replace thingName with the name you registered for the Docker device. thingName = "MyDockerDevice" clientId = thingName # Replace host with the IoT endpoint for your &AWS-account;. host = "myPrefix.iot.region.amazonaws.com" # Replace topic with the topic where the Docker container subscribes. topic = "$aws/things/MyDockerDevice/shadow/update/accepted" # Replace these paths based on the download location of the certificates for the Docker container. rootCAPath = "/path-accessible-in-container/AmazonRootCA1.pem" certificatePath = "/path-accessible-in-container/certId-certificate.pem.crt" privateKeyPath = "/path-accessible-in-container/certId-private.pem.key" # Discover Greengrass cores. discoveryInfoProvider = DiscoveryInfoProvider() discoveryInfoProvider.configureEndpoint(host) discoveryInfoProvider.configureCredentials(rootCAPath, certificatePath, privateKeyPath) discoveryInfoProvider.configureTimeout(10) # 10 seconds. GROUP_CA_PATH = "./groupCA/" MQTT_QOS = 1 discovered = False groupCA = None coreInfo = None try: # Get discovery info from AWS IoT. discoveryInfo = discoveryInfoProvider.discover(thingName) caList = discoveryInfo.getAllCas() coreList = discoveryInfo.getAllCores() # Use first discovery result. groupId, ca = caList[0] coreInfo = coreList[0] # Save the group CA to a local file. groupCA = GROUP_CA_PATH + groupId + "_CA_" + str(uuid.uuid4()) + ".crt" if not os.path.exists(GROUP_CA_PATH): os.makedirs(GROUP_CA_PATH) groupCAFile = open(groupCA, "w") groupCAFile.write(ca) groupCAFile.close() discovered = True except DiscoveryInvalidRequestException as e: print("Invalid discovery request detected!") print("Type: %s" % str(type(e))) print("Error message: %s" % str(e)) print("Stopping...") except BaseException as e: print("Error in discovery!") print("Type: %s" % str(type(e))) print("Error message: %s" % str(e)) print("Stopping...") myAWSIoTMQTTClient = AWSIoTMQTTClient(clientId) myAWSIoTMQTTClient.configureCredentials(groupCA, privateKeyPath, certificatePath) # Try to connect to the Greengrass core. connected = False for connectivityInfo in coreInfo.connectivityInfoList: currentHost = connectivityInfo.host currentPort = connectivityInfo.port myAWSIoTMQTTClient.configureEndpoint(currentHost, currentPort) try: myAWSIoTMQTTClient.connect() connected = True except BaseException as e: print("Error in connect!") print("Type: %s" % str(type(e))) print("Error message: %s" % str(e)) if connected: break if not connected: print("Cannot connect to core %s. Exiting..." % coreInfo.coreThingArn) sys.exit(-2) # Handle the MQTT message received from GGShadowService. def customCallback(client, userdata, message): print("Received an MQTT message") print(message) # Subscribe to the MQTT topic. myAWSIoTMQTTClient.subscribe(topic, MQTT_QOS, customCallback) # Keep the process alive to listen for messages. while True: time.sleep(1) ``` ## Remarque de sécurité Lorsque vous utilisez le connecteur de déploiement d'applications Greengrass Docker, tenez compte des considérations de sécurité suivantes. **Stockage local du fichier Docker Compose** Le connecteur stocke une copie de votre fichier Compose dans le répertoire spécifié pour le paramètre `DockerComposeFileDestinationPath`. Il est de votre responsabilité de sécuriser ce répertoire. Vous devez utiliser les autorisations du système de fichiers pour restreindre l'accès au répertoire. **Stockage local des informations d'identification Docker** Si vos images Docker sont stockées dans des référentiels privés, le connecteur stocke vos informations d'identification Docker dans le répertoire spécifié pour le paramètre `DockerComposeFileDestinationPath`. Il est de votre responsabilité de sécuriser ces informations d'identification. Par exemple, vous devez utiliser l'[assistant des informations d'identification (credential-helper)](https://docs.docker.com/engine/reference/commandline/login/#credentials-store) sur l'appareil principal (noyau) lorsque vous installez Docker Engine. **Installation de Docker Engine à partir d'une source fiable** Il est de votre responsabilité d'installer Docker Engine à partir d'une source fiable. Ce connecteur utilise le démon Docker sur l'appareil principal (noyau) pour accéder à vos ressources Docker et gérer les conteneurs Docker. **Portée des autorisations de rôle de groupe Greengrass** Les autorisations que vous ajoutez dans le rôle de groupe Greengrass peuvent être assumées par toutes les fonctions et connecteurs Lambda du groupe Greengrass. Ce connecteur nécessite l'accès à votre fichier Docker Compose stocké dans un compartiment S3. Cela nécessite également l'accès à votre jeton d'autorisation Amazon ECR si vos images Docker sont stockées dans un référentiel privé sur Amazon ECR. ## Licences Le connecteur de déploiement d'applications Greengrass Docker inclut les logiciels/licences tiers suivants : + [AWS SDK pour Python (Boto3)](https://pypi.org/project/boto3/)/Licence Apache 2.0 + [botocore](https://pypi.org/project/botocore/)/Licence Apache 2.0 + [dateutil](https://pypi.org/project/python-dateutil/1.4/)/Licence PSF + [docutils](https://pypi.org/project/docutils/)/Licence BSD, licence GPL (General Public License) GNU, licence Python Software Foundation, domaine public + [jmespath](https://pypi.org/project/jmespath/)/Licence MIT + [s3transfer](https://pypi.org/project/s3transfer/)/Licence Apache 2.0 + [urllib3](https://pypi.org/project/urllib3/)/Licence MIT Ce connecteur est publié dans le cadre du contrat de [licence logicielle Greengrass Core](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf). ## Journal des modifications Le tableau suivant décrit les modifications apportées à chaque version du connecteur. | Version | Modifications | | --- | --- | | 7 | Ajouté `DockerOfflineMode` pour utiliser un fichier Docker Compose existant lors d'un AWS IoT Greengrass démarrage hors ligne. Rétentatives implémentées pour la `docker login` commande. Support pour 32 bits. UIDs | | 6 | Ajouté `StopContainersOnNewDeployment` pour annuler le nettoyage des conteneurs lorsqu'un nouveau déploiement est effectué ou que GGC s'arrête. Mécanismes d'arrêt et de démarrage plus sûrs. Correction d'un bogue de validation YAML. | | 5 | Les images sont extraites avant de courir`docker-compose down`. | | 4 | Ajout d' pull-before-upun comportement pour mettre à jour les images Docker. | | 3 | Correction d'un problème lié à la recherche des variables d'environnement. | | 2 | Ajout du paramètre `ForceDeploy`. | | 1 | Première version. | Un groupe Greengrass ne peut contenir qu'une seule version du connecteur à la fois. Pour de plus amples informations sur la mise à niveau d'une version de connecteur, veuillez consulter [Mise à niveau des versions du connecteur](connectors.md#upgrade-connector-versions). ## Consultez aussi + [Intégrer à des services et protocoles à l'aide de connecteurs Greengrass](connectors.md) + [Mise en route avec les connecteurs Greengrass (console)](connectors-console.md) + [Démarrage avec les connecteurs Greengrass (CLI)](connectors-cli.md)