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.
# Créer des déploiements en bloc pour des groupes
Vous pouvez utiliser de simples appels d'API pour déployer un grand nombre de groupes Greengrass à la fois. Ces déploiements sont déclenchés avec une vitesse de transmission adaptative qui possède une limite supérieure fixe.
Ce didacticiel explique comment utiliser le AWS CLI pour créer et surveiller un déploiement de groupe en masse dans AWS IoT Greengrass. L'exemple de déploiement en bloc dans ce tutoriel contient plusieurs groupes. Vous pouvez utiliser l'exemple dans votre implémentation pour ajouter autant de groupes que nécessaire.
Le didacticiel contient les étapes détaillées suivantes :
1. [Créer et charger le fichier d'entrée du déploiement en bloc](#bulk-deploy-cli-create-input-file)
1. [Création et configuration d'un rôle d'exécution IAM pour les déploiements en masse](#bulk-deploy-cli-create-role)
1. [Autoriser votre rôle d'exécution à accéder à votre compartiment S3](#bulk-deploy-cli-modify-bucket)
1. [Déployer les groupes](#bulk-deploy-cli-start-bulk-deployments)
1. [Test du déploiement](#bulk-deploy-cli-test)
## Conditions préalables
Pour suivre ce didacticiel, vous devez disposer des éléments suivants :
+ Un ou plusieurs groupes Greengrass déployables. Pour plus d'informations sur la création des groupes et des noyaux AWS IoT Greengrass , consultez [Commencer avec AWS IoT Greengrass](gg-gs.md).
+ Ils AWS CLI sont installés et configurés sur votre machine. Pour plus d'informations, consultez le [Guide de l'utilisateur AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html).
+ Un compartiment S3 créé de la même manière Région AWS que AWS IoT Greengrass. Pour plus d'informations, consultez [la section Création et configuration d'un compartiment S3](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/create-configure-bucket.html) dans le *guide de l'utilisateur d'Amazon Simple Storage Service*.
**Note**
Actuellement, les compartiments activés SSE KMS ne sont pas pris en charge.
## Étape 1 : Créer et charger le fichier d'entrée du déploiement en bloc
Au cours de cette étape, vous créez un fichier d'entrée de déploiement et vous le chargez dans votre compartiment Amazon S3. Ce fichier est un fichier JSON sérialisé, délimité par des lignes, qui contient des informations sur chaque groupe de votre déploiement en masse. AWS IoT Greengrass utilise ces informations pour déployer chaque groupe en votre nom lorsque vous initialisez le déploiement de votre groupe en masse.
1. Exécutez la commande suivante pour obtenir l'`groupId` de chaque groupe que vous souhaitez déployer. Vous entrez l'`groupId` dans votre fichier d'entrée de déploiement en bloc de telle sorte que AWS IoT Greengrass puisse identifier chaque groupe à déployer.
**Note**
Vous pouvez également trouver ces valeurs dans la AWS IoT console. L'ID du groupe s'affiche sur la page **Paramètres** du groupe. IDs Les versions du groupe sont affichées dans l'onglet **Déploiements** du groupe.
```
aws greengrass list-groups
```
La réponse contient des informations sur chaque groupe de votre AWS IoT Greengrass compte :
```
{
"Groups": [
{
"Name": "string",
"Id": "string",
"Arn": "string",
"LastUpdatedTimestamp": "string",
"CreationTimestamp": "string",
"LatestVersion": "string",
"LatestVersionArn": "string"
}
],
"NextToken": "string"
}
```
Exécutez la commande suivante pour obtenir l'`groupVersionId` de chaque groupe que vous souhaitez déployer.
```
list-group-versions --group-id groupId
```
La réponse contient des informations sur toutes les versions du groupe. Notez la `Version` valeur de la version de groupe que vous souhaitez utiliser.
```
{
"Versions": [
{
"Arn": "string",
"Id": "string",
"Version": "string",
"CreationTimestamp": "string"
}
],
"NextToken": "string"
}
```
1. Dans le terminal de votre ordinateur ou dans l'éditeur de votre choix, créez un fichier*MyBulkDeploymentInputFile*, à partir de l'exemple suivant. Ce fichier contient des informations sur chaque AWS IoT Greengrass groupe à inclure dans un déploiement en masse. Bien que cet exemple définisse plusieurs groupes, pour ce didacticiel, votre fichier peut en contenir un seul.
**Note**
La taille de ce fichier doit être inférieure à 100 Mo.
```
{"GroupId":"groupId1", "GroupVersionId":"groupVersionId1", "DeploymentType":"NewDeployment"}
{"GroupId":"groupId2", "GroupVersionId":"groupVersionId2", "DeploymentType":"NewDeployment"}
{"GroupId":"groupId3", "GroupVersionId":"groupVersionId3", "DeploymentType":"NewDeployment"}
...
```
Chaque enregistrement (ou ligne) contient un objet de groupe. Chaque objet de groupe contient son `GroupId` et `GroupVersionId` correspondants et un `DeploymentType`. Actuellement, ne AWS IoT Greengrass prend en charge que les types de déploiement `NewDeployment` en masse.
Enregistrez et fermez votre fichier. Prenez note de l'emplacement du fichier.
1. Utilisez la commande suivante dans votre terminal pour télécharger votre fichier d'entrée dans votre compartiment Amazon S3. Remplacez le chemin de fichier par l'emplacement et le nom de votre fichier. Pour de plus amples informations, veuillez consulter [Ajouter un objet à un compartiment](https://docs.aws.amazon.com/AmazonS3/latest/gsg/PuttingAnObjectInABucket.html).
```
aws s3 cp path/MyBulkDeploymentInputFile s3://amzn-s3-demo-bucket/
```
## Étape 2 : Créer et configurer un rôle d'exécution IAM
Au cours de cette étape, vous allez utiliser la console IAM pour créer un rôle d'exécution autonome. Vous établissez ensuite une relation de confiance entre le rôle AWS IoT Greengrass et vous vous assurez que votre utilisateur IAM dispose de `PassRole` privilèges pour votre rôle d'exécution. Cela vous permet AWS IoT Greengrass d'assumer votre rôle d'exécution et de créer les déploiements en votre nom.
1. Utilisez la stratégie suivante pour créer un rôle d'exécution. Ce document de stratégie permet à AWS IoT Greengrass d'accéder à votre fichier d'entrée de déploiement en bloc lorsqu'il crée chaque déploiement en votre nom.
Pour de plus amples informations sur la création d'un rôle IAM et la délégation des autorisations, veuillez consulter [Création de rôles IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create.html).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": "greengrass:CreateDeployment",
"Resource": [
"arn:aws:greengrass:us-east-1:123456789012:/greengrass/groups/groupId1",
"arn:aws:greengrass:us-east-1:123456789012:/greengrass/groups/groupId2",
"arn:aws:greengrass:us-east-1:123456789012:/greengrass/groups/groupId3"
]
}
]
}
```
------
**Note**
Cette stratégie doit avoir une ressource pour chaque groupe ou version de groupe dans votre fichier d'entrée de déploiement en bloc pour être déployée par AWS IoT Greengrass. Pour autoriser l'accès à tous les groupes, spécifiez un astérisque pour `Resource` :
```
"Resource": ["*"]
```
1. Modifiez la relation d'approbation pour votre rôle d'exécution pour inclure AWS IoT Greengrass. Cela permet à AWS IoT Greengrass d'utiliser votre rôle d'exécution et les autorisations attachées à celui-ci. Pour de plus amples informations, veuillez consulter [Modification de la relation d'approbation pour un rôle existant](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/edit_trust.html).
Nous vous recommandons également d'inclure les clés `aws:SourceArn` contextuelles et les clés de contexte de condition `aws:SourceAccount` globale dans votre politique de confiance afin d'éviter tout problème *de sécurité secondaire confus*. Les clés contextuelles de condition limitent l'accès pour autoriser uniquement les demandes provenant du compte spécifié et de l'espace de travail Greengrass. Pour de plus amples informations sur le problème de l’adjoint confus, veuillez consulter [Prévention du problème de l’adjoint confus entre services](cross-service-confused-deputy-prevention.md).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": "greengrass.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceAccount": "123456789012"
},
"ArnLike": {
"aws:SourceArn": "arn:aws:greengrass:us-east-1:123456789012:*"
}
}
}
]
}
```
------
1. Donnez des `PassRole` autorisations IAM pour votre rôle d'exécution à votre utilisateur IAM. Cet utilisateur IAM est celui utilisé pour lancer le déploiement en masse. `PassRole`les autorisations permettent à votre utilisateur IAM de transmettre votre rôle d'exécution à des AWS IoT Greengrass fins d'utilisation. Pour plus d'informations, consultez la section [Accorder à un utilisateur l'autorisation de transmettre un rôle à un AWS service](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_passrole.html).
Utilisez l'exemple suivant pour mettre à jour la politique IAM associée à votre rôle d'exécution. Modifiez cet exemple, si nécessaire.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "Stmt1508193814000",
"Effect": "Allow",
"Action": [
"iam:PassRole"
],
"Resource": [
"arn:aws:iam::123456789012:user/executionRoleArn"
],
"Condition": {
"StringEquals": {
"iam:PassedToService": "greengrass.amazonaws.com"
}
}
}
]
}
```
------
## Étape 3 : Autoriser votre rôle d'exécution à accéder à votre compartiment S3
Pour démarrer votre déploiement en masse, votre rôle d'exécution doit être capable de lire le fichier d'entrée du déploiement en masse depuis votre compartiment Amazon S3. Associez l'exemple de politique suivant à votre compartiment Amazon S3 afin que ses `GetObject` autorisations soient accessibles à votre rôle d'exécution.
Pour de plus amples informations, veuillez consulter [Comment ajouter une stratégie de compartiment S3 ?](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/add-bucket-policy.html)
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "examplePolicy",
"Statement": [
{
"Sid": "Stmt1535408982966",
"Effect": "Allow",
"Principal": {
"AWS": [
"executionRoleArn"
]
},
"Action": "s3:GetObject",
"Resource":
"arn:aws:s3:::amzn-s3-demo-bucket/objectKey"
}
]
}
```
------
Vous pouvez utiliser la commande suivante dans votre terminal pour vérifier votre stratégie de compartiment :
```
aws s3api get-bucket-policy --bucket amzn-s3-demo-bucket
```
**Note**
Vous pouvez directement modifier votre rôle d'exécution pour lui accorder plutôt l'autorisation d'accéder aux `GetObject` autorisations de votre compartiment Amazon S3. Pour ce faire, attachez l'exemple de stratégie suivant à votre rôle d'exécution.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": "s3:GetObject",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/objectKey"
}
]
}
```
## Étape 4 : Déployer les groupes
Au cours de cette étape, vous allez lancer une opération de déploiement en bloc pour toutes les versions de groupe configurées dans votre fichier d'entrée de déploiement en bloc. L'action de déploiement pour chacune de vos versions de groupe est de type `NewDeploymentType`.
**Note**
Il n'est pas possible d'appeler **StartBulkDeployment** pendant qu'un autre déploiement en bloc à partir du même compte est encore en cours d'exécution. La demande est rejetée.
1. Pour démarrer le déploiement en bloc, utilisez la commande suivante :
Nous vous recommandons d'inclure un jeton `X-Amzn-Client-Token` dans chaque demande **StartBulkDeployment**. Ces demandes sont idempotentes en ce qui concerne le jeton et les paramètres de demande. Ce jeton peut être n'importe quel caractère unique, sensible à la casse et peut contenir un maximum de 64 caractères ASCII.
```
aws greengrass start-bulk-deployment --cli-input-json "{
"InputFileUri":"URI of file in S3 bucket",
"ExecutionRoleArn":"ARN of execution role",
"AmznClientToken":"your Amazon client token"
}"
```
La commande doit entraîner la réussite de code de statut `200`, ainsi que la réponse suivante :
```
{
"bulkDeploymentId": UUID
}
```
Prenez note de l'ID de déploiement en bloc. Il peut être utilisé pour vérifier le statut de votre déploiement en bloc.
**Note**
Bien que les opérations de déploiement groupé ne soient pas prises en charge actuellement, vous pouvez créer des règles d' EventBridge événements Amazon pour recevoir des notifications concernant les modifications de statut de déploiement pour des groupes individuels. Pour de plus amples informations, veuillez consulter [Obtention des notifications de déploiement](deployment-notifications.md).
1. Utilisez la commande suivante pour vérifier le statut de votre déploiement en bloc.
```
aws greengrass get-bulk-deployment-status --bulk-deployment-id 1234567
```
La commande doit retourner un code de statut réussi `200` en plus d'une charge utile JSON d'informations :
```
{
"BulkDeploymentStatus": Running,
"Statistics": {
"RecordsProcessed": integer,
"InvalidInputRecords": integer,
"RetryAttempts": integer
},
"CreatedAt": "string",
"ErrorMessage": "string",
"ErrorDetails": [
{
"DetailedErrorCode": "string",
"DetailedErrorMessage": "string"
}
]
}
```
`BulkDeploymentStatus` contient le statut actuel de l'exécution en bloc. L'exécution peut avoir l'un des six statuts suivants :
+ `Initializing`. La demande de déploiement groupé a été reçue et l'exécution est sur le point de démarrer.
+ `Running`. L'exécution du déploiement groupé a commencé.
+ `Completed`. L'exécution du déploiement en masse a terminé le traitement de tous les enregistrements.
+ `Stopping`. L'exécution du déploiement en masse a reçu une commande d'arrêt et se terminera prochainement. Vous ne pouvez pas démarrer un nouveau déploiement en bloc pendant qu'un déploiement antérieur se trouve dans l'état `Stopping`.
+ `Stopped`. L'exécution du déploiement en masse a été arrêtée manuellement.
+ `Failed`. L'exécution du déploiement en masse a rencontré une erreur et s'est terminée. Le champ `ErrorDetails` contient des détails sur l’erreur.
La charge utile JSON inclut également des données statistiques sur la progression du déploiement en bloc. Vous pouvez utiliser ces informations pour déterminer combien de groupes ont été traités et combien ont échoué. Les informations statistiques incluent :
+ `RecordsProcessed`: le nombre d'enregistrements de groupe tentés.
+ `InvalidInputRecords`: le nombre total d'enregistrements ayant renvoyé une erreur qui ne peut pas être retentée. Par exemple, cela peut se produire si un enregistrement de groupe du fichier d'entrée utilise un format incorrect ou spécifie une version de groupe qui n'existe pas, ou si l'exécution n'accorde pas l'autorisation de déployer un groupe ou une version de groupe.
+ `RetryAttempts`: le nombre de tentatives de déploiement ayant renvoyé une erreur qui peut être retentée. Par exemple, une nouvelle tentative est déclenchée si la tentative pour déployer un groupe renvoie une erreur de limitation. Un déploiement de groupe peut être réessayé jusqu'à cinq fois.
Dans le cas d'un échec de l'exécution du déploiement en bloc, cette charge utile inclut également une section `ErrorDetails` qui peut être utilisée pour le dépannage. Elle contient des informations sur la cause de l'échec de l'exécution.
Vous pouvez vérifier régulièrement le statut du déploiement en bloc pour confirmer qu'il progresse comme prévu. Une fois que le déploiement est terminé, `RecordsProcessed` doit être égal au nombre de groupes de déploiement dans votre fichier d'entrée de déploiement en bloc. Cela indique que chaque enregistrement a été traité.
## Étape 5 : Tester le déploiement
Utilisez la commande **ListBulkDeployments** pour rechercher l'ID de votre déploiement en bloc.
```
aws greengrass list-bulk-deployments
```
Cette commande renvoie une liste de tous vos déploiements en bloc, du plus récent au moins récent, y compris votre `BulkDeploymentId`.
```
{
"BulkDeployments": [
{
"BulkDeploymentId": 1234567,
"BulkDeploymentArn": "string",
"CreatedAt": "string"
}
],
"NextToken": "string"
}
```
Maintenant, appelez la commande **ListBulkDeploymentDetailedReports** pour rassembler des informations détaillées sur chaque déploiement.
```
aws greengrass list-bulk-deployment-detailed-reports --bulk-deployment-id 1234567
```
La commande doit retourner un code de statut réussi `200` en plus d'une charge utile JSON d'informations :
```
{
"BulkDeploymentResults": [
{
"DeploymentId": "string",
"GroupVersionedArn": "string",
"CreatedAt": "string",
"DeploymentStatus": "string",
"ErrorMessage": "string",
"ErrorDetails": [
{
"DetailedErrorCode": "string",
"DetailedErrorMessage": "string"
}
]
}
],
"NextToken": "string"
}
```
Cette charge utile contient généralement une liste paginée de chaque déploiement et son statut de déploiement du plus récent au moins récent. Elle contient également plus d'informations en cas d'échec de l'exécution du déploiement en bloc. Là encore, le nombre total de déploiements répertoriés doit être égal au nombre de groupes que vous avez identifiés dans votre fichier d'entrée de déploiement en bloc.
Les informations renvoyées peuvent changer jusqu'à ce que les déploiements se trouvent dans un état de mise hors service (réussite ou échec). Vous pouvez appeler cette commande périodiquement d'ici là.
## Résolution des problèmes de déploiements en bloc
Si le déploiement en bloc n'est pas réussi, vous pouvez essayer les étapes de dépannage suivantes. Exécutez les commandes dans votre terminal.
### Résolvez les erreurs de fichier d'entrée
Le déploiement en bloc peut échouer en cas d'erreurs de syntaxe dans le fichier d'entrée de déploiement en bloc. Cela renvoie un statut de déploiement en bloc `Failed` avec un message d'erreur indiquant le numéro de la ligne de la première erreur de validation. Il existe quatre erreurs possibles :
+
```
InvalidInputFile: Missing GroupId at line number: line number
```
Cette erreur indique que la ligne de fichier d'entrée donnée n'est pas en mesure d'enregistrer le paramètre spécifié. Les paramètres manquants possibles sont l'`GroupId` et l'`GroupVersionId`.
+
```
InvalidInputFile: Invalid deployment type at line number : line number. Only valid type is 'NewDeployment'.
```
Cette erreur indique que la ligne de fichier d'entrée donnée répertorie un type de déploiement non valide. Pour l'instant, le seul type pris en charge est un déploiement `NewDeployment`.
+
```
Line %s is too long in S3 File. Valid line is less than 256 chars.
```
Cette erreur indique que la ligne de fichier d'entrée donnée est trop longue et doit être raccourcie.
+
```
Failed to parse input file at line number: line number
```
Cette erreur indique que la ligne de fichier d'entrée donnée n'est pas considérée comme un format json valide.
### Vérifier les déploiements en bloc simultanés
Vous ne pouvez pas démarrer un nouveau déploiement en bloc pendant qu'un autre est toujours en cours d'exécution ou dans un état de mise hors service. Cela peut entraîner une `Concurrent Deployment Error`. Vous pouvez utiliser la commande **ListBulkDeployments** pour vérifier qu'un déploiement en bloc n'est pas en cours d’exécution. Cette commande répertorie vos déploiements en bloc du plus récent au moins récent.
```
{
"BulkDeployments": [
{
"BulkDeploymentId": BulkDeploymentId,
"BulkDeploymentArn": "string",
"CreatedAt": "string"
}
],
"NextToken": "string"
}
```
Utilisez le déploiement `BulkDeploymentId` du premier déploiement en bloc répertorié pour exécuter la commande **GetBulkDeploymentStatus**. Si votre déploiement en bloc le plus récent est en cours d'exécution (`Initializing` ou `Running`), utilisez la commande suivante pour arrêter le déploiement en bloc.
```
aws greengrass stop-bulk-deployment --bulk-deployment-id BulkDeploymentId
```
Cette action entraîne le statut `Stopping` jusqu'à ce que le déploiement soit `Stopped`. Une fois que le déploiement a atteint un statut `Stopped`, vous pouvez commencer un nouveau déploiement en bloc.
### Vérifiez ErrorDetails
Exécutez la commande `GetBulkDeploymentStatus` pour renvoyer une charge utile JSON qui contient des informations sur n'importe quel échec d'exécution du déploiement en bloc.
```
"Message": "string",
"ErrorDetails": [
{
"DetailedErrorCode": "string",
"DetailedErrorMessage": "string"
}
]
```
Lorsqu'une erreur sort, la charge utile JSON `ErrorDetails` renvoyée par cet appel contient plus d'informations sur l'échec d'exécution du déploiement en bloc. Un code de statut d'erreur dans la série `400`, par exemple, indique une erreur d'entrée, dans les paramètres d'entrée ou les dépendances du mandataire.
### Vérifiez le journal AWS IoT Greengrass de base
Vous pouvez résoudre les problèmes en consultant les AWS IoT Greengrass principaux journaux. Vous pouvez également utiliser les commandes suivantes pour afficher `runtime.log` :
```
cd /greengrass/ggc/var/log
sudo cat system/runtime.log | more
```
Pour plus d'informations sur la AWS IoT Greengrass journalisation, consultez[Surveillance à l'aide de AWS IoT Greengrass journaux](greengrass-logs-overview.md).
## Consultez aussi
Pour plus d’informations, consultez les ressources suivantes :
+ [Déployer AWS IoT Greengrass des groupes vers un AWS IoT Greengrass noyau](deployments.md)
+ Commandes de [l'API Amazon S3 dans la *AWS CLI référence* des commandes](https://docs.aws.amazon.com/cli/latest/reference/s3api)
+ [AWS IoT Greengrass commandes](https://docs.aws.amazon.com/cli/latest/reference/greengrass/index.html) dans la *référence des AWS CLI commandes*