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
Vous pouvez créer un déploiement qui cible un objet ou un groupe d'objets.
Lorsque vous créez un déploiement, vous configurez les composants logiciels à déployer et la manière dont la tâche de déploiement est déployée sur les équipements cibles. Vous pouvez définir le déploiement dans le fichier JSON que vous fournissez au AWS CLI.
La cible de déploiement détermine les appareils sur lesquels vous souhaitez exécuter vos composants. Pour effectuer un déploiement sur un appareil principal, spécifiez un élément. Pour effectuer un déploiement sur plusieurs appareils principaux, spécifiez un groupe d'objets qui inclut ces appareils. Pour plus d'informations sur la configuration des groupes d'objets, consultez les sections [Groupes d'objets statiques](https://docs.aws.amazon.com/iot/latest/developerguide/thing-groups.html) et [Groupes d'objets dynamiques](https://docs.aws.amazon.com/iot/latest/developerguide/dynamic-thing-groups.html) dans le *Guide du AWS IoT développeur*.
Suivez les étapes décrites dans cette section pour créer un déploiement vers une cible. Pour plus d'informations sur la façon de mettre à jour les composants logiciels sur une cible déployée, consultez[Réviser les déploiements](revise-deployments.md).
**Avertissement**
L'[CreateDeployment](https://docs.aws.amazon.com/greengrass/v2/APIReference/API_CreateDeployment.html)opération peut désinstaller des composants des périphériques principaux. Si un composant est présent dans le déploiement précédent et non dans le nouveau déploiement, le périphérique principal désinstalle ce composant. Pour éviter de désinstaller des composants, utilisez d'abord l'[ListDeployments](https://docs.aws.amazon.com/greengrass/v2/APIReference/API_ListDeployments.html)opération pour vérifier si la cible du déploiement possède déjà un déploiement existant. Utilisez ensuite l'[GetDeployment](https://docs.aws.amazon.com/greengrass/v2/APIReference/API_GetDeployment.html)opération pour démarrer à partir de ce déploiement existant lorsque vous créez un nouveau déploiement.
**Pour créer un déploiement (AWS CLI)**
1. Créez un fichier appelé`deployment.json`, puis copiez l'objet JSON suivant dans le fichier. *targetArn*Remplacez-le par l'ARN de l' AWS IoT objet ou du groupe d'objets à cibler pour le déploiement. L'objet et le groupe ARNs d'objets ont le format suivant :
+ Objet : `arn:aws:iot:region:account-id:thing/thingName`
+ Groupe d'objets : `arn:aws:iot:region:account-id:thinggroup/thingGroupName`
```
{
"targetArn": "targetArn"
}
```
1. Vérifiez si la cible de déploiement comporte un déploiement existant que vous souhaitez réviser. Procédez comme suit :
1. Exécutez la commande suivante pour répertorier les déploiements pour la cible de déploiement. Remplacez *targetArn* par l'ARN de l' AWS IoT objet ou du groupe d'objets cible.
```
aws greengrassv2 list-deployments --target-arn targetArn
```
La réponse contient une liste du dernier déploiement pour la cible. Si la réponse est vide, la cible n'a pas de déploiement existant et vous pouvez passer à[Step 3](#create-deployment-define-name-step). Sinon, copiez le contenu `deploymentId` de la réponse pour l'utiliser à l'étape suivante.
**Note**
Vous pouvez également modifier un déploiement autre que la dernière révision pour la cible. Spécifiez l'`--history-filter ALL`argument pour répertorier tous les déploiements pour la cible. Copiez ensuite l'ID du déploiement que vous souhaitez modifier.
1. Exécutez la commande suivante pour obtenir les détails du déploiement. Ces détails incluent les métadonnées, les composants et la configuration des tâches. *deploymentId*Remplacez-le par l'ID de l'étape précédente.
```
aws greengrassv2 get-deployment --deployment-id deploymentId
```
La réponse contient les détails du déploiement.
1. Copiez l'une des paires clé-valeur suivantes de la réponse de la commande précédente dans. `deployment.json` Vous pouvez modifier ces valeurs pour le nouveau déploiement.
+ `deploymentName`— Le nom du déploiement.
+ `components`— Les composants du déploiement. Pour désinstaller un composant, supprimez-le de cet objet.
+ `deploymentPolicies`— Les politiques du déploiement.
+ `iotJobConfiguration`— La configuration des tâches du déploiement.
+ `tags`— Les tags du déploiement.
1. (Facultatif) Définissez un nom pour le déploiement. Remplacez *deploymentName* par le nom du déploiement.
```
{
"targetArn": "targetArn",
"deploymentName": "deploymentName"
}
```
1. Ajoutez chaque composant pour déployer les équipements cibles. Pour ce faire, ajoutez des paires clé-valeur à l'`components`objet, la clé étant le nom du composant et la valeur étant un objet contenant les détails de ce composant. Spécifiez les détails suivants pour chaque composant que vous ajoutez :
+ `version`— Version du composant à déployer.
+ `configurationUpdate`— La [mise à jour de configuration](update-component-configurations.md) à déployer. La mise à jour est une opération de correctif qui modifie la configuration existante du composant sur chaque équipement cible, ou la configuration par défaut du composant s'il n'existe pas sur le périphérique cible. Vous pouvez spécifier les mises à jour de configuration suivantes :
+ Reset updates (`reset`) — (Facultatif) Une liste de pointeurs JSON qui définissent les valeurs de configuration à rétablir à leurs valeurs par défaut sur l'appareil cible. Le logiciel AWS IoT Greengrass Core applique les mises à jour de réinitialisation avant d'appliquer les mises à jour de fusion. Pour de plus amples informations, veuillez consulter [Réinitialiser les mises à](update-component-configurations.md#reset-configuration-update).
+ Merge updates (`merge`) — (Facultatif) Document JSON qui définit les valeurs de configuration à fusionner sur le périphérique cible. Vous devez sérialiser le document JSON sous forme de chaîne. Pour de plus amples informations, veuillez consulter [Fusion des mises à jour](update-component-configurations.md#merge-configuration-update).
+ `runWith`— (Facultatif) Les options de processus système que le logiciel AWS IoT Greengrass Core utilise pour exécuter les processus de ce composant sur le périphérique principal. Si vous omettez un paramètre dans l'`runWith`objet, le logiciel AWS IoT Greengrass Core utilise les valeurs par défaut que vous configurez sur le composant [Greengrass nucleus](greengrass-nucleus-component.md).
Vous pouvez définir l'une des options suivantes :
+ `posixUser`— L'utilisateur du système POSIX et, éventuellement, le groupe à utiliser pour exécuter ce composant sur les périphériques principaux de Linux. L'utilisateur et le groupe, s'ils sont spécifiés, doivent exister sur chaque périphérique principal Linux. Spécifiez l'utilisateur et le groupe en les séparant par deux points (`:`) au format suivant : `user:group`. Le groupe est facultatif. Si vous ne spécifiez aucun groupe, le logiciel AWS IoT Greengrass Core utilise le groupe principal pour l'utilisateur. Pour de plus amples informations, veuillez consulter [Configurer l'utilisateur qui exécute les composants](configure-greengrass-core-v2.md#configure-component-user).
+ `windowsUser`— L'utilisateur Windows à utiliser pour exécuter ce composant sur les appareils principaux de Windows. L'utilisateur doit exister sur chaque appareil principal de Windows, et son nom et son mot de passe doivent être stockés dans l'instance Credentials Manager du LocalSystem compte. Pour de plus amples informations, veuillez consulter [Configurer l'utilisateur qui exécute les composants](configure-greengrass-core-v2.md#configure-component-user).
Cette fonctionnalité est disponible pour les versions 2.5.0 et ultérieures du composant [Greengrass](greengrass-nucleus-component.md) nucleus.
+ `systemResourceLimits`— Les limites de ressources système à appliquer aux processus de ce composant. Vous pouvez appliquer des limites de ressources système aux composants Lambda génériques et non conteneurisés. Pour de plus amples informations, veuillez consulter [Configuration des limites de ressources système pour les composants](configure-greengrass-core-v2.md#configure-component-system-resource-limits).
Vous pouvez définir l'une des options suivantes :
+ `cpus`— Le temps processeur maximal que les processus de ce composant peuvent utiliser sur le périphérique principal. Le temps processeur total d'un appareil principal est équivalent au nombre de cœurs processeurs de l'appareil. Par exemple, sur un périphérique principal doté de 4 cœurs de processeur, vous pouvez définir cette valeur `2` pour limiter les processus de ce composant à 50 % d'utilisation de chaque cœur de processeur. Sur un appareil doté d'un cœur de processeur, vous pouvez définir cette valeur `0.25` pour limiter les processus de ce composant à 25 % d'utilisation du processeur. Si vous définissez cette valeur sur un nombre supérieur au nombre de cœurs de processeur, le logiciel AWS IoT Greengrass Core ne limite pas l'utilisation du processeur par le composant.
+ `memory`— La quantité maximale de RAM (en kilo-octets) que les processus de ce composant peuvent utiliser sur le périphérique principal.
Cette fonctionnalité est disponible pour les versions 2.4.0 et ultérieures du composant [Greengrass](greengrass-nucleus-component.md) nucleus. AWS IoT Greengrass ne prend actuellement pas en charge cette fonctionnalité sur les appareils Windows principaux.
**Example Exemple de mise à jour de configuration de base**
L'exemple `components` d'objet suivant indique de déployer un composant qui attend un paramètre de configuration nommé`pythonVersion`. `com.example.PythonRuntime`
```
{
"targetArn": "targetArn",
"deploymentName": "deploymentName",
"components": {
"com.example.PythonRuntime": {
"componentVersion": "1.0.0",
"configurationUpdate": {
"merge": "{\"pythonVersion\":\"3.7\"}"
}
}
}
}
```
**Example Exemple de mise à jour de configuration avec mises à jour de réinitialisation et de fusion**
Prenons un exemple de composant de tableau de bord industriel dont la configuration par défaut est la suivante. `com.example.IndustrialDashboard`
```
{
"name": null,
"mode": "REQUEST",
"network": {
"useHttps": true,
"port": {
"http": 80,
"https": 443
},
},
"tags": []
}
```
La mise à jour de configuration suivante spécifie les instructions suivantes :
1. Réinitialisez le paramètre HTTPS à sa valeur par défaut (`true`).
1. Réinitialisez la liste des tags industriels à une liste vide.
1. Fusionnez une liste d'étiquettes industrielles identifiant les flux de données de température et de pression pour deux chaudières.
```
{
"reset": [
"/network/useHttps",
"/tags"
],
"merge": {
"tags": [
"/boiler/1/temperature",
"/boiler/1/pressure",
"/boiler/2/temperature",
"/boiler/2/pressure"
]
}
}
```
L'exemple d'`components`objet suivant indique de déployer ce composant de tableau de bord industriel et de mettre à jour la configuration.
```
{
"targetArn": "targetArn",
"deploymentName": "deploymentName",
"components": {
"com.example.IndustrialDashboard": {
"componentVersion": "1.0.0",
"configurationUpdate": {
"reset": [
"/network/useHttps",
"/tags"
],
"merge": "{\"tags\":[\"/boiler/1/temperature\",\"/boiler/1/pressure\",\"/boiler/2/temperature\",\"/boiler/2/pressure\"]}"
}
}
}
}
```
1. (Facultatif) Définissez les politiques de déploiement pour le déploiement. Vous pouvez configurer à quel moment les périphériques principaux peuvent effectuer un déploiement en toute sécurité ou ce qu'il convient de faire si un périphérique principal ne parvient pas à effectuer le déploiement. Pour ce faire, ajoutez un `deploymentPolicies` objet à`deployment.json`, puis effectuez l'une des opérations suivantes :
1. (Facultatif) Spécifiez la politique de mise à jour des composants (`componentUpdatePolicy`). Cette politique définit si le déploiement permet ou non aux composants de différer une mise à jour jusqu'à ce qu'ils soient prêts à être mis à jour. Par exemple, les composants peuvent avoir besoin de nettoyer les ressources ou de terminer des actions critiques avant de pouvoir redémarrer pour appliquer une mise à jour. Cette politique définit également le délai dont disposent les composants pour répondre à une notification de mise à jour.
Cette politique est un objet doté des paramètres suivants :
+ `action`— (Facultatif) S'il faut ou non informer les composants et attendre qu'ils signalent lorsqu'ils sont prêts à être mis à jour. Sélectionnez parmi les options suivantes :
+ `NOTIFY_COMPONENTS` : le déploiement avertit chaque composant avant qu'il ne s'arrête et met à jour ce composant. Les composants peuvent utiliser l'opération [SubscribeToComponentUpdates](ipc-component-lifecycle.md#ipc-operation-subscribetocomponentupdates) IPC pour recevoir ces notifications.
+ `SKIP_NOTIFY_COMPONENTS` : le déploiement ne notifie pas les composants et n'attend pas qu'ils soient mis à jour en toute sécurité.
La valeur par défaut est `NOTIFY_COMPONENTS`.
+ `timeoutInSeconds`Durée en secondes pendant laquelle chaque composant doit répondre à une notification de mise à jour avec l'opération [DeferComponentUpdate](ipc-component-lifecycle.md#ipc-operation-defercomponentupdate) IPC. Si le composant ne répond pas dans ce délai, le déploiement se poursuit sur le périphérique principal.
La valeur par défaut est de 60 secondes.
1. (Facultatif) Spécifiez la politique de validation de configuration (`configurationValidationPolicy`). Cette politique définit le temps dont dispose chaque composant pour valider une mise à jour de configuration à partir d'un déploiement. Les composants peuvent utiliser l'opération [SubscribeToValidateConfigurationUpdates](ipc-component-configuration.md#ipc-operation-subscribetovalidateconfigurationupdates) IPC pour s'abonner aux notifications relatives à leurs propres mises à jour de configuration. Les composants peuvent ensuite utiliser l'opération [SendConfigurationValidityReport](ipc-component-configuration.md#ipc-operation-sendconfigurationvalidityreport) IPC pour indiquer au logiciel AWS IoT Greengrass principal si la mise à jour de configuration est valide. Si la mise à jour de configuration n'est pas valide, le déploiement échoue.
Cette politique est un objet dont le paramètre est le suivant :
+ `timeoutInSeconds`(Facultatif) Durée en secondes dont dispose chaque composant pour valider une mise à jour de configuration. Si le composant ne répond pas dans ce délai, le déploiement se poursuit sur le périphérique principal.
La valeur par défaut est de 30 secondes.
1. (Facultatif) Spécifiez la politique de gestion des défaillances (`failureHandlingPolicy`). Cette politique est une chaîne qui définit s'il faut ou non annuler les appareils en cas d'échec du déploiement. Sélectionnez parmi les options suivantes :
+ `ROLLBACK`— Si le déploiement échoue sur un périphérique principal, le logiciel AWS IoT Greengrass Core rétablit la configuration précédente de ce périphérique principal.
+ `DO_NOTHING`— Si le déploiement échoue sur un appareil principal, le logiciel AWS IoT Greengrass Core conserve la nouvelle configuration. Cela peut entraîner des composants cassés si la nouvelle configuration n'est pas valide.
La valeur par défaut est `ROLLBACK`.
Votre déploiement dans `deployment.json` peut ressembler à l'exemple suivant :
```
{
"targetArn": "targetArn",
"deploymentName": "deploymentName",
"components": {
"com.example.IndustrialDashboard": {
"componentVersion": "1.0.0",
"configurationUpdate": {
"reset": [
"/network/useHttps",
"/tags"
],
"merge": "{\"tags\":[\"/boiler/1/temperature\",\"/boiler/1/pressure\",\"/boiler/2/temperature\",\"/boiler/2/pressure\"]}"
}
}
},
"deploymentPolicies": {
"componentUpdatePolicy": {
"action": "NOTIFY_COMPONENTS",
"timeoutInSeconds": 30
},
"configurationValidationPolicy": {
"timeoutInSeconds": 60
},
"failureHandlingPolicy": "ROLLBACK"
}
}
```
1. (Facultatif) Définissez le mode d'arrêt, de déploiement ou d'expiration du déploiement. AWS IoT Greengrass utilise des AWS IoT Core tâches pour envoyer des déploiements vers les appareils principaux. Ces options sont donc identiques aux options de configuration des AWS IoT Core tâches. Pour plus d'informations, consultez la section [Déploiement de Job et configuration d'abandon](https://docs.aws.amazon.com/iot/latest/developerguide/job-rollout-abort.html) dans le Guide du *AWS IoT développeur*.
Pour définir les options de la tâche, ajoutez un `iotJobConfiguration` objet à`deployment.json`. Définissez ensuite les options à configurer.
Votre déploiement dans `deployment.json` peut ressembler à l'exemple suivant :
```
{
"targetArn": "targetArn",
"deploymentName": "deploymentName",
"components": {
"com.example.IndustrialDashboard": {
"componentVersion": "1.0.0",
"configurationUpdate": {
"reset": [
"/network/useHttps",
"/tags"
],
"merge": "{\"tags\":[\"/boiler/1/temperature\",\"/boiler/1/pressure\",\"/boiler/2/temperature\",\"/boiler/2/pressure\"]}"
}
}
},
"deploymentPolicies": {
"componentUpdatePolicy": {
"action": "NOTIFY_COMPONENTS",
"timeoutInSeconds": 30
},
"configurationValidationPolicy": {
"timeoutInSeconds": 60
},
"failureHandlingPolicy": "ROLLBACK"
},
"iotJobConfiguration": {
"abortConfig": {
"criteriaList": [
{
"action": "CANCEL",
"failureType": "ALL",
"minNumberOfExecutedThings": 100,
"thresholdPercentage": 5
}
]
},
"jobExecutionsRolloutConfig": {
"exponentialRate": {
"baseRatePerMinute": 5,
"incrementFactor": 2,
"rateIncreaseCriteria": {
"numberOfNotifiedThings": 10,
"numberOfSucceededThings": 5
}
},
"maximumPerMinute": 50
},
"timeoutConfig": {
"inProgressTimeoutInMinutes": 5
}
}
}
```
1. (Facultatif) Ajoutez des balises (`tags`) pour le déploiement. Pour de plus amples informations, veuillez consulter [Marquez vos AWS IoT Greengrass Version 2 ressources](tag-resources.md).
1. Exécutez la commande suivante pour créer le déploiement à partir de`deployment.json`.
```
aws greengrassv2 create-deployment --cli-input-json file://deployment.json
```
La réponse inclut un `deploymentId` identifiant ce déploiement. Vous pouvez utiliser l'ID de déploiement pour vérifier l'état du déploiement. Pour de plus amples informations, veuillez consulter [Vérifier l'état du déploiement](check-deployment-status.md#check-cloud-deployment-status).
# Mettre à jour les configurations des composants
Les configurations de composants sont des objets JSON qui définissent les paramètres de chaque composant. La recette de chaque composant définit sa configuration par défaut, que vous modifiez lorsque vous déployez des composants sur des appareils principaux.
Lorsque vous créez un déploiement, vous pouvez spécifier la *mise à jour de configuration* à appliquer pour chaque composant. Les mises à jour de configuration sont des opérations de correctif, ce qui signifie que la mise à jour modifie la configuration des composants qui existe sur le périphérique principal. Si le périphérique principal ne possède pas le composant, la mise à jour de configuration modifie et applique la configuration par défaut pour ce déploiement.
La mise à jour de configuration définit les mises à jour *réinitialisées* et les mises à jour de *fusion*. Les mises à jour de réinitialisation définissent les valeurs de configuration à rétablir par défaut ou à supprimer. Les mises à jour de fusion définissent les nouvelles valeurs de configuration à définir pour le composant. Lorsque vous déployez une mise à jour de configuration, le logiciel AWS IoT Greengrass Core exécute la mise à jour de réinitialisation avant la mise à jour de fusion.
Les composants peuvent valider les mises à jour de configuration que vous déployez. Le composant s'abonne pour recevoir une notification lorsqu'un déploiement change de configuration, et il peut rejeter une configuration qu'il ne prend pas en charge. Pour de plus amples informations, veuillez consulter [Interagir avec la configuration des composants](ipc-component-configuration.md).
**Topics**
+ [Réinitialiser les mises à](#reset-configuration-update)
+ [Fusion des mises à jour](#merge-configuration-update)
+ [Exemples](#configuration-update-example)
## Réinitialiser les mises à
Les mises à jour de réinitialisation définissent les valeurs de configuration à rétablir à leurs valeurs par défaut sur le périphérique principal. Si aucune valeur de configuration n'a de valeur par défaut, la mise à jour de réinitialisation supprime cette valeur de la configuration du composant. Cela peut vous aider à réparer un composant qui se brise à la suite d'une configuration non valide.
Utilisez une liste de pointeurs JSON pour définir les valeurs de configuration à réinitialiser. Les pointeurs JSON commencent par une barre oblique`/`. Pour identifier une valeur dans une configuration de composants imbriqués, utilisez des barres obliques (`/`) pour séparer les clés de chaque niveau de la configuration. Pour plus d'informations, consultez la [spécification du pointeur JSON](https://tools.ietf.org/html/rfc6901).
**Note**
Vous ne pouvez rétablir les valeurs par défaut que pour une liste entière. Vous ne pouvez pas utiliser les mises à jour de réinitialisation pour réinitialiser un élément individuel d'une liste.
Pour rétablir les valeurs par défaut de l'ensemble de la configuration d'un composant, spécifiez une seule chaîne vide comme mise à jour de réinitialisation.
```
"reset": [""]
```
## Fusion des mises à jour
Les mises à jour de fusion définissent les valeurs de configuration à insérer dans la configuration des composants sur le noyau. La mise à jour de fusion est un objet JSON que le logiciel AWS IoT Greengrass Core fusionne après avoir réinitialisé les valeurs dans les chemins que vous spécifiez dans la mise à jour de réinitialisation. Lorsque vous utilisez le AWS CLI ou AWS SDKs, vous devez sérialiser cet objet JSON sous forme de chaîne.
Vous pouvez fusionner une paire clé-valeur qui n'existe pas dans la configuration par défaut du composant. Vous pouvez également fusionner une paire clé-valeur dont le type est différent de celui de la valeur associée à la même clé. La nouvelle valeur remplace l'ancienne valeur. Cela signifie que vous pouvez modifier la structure de l'objet de configuration.
Vous pouvez fusionner des valeurs nulles avec des chaînes, des listes et des objets vides.
**Note**
Vous ne pouvez pas utiliser les mises à jour par fusion dans le but d'insérer ou d'ajouter un élément à une liste. Vous pouvez remplacer une liste complète ou définir un objet dans lequel chaque élément possède une clé unique.
AWS IoT Greengrass utilise JSON pour les valeurs de configuration. Le JSON spécifie un type de nombre mais ne fait pas la différence entre les nombres entiers et les nombres flottants. Par conséquent, les valeurs de configuration peuvent être converties en valeurs flottantes. AWS IoT Greengrass Pour garantir que votre composant utilise le type de données approprié, nous vous recommandons de définir les valeurs de configuration numériques sous forme de chaînes. Ensuite, demandez à votre composant de les analyser sous forme de nombres entiers ou de nombres flottants. Cela garantit que vos valeurs de configuration sont du même type dans la configuration et sur votre appareil principal.
### Utiliser des variables de recette dans les mises à jour de fusion
Cette fonctionnalité est disponible pour les versions 2.6.0 et ultérieures du composant [Greengrass](greengrass-nucleus-component.md) nucleus.
Si vous définissez l'option de [interpolateComponentConfiguration](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration-interpolate-component-configuration)configuration du noyau de Greengrass sur`true`, vous pouvez utiliser des variables de recette, autres que la variable de recette, dans les mises à `component_dependency_name:configuration:json_pointer` jour de fusion. Par exemple, vous pouvez utiliser la variable de `{iot:thingName}` recette dans une mise à jour de fusion pour inclure le nom de l' AWS IoT objet du périphérique principal dans une valeur de configuration du composant, telle qu'une politique d'[autorisation de communication interprocessus (IPC)](interprocess-communication.md#ipc-authorization-policies).
## Exemples
L'exemple suivant illustre les mises à jour de configuration pour un composant de tableau de bord dont la configuration par défaut est la suivante. Cet exemple de composant affiche des informations sur les équipements industriels.
```
{
"name": null,
"mode": "REQUEST",
"network": {
"useHttps": true,
"port": {
"http": 80,
"https": 443
},
},
"tags": []
}
```
### Recette de composants de tableau de bord industriel
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.IndustrialDashboard",
"ComponentVersion": "1.0.0",
"ComponentDescription": "Displays information about industrial equipment.",
"ComponentPublisher": "Amazon",
"ComponentConfiguration": {
"DefaultConfiguration": {
"name": null,
"mode": "REQUEST",
"network": {
"useHttps": true,
"port": {
"http": 80,
"https": 443
},
},
"tags": []
}
},
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"Run": "python3 -u {artifacts:path}/industrial_dashboard.py"
}
},
{
"Platform": {
"os": "windows"
},
"Lifecycle": {
"Run": "py -3 -u {artifacts:path}/industrial_dashboard.py"
}
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.IndustrialDashboard
ComponentVersion: '1.0.0'
ComponentDescription: Displays information about industrial equipment.
ComponentPublisher: Amazon
ComponentConfiguration:
DefaultConfiguration:
name: null
mode: REQUEST
network:
useHttps: true
port:
http: 80
https: 443
tags: []
Manifests:
- Platform:
os: linux
Lifecycle:
Run: |
python3 -u {artifacts:path}/industrial_dashboard.py
- Platform:
os: windows
Lifecycle:
Run: |
py -3 -u {artifacts:path}/industrial_dashboard.py
```
------
**Example Exemple 1 : mise à jour par fusion**
Vous créez un déploiement qui applique la mise à jour de configuration suivante, qui spécifie une mise à jour par fusion mais pas une mise à jour de réinitialisation. Cette mise à jour de configuration indique au composant d'afficher le tableau de bord sur le port HTTP 8080 avec les données de deux chaudières.
**Configuration à fusionner**
```
{
"name": "Factory 2A",
"network": {
"useHttps": false,
"port": {
"http": 8080
}
},
"tags": [
"/boiler/1/temperature",
"/boiler/1/pressure",
"/boiler/2/temperature",
"/boiler/2/pressure"
]
}
```
La commande suivante crée un déploiement sur un périphérique principal.
```
aws greengrassv2 create-deployment --cli-input-json file://dashboard-deployment.json
```
Le `dashboard-deployment.json` fichier contient le document JSON suivant.
```
{
"targetArn": "arn:aws:iot:us-west-2:123456789012:thing/MyGreengrassCore",
"deploymentName": "Deployment for MyGreengrassCore",
"components": {
"com.example.IndustrialDashboard": {
"componentVersion": "1.0.0",
"configurationUpdate": {
"merge": "{\"name\":\"Factory 2A\",\"network\":{\"useHttps\":false,\"port\":{\"http\":8080}},\"tags\":[\"/boiler/1/temperature\",\"/boiler/1/pressure\",\"/boiler/2/temperature\",\"/boiler/2/pressure\"]}"
}
}
}
}
```
La commande [Greengrass CLI](greengrass-cli-component.md) suivante crée un déploiement local sur un périphérique principal.
```
sudo greengrass-cli deployment create \
--recipeDir recipes \
--artifactDir artifacts \
--merge "com.example.IndustrialDashboard=1.0.0" \
--update-config dashboard-configuration.json
```
Le `dashboard-configuration.json` fichier contient le document JSON suivant.
```
{
"com.example.IndustrialDashboard": {
"MERGE": {
"name": "Factory 2A",
"network": {
"useHttps": false,
"port": {
"http": 8080
}
},
"tags": [
"/boiler/1/temperature",
"/boiler/1/pressure",
"/boiler/2/temperature",
"/boiler/2/pressure"
]
}
}
}
```
Après cette mise à jour, le composant du tableau de bord possède la configuration suivante.
```
{
"name": "Factory 2A",
"mode": "REQUEST",
"network": {
"useHttps": false,
"port": {
"http": 8080,
"https": 443
}
},
"tags": [
"/boiler/1/temperature",
"/boiler/1/pressure",
"/boiler/2/temperature",
"/boiler/2/pressure"
]
}
```
**Example Exemple 2 : réinitialiser et fusionner les mises à jour**
Vous créez ensuite un déploiement qui applique la mise à jour de configuration suivante, qui spécifie une mise à jour de réinitialisation et une mise à jour de fusion. Ces mises à jour indiquent d'afficher le tableau de bord sur le port HTTPS par défaut avec les données des différentes chaudières. Ces mises à jour modifient la configuration qui résulte des mises à jour de configuration de l'exemple précédent.
**Réinitialiser les chemins**
```
[
"/network/useHttps",
"/tags"
]
```
**Configuration à fusionner**
```
{
"tags": [
"/boiler/3/temperature",
"/boiler/3/pressure",
"/boiler/4/temperature",
"/boiler/4/pressure"
]
}
```
La commande suivante crée un déploiement sur un périphérique principal.
```
aws greengrassv2 create-deployment --cli-input-json file://dashboard-deployment2.json
```
Le `dashboard-deployment2.json` fichier contient le document JSON suivant.
```
{
"targetArn": "arn:aws:iot:us-west-2:123456789012:thing/MyGreengrassCore",
"deploymentName": "Deployment for MyGreengrassCore",
"components": {
"com.example.IndustrialDashboard": {
"componentVersion": "1.0.0",
"configurationUpdate": {
"reset": [
"/network/useHttps",
"/tags"
],
"merge": "{\"tags\":[\"/boiler/3/temperature\",\"/boiler/3/pressure\",\"/boiler/4/temperature\",\"/boiler/4/pressure\"]}"
}
}
}
}
```
La commande [Greengrass CLI](greengrass-cli-component.md) suivante crée un déploiement local sur un périphérique principal.
```
sudo greengrass-cli deployment create \
--recipeDir recipes \
--artifactDir artifacts \
--merge "com.example.IndustrialDashboard=1.0.0" \
--update-config dashboard-configuration2.json
```
Le `dashboard-configuration2.json` fichier contient le document JSON suivant.
```
{
"com.example.IndustrialDashboard": {
"RESET": [
"/network/useHttps",
"/tags"
],
"MERGE": {
"tags": [
"/boiler/3/temperature",
"/boiler/3/pressure",
"/boiler/4/temperature",
"/boiler/4/pressure"
]
}
}
}
```
Après cette mise à jour, le composant du tableau de bord possède la configuration suivante.
```
{
"name": "Factory 2A",
"mode": "REQUEST",
"network": {
"useHttps": true,
"port": {
"http": 8080,
"https": 443
}
},
"tags": [
"/boiler/3/temperature",
"/boiler/3/pressure",
"/boiler/4/temperature",
"/boiler/4/pressure",
]
}
```