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. # Exporter des flux de données vers AWS Cloud (console) Ce didacticiel explique comment utiliser la AWS IoT console pour configurer et déployer un AWS IoT Greengrass groupe avec le gestionnaire de flux activé. Le groupe contient une fonction Lambda définie par l'utilisateur qui écrit dans un flux dans le gestionnaire de flux, qui est ensuite exportée automatiquement vers le. AWS Cloud Le gestionnaire de flux rend l'ingestion, le traitement et l'exportation de flux de données volumineux plus efficaces et plus fiables. Dans ce didacticiel, vous allez créer une fonction `TransferStream` Lambda qui consomme des données IoT. La fonction Lambda utilise le SDK AWS IoT Greengrass Core pour créer un flux dans le gestionnaire de flux, puis y lire et écrire. Le gestionnaire de flux exporte ensuite le flux vers Kinesis Data Streams. Le schéma suivant illustre ce flux de travail. ![\[Diagramme du flux de travail de gestion des flux.\]](http://docs.aws.amazon.com/fr_fr/greengrass/v1/developerguide/images/stream-manager-scenario.png) L'objectif de ce didacticiel est de montrer comment les fonctions Lambda définies par l'utilisateur utilisent `StreamManagerClient` l'objet du SDK Core pour interagir avec AWS IoT Greengrass le gestionnaire de flux. Pour des raisons de simplicité, la fonction Python Lambda que vous créez pour ce didacticiel génère des données de périphérique simulées. ## Conditions préalables Pour suivre ce didacticiel, vous devez disposer des éléments suivants : + Un groupe Greengrass et un noyau Greengrass (v1.10 ou version ultérieure). Pour plus d'informations sur la création d'un groupe et d'un noyau Greengrass, consultez. [Commencer avec AWS IoT Greengrass](gg-gs.md) Le didacticiel de mise en route inclut également les étapes d'installation du logiciel AWS IoT Greengrass Core. **Note** Le gestionnaire de flux n'est pas pris en charge sur OpenWrt les distributions. + L'environnement d'exécution Java 8 (JDK 8) installé sur l'appareil principal (noyau). + Pour les distributions basées sur Debian (y compris Raspbian) ou Ubuntu, exécutez la commande suivante : ``` sudo apt install openjdk-8-jdk ``` + Pour les distributions basées sur Red Hat (y compris Amazon Linux), exécutez la commande suivante : ``` sudo yum install java-1.8.0-openjdk ``` Pour de plus amples informations, veuillez consulter [How to download and install prebuilt OpenJDK packages](https://openjdk.java.net/install/) sur le site web OpenJDK. + AWS IoT Greengrass SDK de base pour Python v1.5.0 ou version ultérieure. Pour l'utiliser `StreamManagerClient` dans le SDK de AWS IoT Greengrass base pour Python, vous devez : + Installez Python 3.7 ou version ultérieure sur le périphérique principal. + Incluez le SDK et ses dépendances dans votre package de déploiement de fonctions Lambda. Des instructions sont fournies dans ce didacticiel. **Astuce** Vous pouvez utiliser `StreamManagerClient` avec Java ou NodeJS. Pour un exemple de code, consultez le [SDK AWS IoT Greengrass Core pour](https://github.com/aws/aws-greengrass-core-sdk-java/blob/master/samples/StreamManagerKinesis/src/main/java/com/amazonaws/greengrass/examples/StreamManagerKinesis.java) Java [AWS IoT Greengrass et le SDK Core pour](https://github.com/aws/aws-greengrass-core-sdk-js/blob/master/greengrassExamples/StreamManagerKinesis/index.js) Node.js sur. GitHub + Un flux de destination nommé **MyKinesisStream** créé dans Amazon Kinesis Data Streams au Région AWS même titre que votre groupe Greengrass. Pour plus d'informations, consultez la section [Créer un flux](https://docs.aws.amazon.com/streams/latest/dev/fundamental-stream.html#create-stream) dans le manuel *Amazon Kinesis Developer Guide*. **Note** Dans ce didacticiel, le gestionnaire de flux exporte les données vers Kinesis Data Streams, ce qui entraîne des frais pour Compte AWS votre. Pour plus d'informations sur les tarifs, consultez la section Tarification de [Kinesis Data Streams](https://aws.amazon.com/kinesis/data-streams/pricing/). Pour éviter des frais, vous pouvez exécuter ce didacticiel sans créer de flux de données Kinesis. Dans ce cas, vous devez vérifier dans les journaux que le gestionnaire de flux a tenté d'exporter le flux vers Kinesis Data Streams. + Une politique IAM ajoutée à [Rôle de groupe Greengrass](group-role.md) celle qui autorise l'`kinesis:PutRecords`action sur le flux de données cible, comme indiqué dans l'exemple suivant : ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "kinesis:PutRecords" ], "Resource": [ "arn:aws:kinesis:us-east-1:123456789012:stream/MyKinesisStream" ] } ] } ``` ------ Le didacticiel contient les étapes détaillées suivantes : 1. [Création d'un package de déploiement de fonctions Lambda](#stream-manager-console-create-deployment-package) 1. [Création d’une fonction Lambda ](#stream-manager-console-create-function) 1. [Ajouter une fonction au groupe](#stream-manager-console-create-gg-function) 1. [Activer le gestionnaire de flux](#stream-manager-console-enable-stream-manager) 1. [Configurer la journalisation locale](#stream-manager-console-configure-logging) 1. [Déployer le groupe](#stream-manager-console-create-deployment) 1. [Tester l'application](#stream-manager-console-test-application) Le didacticiel devrait prendre environ 20 minutes. ## Étape 1 : Création d'un package de déploiement de fonctions Lambda Au cours de cette étape, vous allez créer un package de déploiement de fonctions Lambda qui contient le code de fonction Python et ses dépendances. Vous téléchargerez ce package ultérieurement lorsque vous créerez la fonction Lambda dans. AWS Lambda La fonction Lambda utilise le SDK AWS IoT Greengrass Core pour créer et interagir avec des flux locaux. **Note** Vos fonctions Lambda définies par l'utilisateur doivent utiliser [AWS IoT Greengrass le SDK Core](lambda-functions.md#lambda-sdks-core) pour interagir avec le gestionnaire de flux. Pour de plus amples informations sur les conditions requises pour le gestionnaire de flux Greengrass, veuillez consulter les [conditions requises pour le gestionnaire de flux Greengrass](stream-manager.md#stream-manager-requirements). 1. Téléchargez le [SDK AWS IoT Greengrass de base pour Python](lambda-functions.md#lambda-sdks-core) v1.5.0 ou version ultérieure. 1. Décompressez le package téléchargé pour obtenir le kit SDK. Le kit SDK est représenté par le dossier `greengrasssdk`. 1. Installez les dépendances du package à inclure avec le SDK dans votre package de déploiement de fonctions Lambda. 1. Accédez au répertoire SDK qui contient le fichier `requirements.txt`. Ce fichier répertorie les dépendances. 1. Installez les dépendances du kit SDK. Par exemple, exécutez la commande `pip` suivante pour les installer dans le répertoire en cours : ``` pip install --target . -r requirements.txt ``` 1. Enregistrez la fonction de code Python suivante dans un fichier local nommé `transfer_stream.py`. **Astuce** Pour un exemple de code utilisant Java et NodeJS, consultez [AWS IoT Greengrass le SDK Core pour [AWS IoT Greengrass Java et](https://github.com/aws/aws-greengrass-core-sdk-js/blob/master/greengrassExamples/StreamManagerKinesis/index.js) le SDK Core](https://github.com/aws/aws-greengrass-core-sdk-java/blob/master/samples/StreamManagerKinesis/src/main/java/com/amazonaws/greengrass/examples/StreamManagerKinesis.java) pour Node.js sur. GitHub ``` import asyncio import logging import random import time from greengrasssdk.stream_manager import ( ExportDefinition, KinesisConfig, MessageStreamDefinition, ReadMessagesOptions, ResourceNotFoundException, StrategyOnFull, StreamManagerClient, ) # This example creates a local stream named "SomeStream". # It starts writing data into that stream and then stream manager automatically exports # the data to a customer-created Kinesis data stream named "MyKinesisStream". # This example runs forever until the program is stopped. # The size of the local stream on disk will not exceed the default (which is 256 MB). # Any data appended after the stream reaches the size limit continues to be appended, and # stream manager deletes the oldest data until the total stream size is back under 256 MB. # The Kinesis data stream in the cloud has no such bound, so all the data from this script is # uploaded to Kinesis and you will be charged for that usage. def main(logger): try: stream_name = "SomeStream" kinesis_stream_name = "MyKinesisStream" # Create a client for the StreamManager client = StreamManagerClient() # Try deleting the stream (if it exists) so that we have a fresh start try: client.delete_message_stream(stream_name=stream_name) except ResourceNotFoundException: pass exports = ExportDefinition( kinesis=[KinesisConfig(identifier="KinesisExport" + stream_name, kinesis_stream_name=kinesis_stream_name)] ) client.create_message_stream( MessageStreamDefinition( name=stream_name, strategy_on_full=StrategyOnFull.OverwriteOldestData, export_definition=exports ) ) # Append two messages and print their sequence numbers logger.info( "Successfully appended message to stream with sequence number %d", client.append_message(stream_name, "ABCDEFGHIJKLMNO".encode("utf-8")), ) logger.info( "Successfully appended message to stream with sequence number %d", client.append_message(stream_name, "PQRSTUVWXYZ".encode("utf-8")), ) # Try reading the two messages we just appended and print them out logger.info( "Successfully read 2 messages: %s", client.read_messages(stream_name, ReadMessagesOptions(min_message_count=2, read_timeout_millis=1000)), ) logger.info("Now going to start writing random integers between 0 and 1000 to the stream") # Now start putting in random data between 0 and 1000 to emulate device sensor input while True: logger.debug("Appending new random integer to stream") client.append_message(stream_name, random.randint(0, 1000).to_bytes(length=4, signed=True, byteorder="big")) time.sleep(1) except asyncio.TimeoutError: logger.exception("Timed out while executing") except Exception: logger.exception("Exception while running") def function_handler(event, context): return logging.basicConfig(level=logging.INFO) # Start up this sample code main(logger=logging.getLogger()) ``` 1. Compressez les éléments suivants dans un fichier nommé `transfer_stream_python.zip`. Il s'agit de votre package de déploiement de fonctions Lambda. + **transfer\$1stream.py**. Logique d'application. + **greengrasssdk**. Bibliothèque requise pour les fonctions Python Greengrass Lambda qui publient des messages MQTT. Les [opérations du gestionnaire de flux](work-with-streams.md) sont disponibles dans la version 1.5.0 ou ultérieure du SDK AWS IoT Greengrass Core pour Python. + Les dépendances que vous avez installées pour le SDK AWS IoT Greengrass Core pour Python (par exemple, les `cbor2` répertoires). Lorsque vous créez le fichier `zip`, incluez uniquement ces éléments, et non le dossier conteneur. ## Étape 2 : création d’une fonction Lambda Au cours de cette étape, vous allez utiliser la AWS Lambda console pour créer une fonction Lambda et la configurer pour utiliser votre package de déploiement. Vous publiez ensuite une version de fonction et créez un alias. 1. Créez d'abord la fonction Lambda. 1. Dans le AWS Management Console, choisissez **Services**, puis ouvrez la AWS Lambda console. 1. Choisissez **Créer une fonction**, puis sélectionnez **Auteur à partir de zéro**. 1. Dans la section **Informations de base**, spécifiez les valeurs suivantes : + Sous **Nom de la fonction**, saisissez **TransferStream**. + Pour **Runtime**, sélectionnez **Python 3.7**. + Pour **les autorisations**, conservez le paramètre par défaut. Cela crée un rôle d'exécution qui accorde des autorisations Lambda de base. Ce rôle n'est pas utilisé par AWS IoT Greengrass. 1. Dans le bas de la page, choisissez **Create function**. 1. Enregistrez ensuite le gestionnaire et téléchargez le package de déploiement de votre fonction Lambda. 1. Dans l'onglet **Code**, sous **Source du code**, choisissez **Télécharger depuis**. Dans le menu déroulant, sélectionnez le **fichier .zip.** ![\[La liste déroulante Upload from avec le fichier .zip surligné.\]](http://docs.aws.amazon.com/fr_fr/greengrass/v1/developerguide/images/lra-console/upload-deployment-package.png) 1. Choisissez **Upload**, puis choisissez votre package `transfer_stream_python.zip` de déploiement. Ensuite, choisissez **Enregistrer**. 1. Dans l'onglet **Code** de la fonction, sous **Paramètres d'exécution**, choisissez **Modifier**, puis entrez les valeurs suivantes. + Pour **Runtime**, sélectionnez **Python 3.7**. + Pour **Handler (Gestionnaire)**, entrez **transfer\$1stream.function\$1handler**. 1. Choisissez **Enregistrer**. **Note** Le bouton **Test** de la AWS Lambda console ne fonctionne pas avec cette fonction. Le SDK AWS IoT Greengrass principal ne contient pas les modules nécessaires pour exécuter vos fonctions Greengrass Lambda de manière indépendante dans la console. AWS Lambda Ces modules (par exemple`greengrass_common`) sont fournis aux fonctions après leur déploiement sur votre noyau Greengrass. 1. À présent, publiez la première version de votre fonction Lambda et créez un [alias pour](https://docs.aws.amazon.com/lambda/latest/dg/versioning-aliases.html) cette version. **Note** Les groupes Greengrass peuvent référencer une fonction Lambda par alias (recommandé) ou par version. L'utilisation d'un alias facilite la gestion des mises à jour du code, car vous n'avez pas à modifier votre table d'abonnement ou la définition de groupe lorsque le code de fonction est mis à jour. Au lieu de cela, il vous suffit de pointer l'alias vers la nouvelle version de la fonction. 1. Dans le menu **Actions**, sélectionnez **Publier une nouvelle version**. 1. Dans **Description de la version**, saisissez **First version**, puis choisissez **Publish**. 1. Sur la page de configuration **TransferStream: 1**, dans le menu **Actions**, choisissez **Créer un alias**. 1. Sur la page **Create a new alias**, utilisez les valeurs suivantes : + Pour **Nom**, saisissez **GG\$1TransferStream**. + Pour **Version**, choisissez **1**. **Note** AWS IoT Greengrass **ne prend pas en charge les alias Lambda pour les versions \$1LATEST.** 1. Choisissez **Créer**. Vous êtes maintenant prêt à ajouter la fonction Lambda à votre groupe Greengrass. ## Étape 3 : Ajouter une fonction Lambda au groupe Greengrass Au cours de cette étape, vous ajoutez la fonction Lambda au groupe, puis vous configurez son cycle de vie et ses variables d'environnement. Pour de plus amples informations, veuillez consulter [Contrôle de l'exécution des fonctions Greengrass Lambda à l'aide d'une configuration spécifique au groupe](lambda-group-config.md). 1. Dans le volet de navigation de la AWS IoT console, sous **Gérer**, développez les **appareils Greengrass**, puis choisissez **Groups (V1)**. 1. Choisissez le groupe cible. 1. Sur la page de configuration du groupe, choisissez l'onglet **Fonctions Lambda**. 1. **Sous **Mes fonctions Lambda**, choisissez Ajouter.** 1. Sur la page **Ajouter une fonction Lambda, choisissez la fonction** Lambda **pour votre fonction Lambda**. 1. **Pour la **version Lambda**, choisissez Alias:GG\$1. TransferStream** Configurez maintenant les propriétés qui déterminent le comportement de la fonction Lambda dans le groupe Greengrass. 1. Dans la section **Configuration de la fonction Lambda**, apportez les modifications suivantes : + Définissez **Limite de mémoire** sur 32 Mo. + Pour **Épinglé**, choisissez **True**. **Note** Une fonction Lambda de *longue durée* (ou *épinglée*) démarre automatiquement après AWS IoT Greengrass le démarrage et continue de s'exécuter dans son propre conteneur. Cela contraste avec une fonction Lambda *à la demande*, qui démarre lorsqu'elle est invoquée et s'arrête lorsqu'il ne reste plus aucune tâche à exécuter. Pour de plus amples informations, veuillez consulter [Configuration du cycle de vie pour les fonctions Greengrass Lambda](lambda-functions.md#lambda-lifecycle). 1. Choisissez **Ajouter une fonction Lambda**. ## Étape 4 : Activer le gestionnaire de flux Dans cette étape, vous vous assurez que le gestionnaire de flux est activé. 1. Sur la page de configuration du groupe, choisissez l'onglet **Fonctions Lambda**. 1. Sous **Fonctions Lambda du système**, sélectionnez **Stream Manager** et vérifiez l'état. Si l'état est désactivé, choisissez **Modifier**. Ensuite, choisissez **Activer** et **Enregistrer**. Vous pouvez utiliser les paramètres par défaut pour ce didacticiel. Pour de plus amples informations, veuillez consulter [Configuration du gestionnaire de AWS IoT Greengrass flux](configure-stream-manager.md). **Note** Lorsque vous utilisez la console pour activer le gestionnaire de flux et déployer le groupe, la taille de la mémoire du gestionnaire de flux est définie sur 4194 304 Ko (4 Go) par défaut. Nous vous recommandons de définir la taille de la mémoire sur au moins 128 000 Ko. ## Étape 5 : Configurer la journalisation locale Au cours de cette étape, vous configurez les composants AWS IoT Greengrass du système, les fonctions Lambda définies par l'utilisateur et les connecteurs du groupe pour écrire des journaux dans le système de fichiers du périphérique principal. Vous pouvez utiliser les journaux pour résoudre les problèmes que vous rencontrez. Pour de plus amples informations, veuillez consulter [Surveillance à l'aide de AWS IoT Greengrass journaux](greengrass-logs-overview.md). 1. Sous **Configuration des journaux locaux**, vérifiez si la journalisation locale est configurée. 1. **Si les journaux ne sont pas configurés pour les composants du système Greengrass ou pour les fonctions Lambda définies par l'utilisateur, choisissez Modifier.** 1. Choisissez le niveau de journal des **fonctions Lambda de l'utilisateur et le niveau de journal** du système **Greengrass**. 1. Conservez les valeurs par défaut de niveau de journalisation et de limite d'espace disque, puis choisissez **Enregistrer**. ## Étape 6 : Déployer le groupe Greengrass Déployer le groupe sur l'appareil principal (noyau) 1. Assurez-vous que le AWS IoT Greengrass noyau fonctionne. Dans la fenêtre de terminal de votre Raspberry Pi, exécutez les commandes suivantes, si nécessaire. 1. Pour vérifier si le démon est en cours d'exécution : ``` ps aux | grep -E 'greengrass.*daemon' ``` Si la sortie contient une entrée `root` pour `/greengrass/ggc/packages/ggc-version/bin/daemon`, le démon est en cours d'exécution. **Note** La version indiquée dans le chemin dépend de la version du logiciel AWS IoT Greengrass Core installée sur votre appareil principal. 1. Pour démarrer le daemon, procédez comme suit : ``` cd /greengrass/ggc/core/ sudo ./greengrassd start ``` 1. Sur la page de configuration du groupe, choisissez **Deploy**. 1. 1. **Dans l'onglet **Fonctions Lambda**, sous la section **Fonctions Lambda** du système, sélectionnez **Détecteur IP** et choisissez Modifier.** 1. Dans la boîte de dialogue **Modifier les paramètres du détecteur IP**, sélectionnez **Détecter et remplacer automatiquement les points de terminaison du broker MQTT**. 1. Choisissez **Enregistrer**. Les appareils peuvent ainsi acquérir automatiquement des informations de connectivité pour le noyau, telles que l'adresse IP, le DNS et le numéro de port. La détection automatique est recommandée, mais elle prend AWS IoT Greengrass également en charge les points de terminaison spécifiés manuellement. Vous êtes uniquement invité à indiquer la méthode de découverte lors du déploiement initial du groupe. **Note** Si vous y êtes invité, autorisez la création du rôle de [service Greengrass et associez-le à votre rôle](service-role.md) Compte AWS dans le service actuel. Région AWS Ce rôle permet d'accéder AWS IoT Greengrass à vos ressources dans les AWS services. La page **Déploiements** indique l'horodatage, l'ID de version et l'état du déploiement. Une fois terminé, le statut affiché pour le déploiement doit être **Terminé**. Pour bénéficier d'une aide à la résolution des problèmes, consultez [Résolution des problèmes AWS IoT Greengrass](gg-troubleshooting.md). ## Étape 7 : Tester l'application La fonction `TransferStream` Lambda génère des données d'appareil simulées. Elle écrit des données dans un flux que le gestionnaire de flux exporte vers le flux de données Kinesis cible. 1. Dans la console Amazon Kinesis, sous **Kinesis data** streams, sélectionnez. **MyKinesisStream** **Note** Si vous avez exécuté le didacticiel sans flux de données Kinesis cible, [recherchez dans le fichier journal](stream-manager-cli.md#stream-manager-cli-logs) le gestionnaire de flux (`GGStreamManager`). S'il contient `export stream MyKinesisStream doesn't exist` dans un message d'erreur, le test est réussi. Cette erreur signifie que le service a essayé d'effectuer une exportation vers le flux mais que le flux n'existe pas. 1. Sur la **MyKinesisStream**page, choisissez **Surveillance**. Si le test réussit, vous devriez voir des données dans les graphiques **PutRecords** . Selon votre connexion, l'affichage des données peut prendre une minute. **Important** Lorsque vous avez terminé le test, supprimez le flux de données Kinesis pour éviter d'entraîner des frais supplémentaires. Vous pouvez aussi exécuter la commande suivante pour arrêter le démon Greengrass. Cela empêche le noyau d'envoyer des messages jusqu'à ce que vous soyez prêt à continuer le test. ``` cd /greengrass/ggc/core/ sudo ./greengrassd stop ``` 1. Supprimez la fonction **TransferStream**Lambda du noyau. 1. Dans le volet de navigation de la AWS IoT console, sous **Gérer**, développez les **appareils Greengrass**, puis choisissez **Groups (V1)**. 1. Dans la **section Groupes Greengrass**, choisissez votre groupe. 1. Sur la page **Lambdas**, choisissez les ellipses (**...**) pour la **TransferStream**fonction, puis choisissez **Supprimer** la fonction. 1. Sous **Actions**, choisissez **Deploy (Déployer)**. Pour afficher les informations de journalisation ou résoudre les problèmes liés aux flux, recherchez les fonctions `GGStreamManager` et `TransferStream` dans les journaux. Vous devez être `root` autorisé à lire AWS IoT Greengrass les journaux du système de fichiers. + `TransferStream` écrit les entrées de journal dans `greengrass-root/ggc/var/log/user/region/account-id/TransferStream.log`. + `GGStreamManager` écrit les entrées de journal dans `greengrass-root/ggc/var/log/system/GGStreamManager.log`. Si vous avez besoin d'informations supplémentaires sur le dépannage, vous pouvez [définir le niveau de journalisation](#stream-manager-console-configure-logging) des **journaux User Lambda** sur **Debug logs**, puis redéployer le groupe. ## Consultez aussi + [Gérez les flux de données sur le AWS IoT Greengrass cœur](stream-manager.md) + [Configuration du gestionnaire de AWS IoT Greengrass flux](configure-stream-manager.md) + [StreamManagerClient À utiliser pour travailler avec des flux](work-with-streams.md) + [Exporter les configurations pour les AWS Cloud destinations prises en charge](stream-export-configurations.md) + [Exporter des flux de données vers le AWS Cloud (CLI)](stream-manager-cli.md)