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. # Tutoriel : Développement d'un composant Greengrass qui reporte les mises à jour des composants Vous pouvez suivre ce didacticiel pour développer un composant qui reporte les mises à jour over-the-air de déploiement. Lorsque vous déployez des mises à jour sur vos appareils, vous souhaiterez peut-être retarder les mises à jour en fonction de certaines conditions, telles que les suivantes : + Le niveau de batterie de l'appareil est faible. + L'appareil exécute un processus ou une tâche qui ne peut pas être interrompu. + L'appareil dispose d'une connexion Internet limitée ou coûteuse. **Note** Un *composant* est un module logiciel qui s'exécute sur les appareils AWS IoT Greengrass principaux. Les composants vous permettent de créer et de gérer des applications complexes sous forme de composants distincts que vous pouvez réutiliser d'un appareil principal de Greengrass à un autre. Dans ce didacticiel, vous allez effectuer les opérations suivantes : 1. Installez le Greengrass Development Kit CLI (GDK CLI) sur votre ordinateur de développement. La CLI GDK fournit des fonctionnalités qui vous aident à développer des composants Greengrass personnalisés. 1. Développez un composant Hello World qui reporte les mises à jour des composants lorsque le niveau de batterie de l'appareil principal est inférieur à un seuil. Ce composant s'abonne aux notifications de mise à jour à l'aide de l'opération [SubscribeToComponentUpdates](ipc-component-lifecycle.md#ipc-operation-subscribetocomponentupdates)IPC. Lorsqu'il reçoit la notification, il vérifie si le niveau de la batterie est inférieur à un seuil personnalisable. Si le niveau de la batterie est inférieur au seuil, la mise à jour est différée de 30 secondes en utilisant le fonctionnement [DeferComponentUpdate](ipc-component-lifecycle.md#ipc-operation-defercomponentupdate)IPC. Vous développez ce composant sur votre ordinateur de développement à l'aide de la CLI GDK. **Note** Ce composant lit le niveau de batterie à partir d'un fichier que vous créez sur l'appareil principal pour imiter une vraie batterie. Vous pouvez donc suivre ce didacticiel sur un appareil principal sans batterie. 1. Publiez ce composant sur le AWS IoT Greengrass service. 1. Déployez ce composant depuis AWS Cloud le périphérique principal de Greengrass pour le tester. Ensuite, vous modifiez le niveau de batterie virtuel sur le périphérique principal et vous créez des déploiements supplémentaires pour voir comment le périphérique principal reporte les mises à jour lorsque le niveau de batterie est faible. Vous pouvez vous attendre à consacrer 20 à 30 minutes à ce didacticiel. # Prérequis Pour suivre ce didacticiel, vous aurez besoin des éléments suivants : + Un Compte AWS. Si vous n'en avez pas, veuillez consulter [Configurez un Compte AWS](setting-up.md#set-up-aws-account). + Un utilisateur Gestion des identités et des accès AWS (IAM) doté d'autorisations d'administrateur. + Un appareil Greengrass Core doté d'une connexion Internet. Pour plus d'informations sur la configuration d'un périphérique principal, consultez[Configuration des appareils AWS IoT Greengrass principaux](setting-up.md). + [Python](https://www.python.org/downloads/) 3.6 ou version ultérieure installé pour tous les utilisateurs sur le périphérique principal et ajouté à la variable d'`PATH`environnement. Sous Windows, le lanceur Python pour Windows doit également être installé pour tous les utilisateurs. **Important** Sous Windows, Python ne s'installe pas pour tous les utilisateurs par défaut. Lorsque vous installez Python, vous devez personnaliser l'installation pour la configurer afin que le logiciel AWS IoT Greengrass Core exécute des scripts Python. Par exemple, si vous utilisez le programme d'installation graphique Python, procédez comme suit : Sélectionnez **Installer le lanceur pour tous les utilisateurs (recommandé).** Choisissez **Customize installation**. Choisissez **Next**. Sélectionnez **Install for all users**. Sélectionnez **Add Python to environment variables**. Choisissez **Installer**. Pour plus d'informations, consultez la section [Utilisation de Python sous Windows](https://docs.python.org/3/using/windows.html) dans la *documentation de Python 3*. + Un ordinateur de développement de type Windows, macOS ou Unix doté d'une connexion Internet. + [Python](https://www.python.org/downloads/) 3.6 ou version ultérieure installé sur votre ordinateur de développement. + [Git](https://git-scm.com/) installé sur votre ordinateur de développement. + AWS Command Line Interface (AWS CLI) installé et configuré avec des informations d'identification sur votre ordinateur de développement. Pour plus d'informations, consultez les [sections Installation, mise à jour et désinstallation du AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) et [Configuration du AWS CLI dans le](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) *guide de l'AWS Command Line Interface utilisateur*. **Note** Si vous utilisez un Raspberry Pi ou un autre appareil ARM 32 bits, installez la AWS CLI V1. AWS CLI La V2 n'est pas disponible pour les appareils ARM 32 bits. Pour plus d'informations, voir [Installation, mise à jour et désinstallation de la AWS CLI version 1](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv1.html). # Étape 1 : Installation de la CLI du kit de développement Greengrass Le [Greengrass Development Kit CLI (GDK CLI](greengrass-development-kit-cli.md)) fournit des fonctionnalités qui vous aident à développer des composants Greengrass personnalisés. Vous pouvez utiliser la CLI GDK pour créer, créer et publier des composants personnalisés. Si vous n'avez pas installé la CLI GDK sur votre ordinateur de développement, procédez comme suit pour l'installer. **Pour installer la dernière version de la CLI GDK** 1. Sur votre ordinateur de développement, exécutez la commande suivante pour installer la dernière version de la CLI GDK à partir de son [GitHubréférentiel](https://github.com/aws-greengrass/aws-greengrass-gdk-cli). ``` python3 -m pip install -U git+https://github.com/aws-greengrass/aws-greengrass-gdk-cli.git@v1.6.2 ``` 1. Exécutez la commande suivante pour vérifier que la CLI GDK a été correctement installée. ``` gdk --help ``` Si la `gdk` commande est introuvable, ajoutez son dossier dans PATH. + Sur les appareils Linux, ajoutez `/home/MyUser/.local/bin` à PATH et remplacez-le par *MyUser* le nom de votre utilisateur. + Sur les appareils Windows, ajoutez `PythonPath\\Scripts` à PATH et remplacez-le par *PythonPath* le chemin d'accès au dossier Python de votre appareil. # Étape 2 : développer un composant qui reporte les mises à jour Dans cette section, vous allez développer un composant Hello World en Python qui reporte les mises à jour des composants lorsque le niveau de batterie de l'appareil principal est inférieur à un seuil que vous configurez lorsque vous déployez le composant. Dans ce composant, vous utilisez l'[interface de communication interprocessus (IPC)](interprocess-communication.md) de la Kit SDK des appareils AWS IoT version v2 pour Python. Vous utilisez l'opération [SubscribeToComponentUpdates](ipc-component-lifecycle.md#ipc-operation-subscribetocomponentupdates)IPC pour recevoir des notifications lorsque le périphérique principal reçoit un déploiement. Ensuite, vous utilisez l'opération [DeferComponentUpdate](ipc-component-lifecycle.md#ipc-operation-defercomponentupdate)IPC pour différer ou accuser réception de la mise à jour en fonction du niveau de batterie de l'appareil. **Pour développer un composant Hello World qui reporte les mises à jour** 1. Sur votre ordinateur de développement, créez un dossier pour le code source du composant. ``` mkdir com.example.BatteryAwareHelloWorld cd com.example.BatteryAwareHelloWorld ``` 1. Utilisez un éditeur de texte pour créer un fichier nommé`gdk-config.json`. La CLI GDK lit le [fichier de configuration de la CLI GDK](gdk-cli-configuration-file.md), nommé`gdk-config.json`, pour créer et publier des composants. Ce fichier de configuration se trouve à la racine du dossier du composant. Par exemple, sur un système basé sur Linux, vous pouvez exécuter la commande suivante pour utiliser GNU nano pour créer le fichier. ``` nano gdk-config.json ``` Copiez le code JSON suivant dans le fichier. + Remplacez *Amazon* par votre nom. + *us-west-2*Remplacez-le par celui Région AWS où fonctionne votre appareil principal. La CLI GDK y publie le composant. Région AWS + *greengrass-component-artifacts*Remplacez-le par le préfixe du compartiment S3 à utiliser. Lorsque vous utilisez la CLI GDK pour publier le composant, la CLI GDK télécharge les artefacts du composant dans le compartiment S3 dont le nom est formé à partir de cette valeur, du Région AWS, et de votre Compte AWS identifiant au format suivant :. `bucketPrefix-region-accountId` Par exemple, si vous spécifiez **greengrass-component-artifacts** et **us-west-2** que votre Compte AWS identifiant est**123456789012**, la CLI GDK utilise le compartiment S3 nommé`greengrass-component-artifacts-us-west-2-123456789012`. ``` { "component": { "com.example.BatteryAwareHelloWorld": { "author": "Amazon", "version": "NEXT_PATCH", "build": { "build_system" : "zip" }, "publish": { "region": "us-west-2", "bucket": "greengrass-component-artifacts" } } }, "gdk_version": "1.0.0" } ``` Le fichier de configuration spécifie les éléments suivants : + Version à utiliser lorsque la CLI GDK publie le composant Greengrass sur AWS IoT Greengrass le service cloud. `NEXT_PATCH`indique de choisir la prochaine version du correctif après la dernière version disponible dans le service AWS IoT Greengrass cloud. Si le composant n'a pas encore de version dans le service AWS IoT Greengrass cloud, la CLI GDK l'utilise`1.0.0`. + Le système de génération du composant. Lorsque vous utilisez le système de `zip` génération, la CLI GDK empaquète la source du composant dans un fichier ZIP qui devient l'artefact unique du composant. + L' Région AWS endroit où la CLI GDK publie le composant Greengrass. + Le préfixe du compartiment S3 dans lequel la CLI GDK télécharge les artefacts du composant. 1. Utilisez un éditeur de texte pour créer le code source du composant dans un fichier nommé`main.py`. Par exemple, sur un système basé sur Linux, vous pouvez exécuter la commande suivante pour utiliser GNU nano pour créer le fichier. ``` nano main.py ``` Copiez le code Python suivant dans le fichier. ``` import json import os import sys import time import traceback from pathlib import Path from awsiot.greengrasscoreipc.clientv2 import GreengrassCoreIPCClientV2 HELLO_WORLD_PRINT_INTERVAL = 15 # Seconds DEFER_COMPONENT_UPDATE_INTERVAL = 30 * 1000 # Milliseconds class BatteryAwareHelloWorldPrinter(): def __init__(self, ipc_client: GreengrassCoreIPCClientV2, battery_file_path: Path, battery_threshold: float): self.battery_file_path = battery_file_path self.battery_threshold = battery_threshold self.ipc_client = ipc_client self.subscription_operation = None def on_component_update_event(self, event): try: if event.pre_update_event is not None: if self.is_battery_below_threshold(): self.defer_update(event.pre_update_event.deployment_id) print('Deferred update for deployment %s' % event.pre_update_event.deployment_id) else: self.acknowledge_update( event.pre_update_event.deployment_id) print('Acknowledged update for deployment %s' % event.pre_update_event.deployment_id) elif event.post_update_event is not None: print('Applied update for deployment') except: traceback.print_exc() def subscribe_to_component_updates(self): if self.subscription_operation == None: # SubscribeToComponentUpdates returns a tuple with the response and the operation. _, self.subscription_operation = self.ipc_client.subscribe_to_component_updates( on_stream_event=self.on_component_update_event) def close_subscription(self): if self.subscription_operation is not None: self.subscription_operation.close() self.subscription_operation = None def defer_update(self, deployment_id): self.ipc_client.defer_component_update( deployment_id=deployment_id, recheck_after_ms=DEFER_COMPONENT_UPDATE_INTERVAL) def acknowledge_update(self, deployment_id): # Specify recheck_after_ms=0 to acknowledge a component update. self.ipc_client.defer_component_update( deployment_id=deployment_id, recheck_after_ms=0) def is_battery_below_threshold(self): return self.get_battery_level() < self.battery_threshold def get_battery_level(self): # Read the battery level from the virtual battery level file. with self.battery_file_path.open('r') as f: data = json.load(f) return float(data['battery_level']) def print_message(self): message = 'Hello, World!' if self.is_battery_below_threshold(): message += ' Battery level (%d) is below threshold (%d), so the component will defer updates' % ( self.get_battery_level(), self.battery_threshold) else: message += ' Battery level (%d) is above threshold (%d), so the component will acknowledge updates' % ( self.get_battery_level(), self.battery_threshold) print(message) def main(): # Read the battery threshold and virtual battery file path from command-line args. args = sys.argv[1:] battery_threshold = float(args[0]) battery_file_path = Path(args[1]) print('Reading battery level from %s and deferring updates when below %d' % ( str(battery_file_path), battery_threshold)) try: # Create an IPC client and a Hello World printer that defers component updates. ipc_client = GreengrassCoreIPCClientV2() hello_world_printer = BatteryAwareHelloWorldPrinter( ipc_client, battery_file_path, battery_threshold) hello_world_printer.subscribe_to_component_updates() try: # Keep the main thread alive, or the process will exit. while True: hello_world_printer.print_message() time.sleep(HELLO_WORLD_PRINT_INTERVAL) except InterruptedError: print('Subscription interrupted') hello_world_printer.close_subscription() except Exception: print('Exception occurred', file=sys.stderr) traceback.print_exc() exit(1) if __name__ == '__main__': main() ``` Cette application Python effectue les opérations suivantes : + Lit le niveau de batterie de l'appareil principal à partir d'un fichier de niveau de batterie virtuel que vous créerez ultérieurement sur l'appareil principal. Ce fichier de niveau de batterie virtuel imite une vraie batterie. Vous pouvez donc suivre ce didacticiel sur les principaux appareils dépourvus de batterie. + Lit les arguments de ligne de commande pour le seuil de batterie et le chemin d'accès au fichier de niveau de batterie virtuel. La recette du composant définit ces arguments de ligne de commande en fonction des paramètres de configuration, afin que vous puissiez personnaliser ces valeurs lorsque vous déployez le composant. + Utilise le client IPC V2 dans le [Kit SDK des appareils AWS IoT V2 pour que Python](https://github.com/aws/aws-iot-device-sdk-python-v2) communique avec le logiciel AWS IoT Greengrass Core. Par rapport au client IPC d'origine, le client IPC V2 réduit la quantité de code que vous devez écrire pour utiliser IPC dans des composants personnalisés. + S'abonne pour mettre à jour les notifications à l'aide de l'[SubscribeToComponentUpdates](ipc-component-lifecycle.md#ipc-operation-subscribetocomponentupdates)opération IPC. Le logiciel AWS IoT Greengrass Core envoie des notifications avant et après chaque déploiement. Le composant appelle la fonction suivante chaque fois qu'il reçoit une notification. Si la notification concerne un déploiement à venir, le composant vérifie si le niveau de la batterie est inférieur à un seuil. Si le niveau de la batterie est inférieur au seuil, le composant reporte la mise à jour de 30 secondes en utilisant le fonctionnement [DeferComponentUpdate](ipc-component-lifecycle.md#ipc-operation-defercomponentupdate)IPC. Dans le cas contraire, si le niveau de la batterie n'est pas inférieur au seuil, le composant accuse réception de la mise à jour afin que celle-ci puisse se poursuivre. ``` def on_component_update_event(self, event): try: if event.pre_update_event is not None: if self.is_battery_below_threshold(): self.defer_update(event.pre_update_event.deployment_id) print('Deferred update for deployment %s' % event.pre_update_event.deployment_id) else: self.acknowledge_update( event.pre_update_event.deployment_id) print('Acknowledged update for deployment %s' % event.pre_update_event.deployment_id) elif event.post_update_event is not None: print('Applied update for deployment') except: traceback.print_exc() ``` **Note** Le logiciel AWS IoT Greengrass Core n'envoie pas de notifications de mise à jour pour les déploiements locaux. Vous déployez donc ce composant à l'aide du service AWS IoT Greengrass cloud pour le tester. 1. Utilisez un éditeur de texte pour créer la recette du composant dans un fichier nommé `recipe.json` ou`recipe.yaml`. La *recette* du composant définit les métadonnées du composant, les paramètres de configuration par défaut et les scripts de cycle de vie spécifiques à la plate-forme. ------ #### [ JSON ] Par exemple, sur un système basé sur Linux, vous pouvez exécuter la commande suivante pour utiliser GNU nano pour créer le fichier. ``` nano recipe.json ``` Copiez le code JSON suivant dans le fichier. ``` { "RecipeFormatVersion": "2020-01-25", "ComponentName": "COMPONENT_NAME", "ComponentVersion": "COMPONENT_VERSION", "ComponentDescription": "This Hello World component defers updates when the battery level is below a threshold.", "ComponentPublisher": "COMPONENT_AUTHOR", "ComponentConfiguration": { "DefaultConfiguration": { "BatteryThreshold": 50, "LinuxBatteryFilePath": "/home/ggc_user/virtual_battery.json", "WindowsBatteryFilePath": "C:\\Users\\ggc_user\\virtual_battery.json" } }, "Manifests": [ { "Platform": { "os": "linux" }, "Lifecycle": { "install": "python3 -m pip install --user awsiotsdk --upgrade", "Run": "python3 -u {artifacts:decompressedPath}/com.example.BatteryAwareHelloWorld/main.py \"{configuration:/BatteryThreshold}\" \"{configuration:/LinuxBatteryFilePath}\"" }, "Artifacts": [ { "Uri": "s3://BUCKET_NAME/COMPONENT_NAME/COMPONENT_VERSION/com.example.BatteryAwareHelloWorld.zip", "Unarchive": "ZIP" } ] }, { "Platform": { "os": "windows" }, "Lifecycle": { "install": "py -3 -m pip install --user awsiotsdk --upgrade", "Run": "py -3 -u {artifacts:decompressedPath}/com.example.BatteryAwareHelloWorld/main.py \"{configuration:/BatteryThreshold}\" \"{configuration:/WindowsBatteryFilePath}\"" }, "Artifacts": [ { "Uri": "s3://BUCKET_NAME/COMPONENT_NAME/COMPONENT_VERSION/com.example.BatteryAwareHelloWorld.zip", "Unarchive": "ZIP" } ] } ] } ``` ------ #### [ YAML ] Par exemple, sur un système basé sur Linux, vous pouvez exécuter la commande suivante pour utiliser GNU nano pour créer le fichier. ``` nano recipe.yaml ``` Copiez le code YAML suivant dans le fichier. ``` --- RecipeFormatVersion: "2020-01-25" ComponentName: "COMPONENT_NAME" ComponentVersion: "COMPONENT_VERSION" ComponentDescription: "This Hello World component defers updates when the battery level is below a threshold." ComponentPublisher: "COMPONENT_AUTHOR" ComponentConfiguration: DefaultConfiguration: BatteryThreshold: 50 LinuxBatteryFilePath: "/home/ggc_user/virtual_battery.json" WindowsBatteryFilePath: "C:\\Users\\ggc_user\\virtual_battery.json" Manifests: - Platform: os: linux Lifecycle: install: python3 -m pip install --user awsiotsdk --upgrade Run: python3 -u {artifacts:decompressedPath}/com.example.BatteryAwareHelloWorld/main.py "{configuration:/BatteryThreshold}" "{configuration:/LinuxBatteryFilePath}" Artifacts: - Uri: "s3://BUCKET_NAME/COMPONENT_NAME/COMPONENT_VERSION/com.example.BatteryAwareHelloWorld.zip" Unarchive: ZIP - Platform: os: windows Lifecycle: install: py -3 -m pip install --user awsiotsdk --upgrade Run: py -3 -u {artifacts:decompressedPath}/com.example.BatteryAwareHelloWorld/main.py "{configuration:/BatteryThreshold}" "{configuration:/WindowsBatteryFilePath}" Artifacts: - Uri: "s3://BUCKET_NAME/COMPONENT_NAME/COMPONENT_VERSION/com.example.BatteryAwareHelloWorld.zip" Unarchive: ZIP ``` ------ Cette recette précise les éléments suivants : + Paramètres de configuration par défaut pour le seuil de batterie, le chemin du fichier de batterie virtuel sur les appareils principaux Linux et le chemin du fichier de batterie virtuel sur les appareils principaux de Windows. + Un `install` cycle de vie qui installe la dernière version de la Kit SDK des appareils AWS IoT v2 pour Python. + Un `run` cycle de vie qui exécute l'application Python dans`main.py`. + Espaces réservés, tels que `COMPONENT_NAME` et`COMPONENT_VERSION`, où la CLI GDK remplace les informations lorsqu'elle crée la recette du composant. Pour plus d'informations sur les recettes de composants, consultez[AWS IoT Greengrass référence de recette de composant](component-recipe-reference.md). # Étape 3 : Publier le composant sur le AWS IoT Greengrass service Dans cette section, vous publiez le composant Hello World sur le service AWS IoT Greengrass cloud. Une fois qu'un composant est disponible dans le service AWS IoT Greengrass cloud, vous pouvez le déployer sur les appareils principaux. Vous utilisez la CLI GDK pour publier le composant depuis votre ordinateur de développement vers le service AWS IoT Greengrass cloud. La CLI GDK télécharge la recette et les artefacts du composant pour vous. **Pour publier le composant Hello World sur le AWS IoT Greengrass service** 1. Exécutez la commande suivante pour créer le composant à l'aide de la CLI GDK. La [commande component build](greengrass-development-kit-cli-component.md#greengrass-development-kit-cli-component-build) crée une recette et des artefacts basés sur le fichier de configuration de la CLI GDK. Au cours de ce processus, la CLI GDK crée un fichier ZIP contenant le code source du composant. ``` gdk component build ``` Vous devriez voir des messages similaires à ceux de l'exemple suivant. ``` [2022-04-28 11:20:16] INFO - Getting project configuration from gdk-config.json [2022-04-28 11:20:16] INFO - Found component recipe file 'recipe.yaml' in the project directory. [2022-04-28 11:20:16] INFO - Building the component 'com.example.BatteryAwareHelloWorld' with the given project configuration. [2022-04-28 11:20:16] INFO - Using 'zip' build system to build the component. [2022-04-28 11:20:16] WARNING - This component is identified as using 'zip' build system. If this is incorrect, please exit and specify custom build command in the 'gdk-config.json'. [2022-04-28 11:20:16] INFO - Zipping source code files of the component. [2022-04-28 11:20:16] INFO - Copying over the build artifacts to the greengrass component artifacts build folder. [2022-04-28 11:20:16] INFO - Updating artifact URIs in the recipe. [2022-04-28 11:20:16] INFO - Creating component recipe in 'C:\Users\finthomp\greengrassv2\com.example.BatteryAwareHelloWorld\greengrass-build\recipes'. ``` 1. Exécutez la commande suivante pour publier le composant sur le service AWS IoT Greengrass cloud. La [commande de publication du composant](greengrass-development-kit-cli-component.md#greengrass-development-kit-cli-component-publish) télécharge l'artefact du fichier ZIP du composant dans un compartiment S3. Ensuite, il met à jour l'URI S3 du fichier ZIP dans la recette du composant et télécharge la recette vers le AWS IoT Greengrass service. Au cours de ce processus, la CLI GDK vérifie quelle version du composant Hello World est déjà disponible dans le service AWS IoT Greengrass cloud, afin de pouvoir choisir la version de correctif suivante après cette version. Si le composant n'existe pas encore, la CLI GDK utilise la version`1.0.0`. ``` gdk component publish ``` Vous devriez voir des messages similaires à ceux de l'exemple suivant. La sortie indique la version du composant créée par la CLI GDK. ``` [2022-04-28 11:20:29] INFO - Getting project configuration from gdk-config.json [2022-04-28 11:20:29] INFO - Found component recipe file 'recipe.yaml' in the project directory. [2022-04-28 11:20:29] INFO - Found credentials in shared credentials file: ~/.aws/credentials [2022-04-28 11:20:30] INFO - No private version of the component 'com.example.BatteryAwareHelloWorld' exist in the account. Using '1.0.0' as the next version to create. [2022-04-28 11:20:30] INFO - Publishing the component 'com.example.BatteryAwareHelloWorld' with the given project configuration. [2022-04-28 11:20:30] INFO - Uploading the component built artifacts to s3 bucket. [2022-04-28 11:20:30] INFO - Uploading component artifacts to S3 bucket: greengrass-component-artifacts-us-west-2-123456789012. If this is your first time using this bucket, add the 's3:GetObject' permission to each core device's token exchange role to allow it to download the component artifacts. For more information, see https://docs.aws.amazon.com/greengrass/v2/developerguide/device-service-role.html. [2022-04-28 11:20:30] INFO - Not creating an artifacts bucket as it already exists. [2022-04-28 11:20:30] INFO - Updating the component recipe com.example.BatteryAwareHelloWorld-1.0.0. [2022-04-28 11:20:31] INFO - Creating a new greengrass component com.example.BatteryAwareHelloWorld-1.0.0 [2022-04-28 11:20:31] INFO - Created private version '1.0.0' of the component in the account.'com.example.BatteryAwareHelloWorld'. ``` 1. Copiez le nom du compartiment S3 depuis la sortie. Vous utiliserez le nom du compartiment ultérieurement pour autoriser le périphérique principal à télécharger les artefacts des composants à partir de ce compartiment. 1. (Facultatif) Affichez le composant dans la AWS IoT Greengrass console pour vérifier qu'il a été correctement chargé. Procédez comme suit : 1. Dans le menu de navigation de la [AWS IoT Greengrass console](https://console.aws.amazon.com/greengrass), sélectionnez **Composants**. 1. Sur la page **Composants**, choisissez l'onglet **Mes composants**, puis sélectionnez **com.example.BatteryAwareHelloWorld**. Sur cette page, vous pouvez consulter la recette du composant ainsi que d'autres informations le concernant. 1. Autorisez le périphérique principal à accéder aux artefacts des composants dans le compartiment S3. Chaque appareil principal possède un [rôle IAM principal](device-service-role.md) qui lui permet d'interagir avec le AWS cloud AWS IoT et d'envoyer des journaux vers celui-ci. Ce rôle de périphérique n'autorise pas l'accès aux compartiments S3 par défaut. Vous devez donc créer et associer une politique permettant au périphérique principal de récupérer les artefacts des composants du compartiment S3. Si le rôle de votre appareil autorise déjà l'accès au compartiment S3, vous pouvez ignorer cette étape. Sinon, créez une politique IAM autorisant l'accès et associez-la au rôle, comme suit : 1. Dans le menu de navigation de [la console IAM](https://console.aws.amazon.com/iam), choisissez **Policies**, puis **Create policy**. 1. Sur l'onglet **JSON**, remplacez le contenu de l'espace réservé par la stratégie suivante. *greengrass-component-artifacts-us-west-2-123456789012*Remplacez-le par le nom du compartiment S3 dans lequel la CLI GDK a téléchargé les artefacts du composant. Par exemple, si vous l'avez spécifié **greengrass-component-artifacts** **us-west-2** dans le fichier de configuration de la CLI GDK et que votre Compte AWS identifiant est**123456789012**, la CLI GDK utilise le compartiment S3 nommé. `greengrass-component-artifacts-us-west-2-123456789012` ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "s3:GetObject" ], "Resource": "arn:aws:s3:::greengrass-component-artifacts-us-west-2-123456789012/*" } ] } ``` ------ 1. Choisissez **Suivant**. 1. Dans la **section Détails de la politique**, pour **Nom**, entrez**MyGreengrassV2ComponentArtifactPolicy**. 1. Choisissez **Create Policy** (Créer une politique). 1. **Dans le menu de navigation de [la console IAM](https://console.aws.amazon.com/iam), choisissez Role, puis choisissez le nom du rôle pour le périphérique principal.** Vous avez spécifié ce nom de rôle lors de l'installation du logiciel AWS IoT Greengrass Core. Si vous n'avez pas spécifié de nom, le nom par défaut est`GreengrassV2TokenExchangeRole`. 1. Sous **Autorisations**, choisissez **Ajouter des autorisations**, puis choisissez **Joindre des politiques**. 1. Sur la page **Ajouter des autorisations**, cochez la case à côté de la `MyGreengrassV2ComponentArtifactPolicy` politique que vous avez créée, puis choisissez **Ajouter des autorisations**. # Étape 4 : Déployer et tester le composant sur un appareil principal Dans cette section, vous déployez le composant sur le périphérique principal pour tester ses fonctionnalités. Sur l'appareil principal, vous créez le fichier de niveau de batterie virtuel pour imiter une batterie réelle. Ensuite, vous créez des déploiements supplémentaires et vous observez les fichiers journaux des composants sur le périphérique principal pour voir le composant différer et accuser réception des mises à jour. **Pour déployer et tester le composant Hello World qui reporte les mises à jour** 1. Utilisez un éditeur de texte pour créer un fichier de niveau de batterie virtuel. Ce fichier imite une vraie batterie. + Sur les appareils principaux de Linux, créez un fichier nommé`/home/ggc_user/virtual_battery.json`. Exécutez l'éditeur de texte avec `sudo` des autorisations. + Sur les appareils principaux de Windows, créez un fichier nommé`C:\Users\ggc_user\virtual_battery.json`. Exécutez l'éditeur de texte en tant qu'administrateur. Par exemple, sur un système basé sur Linux, vous pouvez exécuter la commande suivante pour utiliser GNU nano pour créer le fichier. ``` sudo nano /home/ggc_user/virtual_battery.json ``` Copiez le code JSON suivant dans le fichier. ``` { "battery_level": 50 } ``` 1. Déployez le composant Hello World sur l'appareil principal. Procédez comme suit : 1. Dans le menu de navigation de la [AWS IoT Greengrass console](https://console.aws.amazon.com/greengrass), sélectionnez **Composants**. 1. Sur la page **Composants**, choisissez l'onglet **Mes composants**, puis sélectionnez **com.example.BatteryAwareHelloWorld**. 1. Sur la page **com.example.BatteryAwareHelloWorld**, choisissez **Deploy (Déployer)**. 1. Dans **Ajouter au déploiement**, choisissez un déploiement existant à réviser ou choisissez de créer un nouveau déploiement, puis choisissez **Suivant**. 1. Si vous avez choisi de créer un nouveau déploiement, choisissez le périphérique principal ou le groupe d'objets cible pour le déploiement. Sur la page **Spécifier la cible**, sous **Cible de déploiement**, choisissez un périphérique principal ou un groupe d'objets, puis cliquez sur **Suivant**. 1. Sur la page **Sélectionner les composants**, vérifiez que le **com.example.BatteryAwareHelloWorld**composant est sélectionné, puis choisissez **Next**. 1. Sur la page **Configurer les composants**, sélectionnez **com.example.BatteryAwareHelloWorld**, puis effectuez les opérations suivantes : 1. Choisissez **Configure component (Configurer un composant)**. 1. Dans le com.example.BatteryAwareHelloWorld mode **Configurer**, sous **Mise à jour de la configuration**, dans **Configuration à fusionner**, entrez la mise à jour de configuration suivante. ``` { "BatteryThreshold": 70 } ``` 1. Choisissez **Confirmer** pour fermer le modal, puis cliquez sur **Suivant**. 1. Sur la page **Confirmer les paramètres avancés**, dans la section **Politiques de déploiement**, sous **Politique de mise à jour des composants**, vérifiez que l'option **Notifier les composants** est sélectionnée. L'option **Notifier les composants** est sélectionnée par défaut lorsque vous créez un nouveau déploiement. 1. Sur la page **Review (Révision)**, choisissez **Deploy (Déployer)**. Le déploiement peut prendre jusqu'à une minute. 1. Le logiciel AWS IoT Greengrass Core enregistre les données standard des processus des composants dans les fichiers journaux du `logs` dossier. Exécutez la commande suivante pour vérifier que le composant Hello World s'exécute et imprime des messages d'état. ------ #### [ Linux or Unix ] ``` sudo tail -f /greengrass/v2/logs/com.example.BatteryAwareHelloWorld.log ``` ------ #### [ Windows Command Prompt (CMD) ] ``` type C:\greengrass\v2\logs\com.example.BatteryAwareHelloWorld.log ``` ------ #### [ PowerShell ] ``` gc C:\greengrass\v2\logs\com.example.BatteryAwareHelloWorld.log -Tail 10 -Wait ``` ------ Vous devriez voir des messages similaires à ceux de l'exemple suivant. ``` Hello, World! Battery level (50) is below threshold (70), so the component will defer updates. ``` **Note** Si le fichier n'existe pas, le déploiement n'est peut-être pas encore terminé. Si le fichier n'existe pas dans les 30 secondes, le déploiement a probablement échoué. Cela peut se produire si le périphérique principal n'est pas autorisé à télécharger les artefacts du composant depuis le compartiment S3, par exemple. Exécutez la commande suivante pour afficher le fichier journal du logiciel AWS IoT Greengrass Core. Ce fichier inclut les journaux du service de déploiement de l'appareil principal Greengrass. ``` sudo tail -f /greengrass/v2/logs/greengrass.log ``` ``` type C:\greengrass\v2\logs\greengrass.log ``` La `type` commande écrit le contenu du fichier sur le terminal. Exécutez cette commande plusieurs fois pour observer les modifications apportées au fichier. ``` gc C:\greengrass\v2\logs\greengrass.log -Tail 10 -Wait ``` 1. Créez un nouveau déploiement sur le périphérique principal pour vérifier que le composant reporte la mise à jour. Procédez comme suit : 1. Dans le menu de navigation de la [AWS IoT Greengrass console](https://console.aws.amazon.com/greengrass), sélectionnez **Déploiements.** 1. Choisissez le déploiement que vous avez créé ou révisé précédemment. 1. Sur la page de déploiement, choisissez **Revise**. 1. Dans le mode **de déploiement Revise**, choisissez **Revise le déploiement**. 1. Choisissez **Next** à chaque étape, puis choisissez **Deploy**. 1. Exécutez la commande suivante pour consulter à nouveau les journaux du composant et vérifier que la mise à jour est différée. ------ #### [ Linux or Unix ] ``` sudo tail -f /greengrass/v2/logs/com.example.BatteryAwareHelloWorld.log ``` ------ #### [ Windows Command Prompt (CMD) ] ``` type C:\greengrass\v2\logs\com.example.BatteryAwareHelloWorld.log ``` ------ #### [ PowerShell ] ``` gc C:\greengrass\v2\logs\com.example.BatteryAwareHelloWorld.log -Tail 10 -Wait ``` ------ Vous devriez voir des messages similaires à ceux de l'exemple suivant. Le composant reporte la mise à jour de 30 secondes, de sorte qu'il imprime ce message à plusieurs reprises. ``` Deferred update for deployment 50722a95-a05f-4e2a-9414-da80103269aa. ``` 1. Utilisez un éditeur de texte pour modifier le fichier de niveau de batterie virtuel et remplacer le niveau de batterie par une valeur supérieure au seuil, afin que le déploiement puisse se poursuivre. + Sur les appareils principaux de Linux, modifiez le fichier nommé`/home/ggc_user/virtual_battery.json`. Exécutez l'éditeur de texte avec `sudo` des autorisations. + Sur les appareils principaux de Windows, modifiez le fichier nommé`C:\Users\ggc_user\virtual_battery.json`. Exécutez l'éditeur de texte en tant qu'administrateur. Par exemple, sur un système basé sur Linux, vous pouvez exécuter la commande suivante pour utiliser GNU nano pour créer le fichier. ``` sudo nano /home/ggc_user/virtual_battery.json ``` Réglez le niveau de la batterie sur`80`. ``` { "battery_level": 80 } ``` 1. Exécutez la commande suivante pour consulter à nouveau les journaux du composant et vérifier qu'il accuse réception de la mise à jour. ------ #### [ Linux or Unix ] ``` sudo tail -f /greengrass/v2/logs/com.example.BatteryAwareHelloWorld.log ``` ------ #### [ Windows Command Prompt (CMD) ] ``` type C:\greengrass\v2\logs\com.example.BatteryAwareHelloWorld.log ``` ------ #### [ PowerShell ] ``` gc C:\greengrass\v2\logs\com.example.BatteryAwareHelloWorld.log -Tail 10 -Wait ``` ------ Vous devriez voir des messages similaires aux exemples suivants. ``` Hello, World! Battery level (80) is above threshold (70), so the component will acknowledge updates. Acknowledged update for deployment f9499eb2-4a40-40a7-86c1-c89887d859f1. ``` Vous avez terminé ce didacticiel. Le composant Hello World reporte ou accuse réception des mises à jour en fonction du niveau de batterie de l'appareil principal. Pour plus d'informations sur les sujets abordés dans ce didacticiel, consultez les rubriques suivantes : + [Développer des AWS IoT Greengrass composants](develop-greengrass-components.md) + [Déployer AWS IoT Greengrass des composants sur des appareils](manage-deployments.md) + [Utilisez le Kit SDK des appareils AWS IoT pour communiquer avec le noyau de Greengrass, les autres composants et AWS IoT CoreCommuniquez avec le noyau de Greengrass, les autres composants et AWS IoT Core](interprocess-communication.md) + [AWS IoT Greengrass Interface de ligne de commande du kit de développement](greengrass-development-kit-cli.md)