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.
# Déployer AWS IoT Greengrass des groupes vers un AWS IoT Greengrass noyau
Utilisez AWS IoT Greengrass des groupes pour organiser les entités dans votre environnement périphérique. Vous pouvez également utiliser des groupes pour contrôler la manière dont les entités du groupe interagissent entre elles et avec le AWS Cloud. Par exemple, seules les fonctions Lambda du groupe sont déployées pour être exécutées localement, et seuls les appareils du groupe peuvent communiquer via le serveur MQTT local.
Un groupe doit inclure un [noyau](gg-core.md), c'est-à-dire un AWS IoT appareil qui exécute le logiciel AWS IoT Greengrass Core. Le cœur agit comme une passerelle périphérique et fournit des AWS IoT Core fonctionnalités dans l'environnement périphérique. En fonction des besoins de votre entreprise, vous pouvez également ajouter les entités suivantes à un groupe :
+ **Appareils clients**. Représenté en tant qu'objets dans le registre AWS IoT . Ces appareils doivent exécuter [FreeRTOS](https://docs.aws.amazon.com/freertos/latest/userguide/freertos-lib-gg-connectivity.html) ou utiliser [AWS IoT le Device SDK AWS IoT Greengrass ou l'](what-is-gg.md#iot-device-sdk)[API Discovery](gg-discover-api.md) pour obtenir des informations de connexion pour le noyau. Seuls les appareils clients membres du groupe peuvent se connecter au cœur.
+ **Fonctions Lambda**. Applications sans serveur définies par l'utilisateur qui exécutent du code sur le cœur. Les fonctions Lambda sont créées AWS Lambda et référencées à partir d'un groupe Greengrass. Pour de plus amples informations, veuillez consulter [Exécuter les fonctions Lambda sur le noyau AWS IoT Greengrass](lambda-functions.md).
+ **Connecteurs**. Applications sans serveur prédéfinies qui exécutent du code sur le cœur. Les connecteurs peuvent fournir une intégration intégrée à l'infrastructure locale AWS, aux protocoles des appareils et à d'autres services cloud. Pour de plus amples informations, veuillez consulter [Intégrer à des services et protocoles à l'aide de connecteurs Greengrass](connectors.md).
+ **Abonnements**. Définit les éditeurs, les abonnés et les rubriques MQTT (ou sujets) qui sont autorisés pour la communication MQTT.
+ **Ressources**. Références à des [appareils et volumes](access-local-resources.md) locaux, à des [modèles d'apprentissage automatique](ml-inference.md) et à des [secrets](secrets.md), utilisés pour le contrôle d'accès par les fonctions et connecteurs Greengrass Lambda.
+ **Journaux**. Configurations de journalisation pour les composants AWS IoT Greengrass du système et les fonctions Lambda. Pour de plus amples informations, veuillez consulter [Surveillance à l'aide de AWS IoT Greengrass journaux](greengrass-logs-overview.md).
Vous gérez votre groupe Greengrass dans le, AWS Cloud puis vous le déployez sur un noyau. Le déploiement copie la configuration du groupe dans le fichier `group.json` sur l'appareil principal. Ce fichier se trouve dans le dossier `greengrass-root/ggc/deployments/group`.
![\[Définition cloud du groupe Greengrass déployé sur un appareil principal.\]](http://docs.aws.amazon.com/fr_fr/greengrass/v1/developerguide/images/group-deploy.png)
**Note**
Au cours d'un déploiement, le processus de démon Greengrass sur l'appareil principal s'arrête, puis redémarre.
## Déploiement de groupes depuis la AWS IoT console
Vous pouvez déployer un groupe et gérer ses déploiements depuis la page de configuration du groupe dans la AWS IoT console.
**Note**
Pour ouvrir cette page dans la console, choisissez **Greengrass devices**, **Groups (V1)**, puis sous **Greengrass groups**, choisissez votre groupe.
**Pour déployer la version actuelle du groupe**
+ Sur la page de configuration du groupe, choisissez **Deploy**.
**Pour afficher l'historique de déploiement du groupe**
L'historique de déploiement d'un groupe inclut la date et l'heure, la version du groupe et l'état de chaque tentative de déploiement.
1. Sur la page de configuration du groupe, choisissez l'onglet **Déploiements**.
1. Pour obtenir plus d'informations sur un déploiement, y compris les messages d'erreur, choisissez **Déploiements** depuis la AWS IoT console, sous Appareils **Greengrass**.
**Pour redéployer un déploiement de groupe**
Vous pouvez souhaiter redéployer un déploiement si le déploiement actuel échoue ou revenir à une autre version de groupe.
1. Sur la AWS IoT console, choisissez **Greengrass devices**, puis **Groups (V1)**.
1. Choisissez l'onglet **Déploiements**.
1. Choisissez le déploiement que vous souhaitez redéployer, puis **Redéployer**.
**Pour réinitialiser les déploiements de groupe**
Vous pouvez souhaiter réinitialiser les déploiements de groupe pour déplacer ou supprimer un groupe ou supprimer des informations de déploiement. Pour de plus amples informations, veuillez consulter [Réinitialiser les déploiements](reset-deployments-scenario.md).
1. Sur la AWS IoT console, choisissez **Greengrass devices**, puis **Groups (V1)**.
1. Choisissez l'onglet **Déploiements**.
1. Choisissez le déploiement que vous souhaitez réinitialiser, puis sélectionnez **Réinitialiser les déploiements.**
## Déploiement de groupes avec l' AWS IoT Greengrass API
L' AWS IoT Greengrass API fournit les actions suivantes pour déployer des AWS IoT Greengrass groupes et gérer les déploiements de groupes. Vous pouvez appeler ces actions depuis AWS CLI l' AWS IoT Greengrass API ou le AWS SDK.
| Action | Description |
| --- | --- |
| [CreateDeployment](https://docs.aws.amazon.com/greengrass/v1/apireference/createdeployment-post.html) | Crée un déploiement `Redeployment` ou `NewDeployment`. Vous pouvez souhaiter redéployer un déploiement si le déploiement actuel échoue. Ou vous pouvez souhaiter redéployer pour revenir à une autre version de groupe. |
| [GetDeploymentStatus](https://docs.aws.amazon.com/greengrass/v1/apireference/getdeploymentstatus-get.html) | Renvoie le statut d'un déploiement : `Building`, `InProgress`, `Success` ou `Failure`. Vous pouvez configurer les EventBridge événements Amazon pour recevoir des notifications de déploiement. Pour de plus amples informations, veuillez consulter [Obtention des notifications de déploiement](deployment-notifications.md). |
| [ListDeployments](https://docs.aws.amazon.com/greengrass/v1/apireference/listdeployments-get.html) | Renvoie l'historique de déploiement pour le groupe. |
| [ResetDeployments](https://docs.aws.amazon.com/greengrass/v1/apireference/resetdeployments-post.html) | Réinitialise les déploiements pour le groupe. Vous pouvez souhaiter réinitialiser les déploiements de groupe pour déplacer ou supprimer un groupe ou supprimer des informations de déploiement. Pour de plus amples informations, veuillez consulter [Réinitialiser les déploiements](reset-deployments-scenario.md). |
**Note**
Pour plus d'informations sur les opérations de déploiement en bloc, consultez [Créer des déploiements en bloc pour des groupes](bulk-deploy-cli.md).
### Obtention de l'ID de groupe
L'ID de groupe est couramment utilisé dans les actions API. Vous pouvez utiliser cette [ListGroups](https://docs.aws.amazon.com/greengrass/v1/apireference/listgroups-get.html)action pour trouver l'identifiant du groupe cible dans votre liste de groupes. Par exemple, dans le AWS CLI, utilisez la `list-groups` commande.
```
aws greengrass list-groups
```
Vous pouvez également inclure l'option `query` pour filtrer les résultats. Par exemple :
+ Pour obtenir le groupe créé le plus récemment :
```
aws greengrass list-groups --query "reverse(sort_by(Groups, &CreationTimestamp))[0]"
```
+ Pour obtenir un groupe par son nom :
```
aws greengrass list-groups --query "Groups[?Name=='MyGroup']"
```
Les noms de groupe ne devant pas nécessairement être uniques, plusieurs groupes peuvent être renvoyés.
Voici un exemple de réponse `list-groups` : Les informations relatives à chaque groupe comprennent l'ID du groupe (dans la propriété `Id`) et l'ID de la version de groupe la plus récente (dans la propriété `LatestVersion`). Pour obtenir une autre version IDs pour un groupe, utilisez l'ID du groupe avec [ListGroupVersions](https://docs.aws.amazon.com/greengrass/v1/apireference/listgroupversions-get.html).
**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.
```
{
"Groups": [
{
"LatestVersionArn": "arn:aws:us-west-2:123456789012:/greengrass/groups/00dedaaa-ac16-484d-ad77-c3eedEXAMPLE/versions/4cbc3f07-fc5e-48c4-a50e-7d356EXAMPLE",
"Name": "MyFirstGroup",
"LastUpdatedTimestamp": "2019-11-11T05:47:31.435Z",
"LatestVersion": "4cbc3f07-fc5e-48c4-a50e-7d356EXAMPLE",
"CreationTimestamp": "2019-11-11T05:47:31.435Z",
"Id": "00dedaaa-ac16-484d-ad77-c3eedEXAMPLE",
"Arn": "arn:aws:us-west-2:123456789012:/greengrass/groups/00dedaaa-ac16-484d-ad77-c3eedEXAMPLE"
},
{
"LatestVersionArn": "arn:aws:us-west-2:123456789012:/greengrass/groups/036ceaf9-9319-4716-ba2a-237f9EXAMPLE/versions/8fe9e8ec-64d1-4647-b0b0-01dc8EXAMPLE",
"Name": "GreenhouseSensors",
"LastUpdatedTimestamp": "2020-01-07T19:58:36.774Z",
"LatestVersion": "8fe9e8ec-64d1-4647-b0b0-01dc8EXAMPLE",
"CreationTimestamp": "2020-01-07T19:58:36.774Z",
"Id": "036ceaf9-9319-4716-ba2a-237f9EXAMPLE",
"Arn": "arn:aws:us-west-2:123456789012:/greengrass/groups/036ceaf9-9319-4716-ba2a-237f9EXAMPLE"
},
...
]
}
```
Si vous ne spécifiez pas de Région AWS, AWS CLI les commandes utilisent la région par défaut de votre profil. Pour renvoyer des groupes dans une autre région, incluez *region* cette option. Par exemple :
```
aws greengrass list-groups --region us-east-1
```
## Vue d'ensemble du modèle AWS IoT Greengrass d'objet de groupe
Lorsque vous programmez avec l' AWS IoT Greengrass API, il est utile de comprendre le modèle d'objet du groupe Greengrass.
### Groups
Dans l' AWS IoT Greengrass API, l'`Group`objet de niveau supérieur se compose de métadonnées et d'une liste d'`GroupVersion`objets. `GroupVersion`les objets sont associés à un `Group` identifiant secondaire.
![\[Diagramme d'un groupe, composé de métadonnées et d'une liste de versions de groupe.\]](http://docs.aws.amazon.com/fr_fr/greengrass/v1/developerguide/images/om-group.png)
### Versions de groupe
Les objets `GroupVersion` définissent l'appartenance au groupe. Chaque objet `GroupVersion` fait référence à un objet `CoreDefinitionVersion` et d'autres versions de composant par ARN. Ces références déterminent les entités à inclure dans le groupe.
![\[Diagramme d'une version de groupe qui fait référence à d'autres types de version par ARN.\]](http://docs.aws.amazon.com/fr_fr/greengrass/v1/developerguide/images/om-groupversion.png)
Par exemple, pour inclure trois fonctions Lambda, un appareil et deux abonnements dans le groupe, les `GroupVersion` références :
+ `CoreDefinitionVersion` contenant le noyau requis.
+ `FunctionDefinitionVersion`, qui contient les trois fonctions.
+ Celui `DeviceDefinitionVersion` qui contient l'appareil client.
+ `SubscriptionDefinitionVersion`, qui contient les deux abonnements.
L’objet `GroupVersion` déployé sur un périphérique noyau détermine les entités disponibles dans l'environnement local et la manière dont elles peuvent interagir.
### Composants de groupe
Les composants que vous ajoutez aux groupes ont une hiérarchie à trois niveaux :
+ *Définition* qui fait référence à une liste d'*DefinitionVersion*objets d'un type donné. Par exemple, un objet `DeviceDefinition` fait référence à une liste d'objets `DeviceDefinitionVersion`.
+ Un *DefinitionVersion*qui contient un ensemble d'entités d'un type donné. Par exemple, un objet `DeviceDefinitionVersion` contient une liste d'objets `Device`.
+ Entités individuelles qui définissent leurs propriétés et leur comportement. Par exemple, a `Device` définit l'ARN de l'appareil client correspondant dans le AWS IoT registre, l'ARN de son certificat d'appareil et indique si son shadow local se synchronise automatiquement avec le cloud.
Vous pouvez ajouter les types d'entité suivants à un groupe :
+ [Connecteur](https://docs.aws.amazon.com/greengrass/v1/apireference/definitions-connector.html)
+ [Principal](https://docs.aws.amazon.com/greengrass/v1/apireference/definitions-core.html)
+ [Device](https://docs.aws.amazon.com/greengrass/v1/apireference/definitions-device.html)
+ [Fonction](https://docs.aws.amazon.com/greengrass/v1/apireference/definitions-function.html)
+ [Logger](https://docs.aws.amazon.com/greengrass/v1/apireference/definitions-logger.html)
+ [Ressource](https://docs.aws.amazon.com/greengrass/v1/apireference/definitions-resource.html)
+ [Abonnement](https://docs.aws.amazon.com/greengrass/v1/apireference/definitions-subscription.html)
L'exemple suivant `DeviceDefinition` fait référence à trois objets `DeviceDefinitionVersion` qui contiennent chacun plusieurs objets `Device`. Un seul objet `DeviceDefinitionVersion` à la fois est utilisé dans un groupe.
![\[Schéma d'une hiérarchie de périphériques, composée de DeviceDefinition DeviceDefinitionVersion, et d'objets de périphériques.\]](http://docs.aws.amazon.com/fr_fr/greengrass/v1/developerguide/images/om-devicedefinition.png)
### Mise à jour de groupes
Dans l' AWS IoT Greengrass API, vous utilisez les versions pour mettre à jour la configuration d'un groupe. Les versions étant immuables, pour ajouter, supprimer ou modifier des composants de groupe, vous devez créer *DefinitionVersion*des objets contenant des entités nouvelles ou mises à jour.
Vous pouvez associer de nouveaux *DefinitionVersions*objets à des objets de *définition* nouveaux ou existants. Par exemple, vous pouvez utiliser l'action `CreateFunctionDefinition` pour créer un objet `FunctionDefinition` qui inclut l’objet `FunctionDefinitionVersion` comme version initiale, ou vous pouvez utiliser l'action `CreateFunctionDefinitionVersion` et faire référence à un objet `FunctionDefinition` existant.
Après avoir créé les composants de votre groupe, vous en créez un `GroupVersion` qui contient tous les *DefinitionVersion*objets que vous souhaitez inclure dans le groupe. Vous déployez ensuite l’objet `GroupVersion`.
Pour déployer un objet `GroupVersion`, celui-ci doit faire référence à un objet `CoreDefinitionVersion` qui contient exactement un objet `Core`. Toutes les entités référencées doivent être membres du groupe. En outre, un rôle de [service Greengrass doit être associé à votre rôle](service-role.md) Compte AWS dans l' Région AWS endroit où vous déployez le. `GroupVersion`
**Note**
Les actions `Update` dans l'API sont utilisées pour modifier le nom d'un objet `Group` ou de composant *Definition*.
**Mettre à jour les entités qui font référence à AWS des ressources**
Les fonctions Lambda et les [ressources secrètes de Greengrass définissent les propriétés spécifiques à Greengrass et font également référence aux ressources](secrets.md) correspondantes. AWS Pour mettre à jour ces entités, vous pouvez apporter des modifications à la AWS ressource correspondante plutôt qu'à vos objets Greengrass. Par exemple, les fonctions Lambda font référence à une fonction dans AWS Lambda et définissent également le cycle de vie et d'autres propriétés spécifiques au groupe Greengrass.
+ Pour mettre à jour le code de fonction Lambda ou les dépendances packagées, apportez vos modifications dans. AWS Lambda Lors du prochain déploiement de groupe, ces modifications sont extraites de votre environnement local AWS Lambda et copiées dans celui-ci.
+ Pour mettre à jour les [propriétés spécifiques à Greengrass](lambda-group-config.md), vous créez un objet `FunctionDefinitionVersion` qui contient les propriétés `Function` mises à jour.
**Note**
Les fonctions Lambda Greengrass peuvent référencer une fonction Lambda par un alias ARN ou une version ARN. Si vous référencez l'ARN d'alias (recommandé), vous n'avez pas besoin de mettre à jour votre `FunctionDefinitionVersion` (ou `SubscriptionDefinitionVersion`) lorsque vous publiez une nouvelle version de fonction dans AWS Lambda. Pour de plus amples informations, veuillez consulter [Référencer les fonctions Lambda par alias ou par version](lambda-functions.md#lambda-versions-aliases).
## Consultez aussi
+ [Obtention des notifications de déploiement](deployment-notifications.md)
+ [Réinitialiser les déploiements](reset-deployments-scenario.md)
+ [Créer des déploiements en bloc pour des groupes](bulk-deploy-cli.md)
+ [Dépannage des problèmes de déploiement](gg-troubleshooting.md#gg-troubleshooting-deploymentissues)
+ [AWS IoT Greengrass Version 1 API Reference](https://docs.aws.amazon.com/greengrass/v1/apireference/)
+ [AWS IoT Greengrass commandes](https://docs.aws.amazon.com/cli/latest/reference/greengrass/index.html) dans la *référence des AWS CLI commandes*
# Obtention des notifications de déploiement
Les règles relatives aux EventBridge événements d'Amazon vous fournissent des notifications concernant les changements d'état relatifs aux déploiements de votre groupe Greengrass. EventBridge fournit un flux d'événements système en temps quasi réel qui décrit l'évolution des AWS ressources. AWS IoT Greengrass envoie ces événements EventBridge à *au moins une fois*. Cela signifie qu'il est AWS IoT Greengrass possible d'envoyer plusieurs copies d'un événement donné pour garantir la livraison. En outre, les écouteurs d'événements peuvent ne pas recevoir les événements dans l'ordre dans lequel ces derniers se produisent.
**Note**
Amazon EventBridge est un service de bus d'événements que vous pouvez utiliser pour connecter vos applications à des données provenant de diverses sources, telles que les [appareils principaux de Greengrass et les notifications](telemetry.md) de déploiement. Pour plus d'informations, consultez [Qu'est-ce qu'Amazon EventBridge ?](https://docs.aws.amazon.com/eventbridge/latest/userguide/what-is-amazon-eventbridge.html) dans le *guide de EventBridge l'utilisateur Amazon*.
AWS IoT Greengrass émet un événement lorsque les déploiements de groupe changent d'état. Vous pouvez créer une EventBridge règle qui s'applique à toutes les transitions d'état ou aux transitions vers les états que vous spécifiez. Lorsqu'un déploiement entre dans un état qui initie une règle, il EventBridge invoque les actions cibles définies dans la règle. Cela vous permet d'envoyer des notifications, de capturer des informations sur les événements, de prendre des mesures correctives ou de déclencher d'autres événements en réponse à un changement d'état. Par exemple, vous pouvez créer des règles pour les cas d'utilisation suivants :
+ Lancez des opérations après le déploiement, telles que le téléchargement de ressources et la notification du personnel.
+ Envoyer des notifications en cas de réussite ou de l'échec d'un déploiement.
+ Publier des métriques personnalisées sur les événements de déploiement.
AWS IoT Greengrass émet un événement lorsqu'un déploiement entre dans les états suivants :`Building`, `InProgress``Success`, et`Failure`.
**Note**
La surveillance du statut d'une opération de [déploiement en bloc](bulk-deploy-cli.md) n'est pas prise en charge actuellement. AWS IoT Greengrass Émet toutefois des événements de changement d'état pour les déploiements de groupe individuels qui font partie d'un déploiement en masse.
## Événement de changement de statut de déploiement de groupe
L' [événement](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/CloudWatchEventsandEventPatterns.html) pour un changement d'état de déploiement utilise le format suivant :
```
{
"version":"0",
"id":" cd4d811e-ab12-322b-8255-EXAMPLEb1bc8",
"detail-type":"Greengrass Deployment Status Change",
"source":"aws.greengrass",
"account":"123456789012",
"time":"2018-03-22T00:38:11Z",
"region":"us-west-2",
"resources":[],
"detail":{
"group-id": "284dcd4e-24bc-4c8c-a770-EXAMPLEf03b8",
"deployment-id": "4f38f1a7-3dd0-42a1-af48-EXAMPLE09681",
"deployment-type": "NewDeployment|Redeployment|ResetDeployment|ForceResetDeployment",
"status": "Building|InProgress|Success|Failure"
}
}
```
Vous pouvez créer des règles qui s'appliquent à un ou plusieurs groupes. Vous pouvez filtrer les règles selon un ou plusieurs des types et états de déploiement suivants :
**Types de déploiement**
+ `NewDeployment`. Le premier déploiement d'une version de groupe.
+ `ReDeployment`. Redéploiement d'une version de groupe.
+ `ResetDeployment`. Supprime les informations de déploiement stockées dans AWS Cloud et sur le AWS IoT Greengrass noyau. Pour de plus amples informations, veuillez consulter [Réinitialiser les déploiements](reset-deployments-scenario.md).
+ `ForceResetDeployment`. Supprime les informations de déploiement stockées dans le AWS Cloud et signale le succès sans attendre que le noyau réponde. Supprime également des informations de déploiement stockées sur le noyau si le noyau est connecté ou lors de sa prochaine connexion.
**États de déploiement**
+ `Building`. AWS IoT Greengrass valide la configuration du groupe et crée des artefacts de déploiement.
+ `InProgress`. Le déploiement est en cours sur le AWS IoT Greengrass noyau.
+ `Success`. Le déploiement s'est déroulé avec succès.
+ `Failure`. Le déploiement a échoué.
Il est possible que les événements soient dupliqués ou hors service. Pour déterminer l'ordre des événements, utilisez la propriété `time`.
**Note**
AWS IoT Greengrass n'utilise pas la `resources` propriété, elle est donc toujours vide.
## Conditions préalables à la création de règles EventBridge
Avant de créer une EventBridge règle pour AWS IoT Greengrass, procédez comme suit :
+ Familiarisez-vous avec les événements, les règles et les cibles dans EventBridge.
+ Créez et configurez les cibles invoquées par vos EventBridge règles. Les règles peuvent appeler de nombreux types de cibles, notamment :
+ Amazon Simple Notification Service (Amazon SNS)
+ AWS Lambda fonctions
+ Amazon Kinesis Video Streams
+ Files d’attente Amazon Simple Queue Service (Amazon SQS)
Pour plus d'informations, consultez [Qu'est-ce qu'Amazon EventBridge ?](https://docs.aws.amazon.com/eventbridge/latest/userguide/what-is-amazon-eventbridge.html) et [Getting started with Amazon EventBridge](https://docs.aws.amazon.com/eventbridge/latest/userguide/eventbridge-getting-set-up.html) dans le *guide de EventBridge l'utilisateur Amazon*.
## Configurer les notifications de déploiement (console)
Suivez les étapes ci-dessous pour créer une EventBridge règle qui publie une rubrique Amazon SNS lorsque l'état de déploiement d'un groupe change. Cela permet aux serveurs web, aux adresses e-mail et aux autres abonnés à la rubrique de répondre à l'événement. Pour plus d'informations, consultez la section [Création d'une EventBridge règle déclenchant un événement à partir d'une AWS ressource](https://docs.aws.amazon.com/eventbridge/latest/userguide/create-eventbridge-rule.html) dans le *guide de EventBridge l'utilisateur Amazon*.
1. Ouvrez la [ EventBridgeconsole Amazon](https://console.aws.amazon.com/events/).
1. Dans le panneau de navigation, choisissez **Rules**.
1. Choisissez **Créer une règle**.
1. Saisissez un nom et une description pour la règle.
Une règle ne peut pas avoir le même nom qu'une autre règle de la même région et sur le même bus d'événement.
1. Pour **Event bus** (Bus d'événement), sélectionnez le bus d'événement que vous souhaitez associer à cette règle. Si vous souhaitez que cette règle corresponde aux événements provenant de votre compte, sélectionnez **Bus d’événements par défaut AWS **. Lorsqu'un AWS service de votre compte émet un événement, celui-ci est toujours redirigé vers le bus d'événements par défaut de votre compte.
1. Pour **Type de règle**, choisissez **Règle avec un modèle d’événement**.
1. Choisissez **Suivant**.
1. Pour **Source d'événement**, choisissez **Services AWS **.
1. Dans **Modèle d'événement**, sélectionnez **AWS services**.
1. Pour le **AWS service**, choisissez Greengrass.
1. Dans **Event type (Type d'événement)**, choisissez **Greengrass Deployment Status Change -Modifier l'état du déploiement Greengrass)**.
**Note**
L'**appel AWS d'API via** le type d' CloudTrailévénement est basé sur AWS IoT Greengrass l'intégration avec AWS CloudTrail. Vous pouvez utiliser cette option pour créer des règles initiées par des appels de lecture ou d'écriture à l' AWS IoT Greengrass API. Pour de plus amples informations, veuillez consulter [Journalisation des appels d' AWS IoT Greengrass API avec AWS CloudTrail](logging-using-cloudtrail.md).
1. Choisissez les états de déploiement qui déclenchent une notification.
+ Pour recevoir des notifications pour tous les événements de modification d'état, choisissez **Any state (N'importe quel état)**.
+ Pour recevoir des notifications pour certains événements de modification d'état uniquement, choisissez **Specific state(s) (État(s) spécifique(s))**, puis choisissez les états cibles.
1. Choisissez les types de déploiement qui déclenchent une notification.
+ Pour recevoir des notifications pour tous les types de déploiement, choisissez **Any state (N'importe quel état)**.
+ Pour recevoir des notifications pour certains types de déploiement uniquement, choisissez **Specific state(s) (État(s) spécifique(s))**, puis choisissez les types de déploiement cibles.
1. Choisissez **Suivant**.
1. Pour **Types de cibles**, choisissez **service AWS **.
1. Pour **Sélectionner une cible**, configurez votre cible. Cet exemple utilise une rubrique Amazon SNS, mais vous pouvez configurer d'autres types de cibles pour envoyer des notifications.
1. Pour **Target** (Cible), choisissez **SNS topic** (Rubrique SNS).
1. Pour **Topic (Rubrique)**, choisissez votre rubrique cible.
1. Choisissez **Suivant**.
1. Sous **Balises**, définissez des balises pour la règle ou laissez les champs vides.
1. Choisissez **Suivant**.
1. Consultez les détails de la règle et choisissez **Create rule** (Créer une règle).
## Configurer les notifications de déploiement (interface de ligne de commande)
Suivez les étapes ci-dessous pour créer une EventBridge règle qui publie une rubrique Amazon SNS lorsque l'état de déploiement d'un groupe change. Cela permet aux serveurs web, aux adresses e-mail et aux autres abonnés à la rubrique de répondre à l'événement.
1. Créez la règle.
+ Remplacez *group-id* par l'identifiant de votre AWS IoT Greengrass groupe.
```
aws events put-rule \
--name TestRule \
--event-pattern "{\"source\": [\"aws.greengrass\"], \"detail\": {\"group-id\": [\"group-id\"]}}"
```
Les propriétés qui sont omises dans le modèle sont ignorées.
1. Ajoutez la rubrique en tant que cible de règle.
+ *topic-arn*Remplacez-le par l'ARN de votre rubrique Amazon SNS.
```
aws events put-targets \
--rule TestRule \
--targets "Id"="1","Arn"="topic-arn"
```
**Note**
Pour autoriser Amazon EventBridge à appeler votre sujet cible, vous devez ajouter une politique basée sur les ressources à votre sujet. Pour plus d'informations, consultez les [autorisations Amazon SNS](https://docs.aws.amazon.com/eventbridge/latest/userguide/resource-based-policies-eventbridge.html#sns-permissions) dans le guide de * EventBridge l'utilisateur Amazon*.
Pour plus d'informations, consultez la section [Événements et modèles d'événements EventBridge dans](https://docs.aws.amazon.com/eventbridge/latest/userguide/eventbridge-and-event-patterns.html) le *guide de EventBridge l'utilisateur Amazon*.
## Configurer les notifications de déploiement (CloudFormation)
Utilisez des CloudFormation modèles pour créer des EventBridge règles qui envoient des notifications concernant les changements d'état pour les déploiements de votre groupe Greengrass. Pour plus d'informations, consultez la [référence aux types de EventBridge ressources Amazon](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/AWS_Events.html) dans le *guide de AWS CloudFormation l'utilisateur*.
## Consultez aussi
+ [Déployer AWS IoT Greengrass des groupes vers un AWS IoT Greengrass noyau](deployments.md)
+ [Qu'est-ce qu'Amazon EventBridge ?](https://docs.aws.amazon.com/eventbridge/latest/userguide/what-is-amazon-eventbridge.html) dans le *guide de EventBridge l'utilisateur Amazon*
# Réinitialiser les déploiements
Cette fonctionnalité est disponible pour AWS IoT Greengrass Core v1.1 et versions ultérieures.
Vous pouvez souhaiter réinitialiser les déploiements d'un groupe pour :
+ Supprimez le groupe, par exemple lorsque vous souhaitez déplacer le noyau du groupe vers un autre groupe ou lorsque le noyau du groupe a été redessiné. Avant de supprimer un groupe, vous devez réinitialiser les déploiements du groupe pour utiliser le noyau avec un autre groupe Greengrass.
+ Déplacer le noyau du groupe vers un autre groupe.
+ Restaurer l'état antérieur d’un groupe avant tous les déploiements.
+ Supprimer la configuration de déploiement de l'appareil principal.
+ Supprimer des données sensibles de l'appareil principal ou du cloud.
+ Déployer une nouvelle configuration sur un noyau sans avoir à remplacer le noyau par un autre dans le groupe actuel.
**Note**
La fonctionnalité de réinitialisation des déploiements n'est pas disponible dans la version 1.0.0 du logiciel AWS IoT Greengrass Core. Vous ne pouvez pas supprimer un groupe qui a été déployé à l'aide de la version 1.0.0.
L'opération de réinitialisation des déploiements nettoie d'abord toutes les informations de déploiement stockées dans le cloud pour un groupe donné. Il demande ensuite au périphérique principal du groupe de nettoyer également toutes les informations relatives au déploiement (fonctions Lambda, journaux des utilisateurs, base de données fantôme et certificat de serveur, mais pas les certificats `config.json` définis par l'utilisateur ou les certificats principaux de Greengrass). Vous ne pouvez pas lancer une réinitialisation des déploiements pour un groupe si ce dernier a un déploiement dont l’état est `In Progress` ou `Building`.
## Réinitialisez les déploiements depuis la console AWS IoT
Vous pouvez réinitialiser les déploiements de groupe à partir de la page de configuration de groupe de la AWS IoT console.
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. Dans l'onglet **Déploiements**, choisissez **Réinitialiser les déploiements**.
1. Dans la boîte de dialogue **Réinitialiser les déploiements pour ce groupe Greengrass**, **confirm** tapez « Accepter », puis **choisissez** « Réinitialiser le déploiement ».
## Réinitialisez les déploiements avec l'API AWS IoT Greengrass
Vous pouvez utiliser l'`ResetDeployments`action dans l' AWS CLI AWS IoT Greengrass API ou le AWS SDK pour réinitialiser les déploiements. Les exemples de cette rubrique utilisent l’interface de ligne de commande.
```
aws greengrass reset-deployments --group-id GroupId [--force]
```Arguments destinés à la commande `reset-deployments` de l'interface de ligne de commande :
`--group-id`
ID du groupe Utilisez la commande `list-groups` pour obtenir cette valeur.
`--force`
Facultatif. Utilisez ce paramètre si l'appareil principal du groupe a été perdu, volé ou détruit. Si cette option est activée, le processus de déploiement de la réinitialisation signale la réussite une fois que toutes les informations de déploiement dans le cloud ont été nettoyées, sans attendre la réponse d'un appareil principal. Toutefois, si l'appareil principal est ou devient actif, il effectue également des opérations de nettoyage.
La sortie de la commande `reset-deployments` de l'interface de ligne de commande ressemble à ceci :
```
{
"DeploymentId": "4db95ef8-9309-4774-95a4-eea580b6ceef",
"DeploymentArn": "arn:aws:greengrass:us-west-2:106511594199:/greengrass/groups/b744ed45-a7df-4227-860a-8d4492caa412/deployments/4db95ef8-9309-4774-95a4-eea580b6ceef"
}
```
Vous pouvez vérifier le statut du déploiement de la réinitialisation avec la commande `get-deployment-status` de l'interface de ligne de commande :
```
aws greengrass get-deployment-status --deployment-id DeploymentId --group-id GroupId
```Arguments destinés à la commande `get-deployment-status` de l'interface de ligne de commande :
`--deployment-id`
ID de déploiement
`--group-id`
ID du groupe
La sortie de la commande `get-deployment-status` de l'interface de ligne de commande ressemble à ceci :
```
{
"DeploymentStatus": "Success",
"UpdatedAt": "2017-04-04T00:00:00.000Z"
}
```
`DeploymentStatus` est défini sur `Building` lorsque le déploiement de la réinitialisation est en cours de préparation. Lorsque le déploiement de réinitialisation est prêt mais que le AWS IoT Greengrass noyau n'a pas pris en charge le déploiement de réinitialisation, `DeploymentStatus` c'est le cas`InProgress`.
Si l'opération de réinitialisation échoue, les informations relatives à l'erreur sont renvoyées dans la réponse.
## Consultez aussi
+ [Déployer AWS IoT Greengrass des groupes vers un AWS IoT Greengrass noyau](deployments.md)
+ [ResetDeployments ](https://docs.aws.amazon.com/greengrass/v1/apireference/resetdeployments-post.html)dans la *référence de AWS IoT Greengrass Version 1 l'API*
+ [GetDeploymentStatus](https://docs.aws.amazon.com/greengrass/v1/apireference/getdeploymentstatus-get.html)dans la *référence de AWS IoT Greengrass Version 1 l'API*
# 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*