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.
# Gérez les flux de données sur le AWS IoT Greengrass cœur
AWS IoT Greengrass le gestionnaire de flux facilite et rend plus fiable le transfert de gros volumes de données IoT vers le AWS Cloud. Le gestionnaire de flux traite les flux de données localement et les exporte AWS Cloud automatiquement vers le. Cette fonctionnalité s'intègre aux scénarios périphériques courants, tels que l'inférence d'apprentissage automatique (ML), dans le cadre desquels les données sont traitées et analysées localement avant d'être exportées vers des destinations de stockage locales AWS Cloud ou locales.
Le gestionnaire de flux simplifie le développement d'applications. Vos applications IoT peuvent utiliser un mécanisme standardisé pour traiter les flux à volume élevé et gérer les stratégies de conservation des données locales au lieu de créer des fonctionnalités de gestion des flux personnalisées. Les applications IoT peuvent lire et écrire dans des flux. Elles peuvent définir des stratégies pour le type et la taille du stockage, ainsi que pour la conservation des données par flux afin de contrôler la façon dont le gestionnaire de flux traite et exporte les flux.
Le gestionnaire de flux est conçu pour fonctionner dans des environnements à connectivité intermittente ou limitée. Vous pouvez définir l'utilisation de la bande passante, le comportement du délai d'expiration et la façon dont les données du flux sont traitées lorsque le noyau est connecté ou déconnecté. Pour les données critiques, vous pouvez définir des priorités afin de contrôler l'ordre dans lequel les flux sont exportés vers le AWS Cloud.
Vous pouvez configurer des exportations automatiques vers le à des AWS Cloud fins de stockage ou de traitement et d'analyse ultérieurs. Le gestionnaire de flux prend en charge l'exportation vers les AWS Cloud destinations suivantes.
+ Canaux entrants AWS IoT Analytics. AWS IoT Analytics vous permet d'effectuer une analyse avancée de vos données afin de prendre des décisions commerciales et d'améliorer les modèles d'apprentissage automatique. Pour plus d'informations, voir [Qu'est-ce que c'est AWS IoT Analytics ?](https://docs.aws.amazon.com/iotanalytics/latest/userguide/welcome.html) dans le *guide de AWS IoT Analytics l'utilisateur*.
+ Streams dans Kinesis Data Streams. Kinesis Data Streams est couramment utilisé pour agréger de gros volumes de données et les charger dans un entrepôt de données ou un cluster Map-Reduce. Pour plus d'informations, consultez [Qu'est-ce qu'Amazon Kinesis Data Streams ?](https://docs.aws.amazon.com/streams/latest/dev/what-is-this-service.html) dans le manuel *Amazon Kinesis Developer Guide*.
+ Propriétés des actifs dans AWS IoT SiteWise. AWS IoT SiteWise vous permet de collecter, d'organiser et d'analyser les données des équipements industriels à grande échelle. Pour plus d'informations, voir [Qu'est-ce que c'est AWS IoT SiteWise ?](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/what-is-sitewise.html) dans le *guide de AWS IoT SiteWise l'utilisateur*.
+ Objets dans Amazon S3. Vous pouvez utiliser Amazon S3 pour stocker et récupérer de grandes quantités de données. Pour plus d'informations, consultez [Qu'est-ce qu'Amazon S3 ?](https://docs.aws.amazon.com/AmazonS3/latest/dev/Welcome.html) dans le *guide du développeur Amazon Simple Storage Service*.
## Flux de travail de gestion des flux
Vos applications IoT interagissent avec le gestionnaire de flux via le SDK AWS IoT Greengrass Core. Dans un flux de travail simple, une fonction Lambda définie par l'utilisateur exécutée sur le cœur de Greengrass consomme des données IoT, telles que des séries chronologiques de température et de pression. La fonction Lambda peut filtrer ou compresser les données, puis appeler le SDK AWS IoT Greengrass Core pour écrire les données dans un flux dans le gestionnaire de flux. Le gestionnaire de flux peut exporter le flux vers le AWS Cloud automatiquement, en fonction des politiques définies pour le flux. Les fonctions Lambda définies par l'utilisateur peuvent également envoyer des données directement vers des bases de données locales ou des référentiels de stockage.
Vos applications IoT peuvent inclure plusieurs fonctions Lambda définies par l'utilisateur qui lisent ou écrivent dans des flux. Ces fonctions Lambda locales peuvent lire et écrire dans des flux pour filtrer, agréger et analyser les données localement. Cela permet de répondre rapidement aux événements locaux et d'extraire des informations précieuses avant que les données ne soient transférées du noyau vers le cloud ou vers des destinations locales.
Le diagramme suivant présente un exemple de flux de travail.
![\[Diagramme du flux de travail du gestionnaire de flux.\]](http://docs.aws.amazon.com/fr_fr/greengrass/v1/developerguide/images/stream-manager-architecture.png)
Pour utiliser le gestionnaire de flux, commencez par configurer les paramètres du gestionnaire de flux pour définir les paramètres d'exécution au niveau du groupe qui s'appliquent à tous les flux du noyau de Greengrass. Ces paramètres personnalisables vous permettent de contrôler la manière dont le gestionnaire de flux stocke, traite et exporte les flux en fonction des besoins de votre entreprise et des contraintes environnementales. Pour de plus amples informations, veuillez consulter [Configuration du gestionnaire de AWS IoT Greengrass flux](configure-stream-manager.md).
Après avoir configuré le gestionnaire de flux, vous pouvez créer et déployer vos applications IoT. Il s'agit généralement de fonctions Lambda définies par l'utilisateur qui sont `StreamManagerClient` utilisées dans AWS IoT Greengrass le SDK Core pour créer et interagir avec des flux. Lors de la création du flux, la fonction Lambda définit les politiques par flux, telles que les destinations d'exportation, la priorité et la persistance. Pour plus d'informations, y compris les extraits de code pour les `StreamManagerClient` opérations, consultez. [StreamManagerClient À utiliser pour travailler avec des flux](work-with-streams.md)
Pour les didacticiels qui configurent un flux de travail simple, voir [Exporter des flux de données vers AWS Cloud (console)](stream-manager-console.md) ou[Exporter des flux de données vers le AWS Cloud (CLI)](stream-manager-cli.md).
## Prérequis
Les exigences suivantes s'appliquent à l'utilisation du gestionnaire de flux :
+ Vous devez utiliser le logiciel AWS IoT Greengrass Core v1.10 ou version ultérieure, avec le gestionnaire de flux activé. Pour de plus amples informations, veuillez consulter [Configuration du gestionnaire de AWS IoT Greengrass flux](configure-stream-manager.md).
Le gestionnaire de flux n'est pas pris en charge sur OpenWrt les distributions.
+ L'environnement d'exécution Java 8 (JDK 8) doit être installé sur le 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.
+ Le gestionnaire de flux nécessite un minimum de 70 Mo de RAM en plus de votre logiciel AWS IoT Greengrass Core de base. Vos besoins totaux en mémoire dépendent de votre charge de travail.
+ Les 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. Le SDK de AWS IoT Greengrass base est disponible en plusieurs langues, mais seules les versions suivantes prennent en charge les opérations du gestionnaire de flux :
+ SDK Java (v1.4.0 ou version ultérieure)
+ SDK Python (v1.5.0 ou version ultérieure)
+ SDK Node.js (v1.6.0 ou version ultérieure)
Téléchargez la version du SDK correspondant à l'environnement d'exécution de votre fonction Lambda et incluez-la dans votre package de déploiement de fonctions Lambda.
**Note**
Le SDK de AWS IoT Greengrass base pour Python nécessite Python 3.7 ou version ultérieure et comporte d'autres dépendances de package. Pour plus d'informations, voir [Créer un package de déploiement de fonctions Lambda (console) ou Créer un package](stream-manager-console.md#stream-manager-console-create-deployment-package) [de déploiement de fonctions Lambda (CLI](stream-manager-cli.md#stream-manager-cli-create-deployment-package)).
+ Si vous définissez des destinations AWS Cloud d'exportation pour un flux, vous devez créer vos cibles d'exportation et accorder des autorisations d'accès dans le rôle de groupe Greengrass. Selon la destination, d'autres exigences peuvent également s'appliquer. Pour plus d’informations, consultez :
+ [AWS IoT Analytics chaînes](stream-export-configurations.md#export-to-iot-analytics)
+ [Flux de données Amazon Kinesis](stream-export-configurations.md#export-to-kinesis)
+ [AWS IoT SiteWise propriétés des actifs](stream-export-configurations.md#export-to-iot-sitewise)
+ [Objets Amazon S3](stream-export-configurations.md#export-to-s3)
Vous êtes responsable de la maintenance de ces AWS Cloud ressources.
## Sécurité des données
Lorsque vous utilisez le gestionnaire de flux, tenez compte des considérations de sécurité suivantes.
### Sécurité des données locales
AWS IoT Greengrass ne chiffre pas les données de flux au repos ou en transit localement entre les composants du périphérique principal.
+ **Données au repos**. Les données de flux sont stockées localement dans un répertoire de stockage sur le cœur de Greengrass. Pour la sécurité des données, AWS IoT Greengrass s'appuie sur les autorisations de fichiers Unix et le chiffrement complet du disque, s'il est activé. Vous pouvez utiliser le paramètre facultatif [STREAM\$1MANAGER\$1STORE\$1ROOT\$1DIR](configure-stream-manager.md#STREAM_MANAGER_STORE_ROOT_DIR) pour spécifier le répertoire de stockage. Si vous modifiez ce paramètre ultérieurement pour utiliser un autre répertoire de stockage, AWS IoT Greengrass cela ne supprime pas le répertoire de stockage précédent ni son contenu.
+ **Données en transit localement**. AWS IoT Greengrass ne chiffre pas les données de flux en transit local sur le cœur entre les sources de données, les fonctions Lambda, AWS IoT Greengrass le SDK principal et le gestionnaire de flux.
+ **Données en transit vers le AWS Cloud**. Les flux de données exportés par le gestionnaire de flux AWS Cloud utilisent le chiffrement standard du client de AWS service avec le protocole TLS (Transport Layer Security).
Pour de plus amples informations, veuillez consulter [Chiffrement des données](data-encryption.md).
### Authentification client
Les clients du gestionnaire de flux utilisent le SDK AWS IoT Greengrass Core pour communiquer avec le gestionnaire de flux. Lorsque l'authentification du client est activée, seules les fonctions Lambda du groupe Greengrass peuvent interagir avec les flux dans le gestionnaire de flux. Lorsque l'authentification client est désactivée, tout processus s'exécutant sur le noyau Greengrass (tels que les [conteneurs Docker](docker-app-connector.md)) peut interagir avec les flux du gestionnaire de flux. Vous ne devez désactiver l'authentification que si votre analyse de rentabilisation l'exige.
Vous utilisez le paramètre [STREAM\$1MANAGER\$1AUTHENTICATE\$1CLIENT](configure-stream-manager.md#STREAM_MANAGER_AUTHENTICATE_CLIENT) pour définir le mode d'authentification du client. Vous pouvez configurer ce paramètre depuis la console ou AWS IoT Greengrass l'API. Les modifications prennent effet après le déploiement du groupe.
****
| | Activé | Désactivées |
| --- | --- | --- |
| Valeur de paramètre | `true` (valeur par défaut et recommandée) | `false` |
| Clients autorisés | Fonctions Lambda définies par l'utilisateur dans le groupe Greengrass | Fonctions Lambda définies par l'utilisateur dans le groupe Greengrass Autres processus en cours d'exécution sur l'appareil principal Greengrass |
## Consultez aussi
+ [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 AWS Cloud (console)](stream-manager-console.md)
+ [Exporter des flux de données vers le AWS Cloud (CLI)](stream-manager-cli.md)
# Configuration du gestionnaire de AWS IoT Greengrass flux
À la AWS IoT Greengrass base, le gestionnaire de flux peut stocker, traiter et exporter les données des appareils IoT. Le gestionnaire de flux fournit les paramètres que vous utilisez pour configurer les paramètres d'exécution au niveau du groupe. Ces paramètres s'appliquent à tous les flux sur le noyau Greengrass. Vous pouvez utiliser la AWS IoT console ou l' AWS IoT Greengrass API pour configurer les paramètres du gestionnaire de flux. Les modifications prennent effet après le déploiement du groupe.
**Note**
Après avoir configuré le gestionnaire de flux, vous pouvez créer et déployer des applications IoT qui s'exécutent sur le cœur de Greengrass et interagissent avec le gestionnaire de flux. Ces applications IoT sont généralement des fonctions Lambda définies par l'utilisateur. Pour de plus amples informations, veuillez consulter [StreamManagerClient À utiliser pour travailler avec des flux](work-with-streams.md).
## Paramètres du gestionnaire de flux
Le gestionnaire de flux fournit les paramètres suivants qui vous permettent de définir des paramètres au niveau du groupe. Tous les paramètres sont facultatifs.
**Répertoire de stockage**
Nom du paramètre: `STREAM_MANAGER_STORE_ROOT_DIR`
Chemin absolu du répertoire local utilisé pour stocker les flux. Cette valeur doit commencer par une barre oblique (par exemple, `/data`).
Pour de plus amples informations sur la sécurité des données de flux, veuillez consulter [Sécurité des données locales](stream-manager.md#stream-manager-security-stream-data).
Version minimale AWS IoT Greengrass du noyau : 1.10.0
**Server port**
Nom du paramètre: `STREAM_MANAGER_SERVER_PORT`
Numéro de port local utilisé pour communiquer avec le gestionnaire de flux. La valeur par défaut est `8088`.
Version minimale AWS IoT Greengrass du noyau : 1.10.0
**Authentification du client**
Nom du paramètre: `STREAM_MANAGER_AUTHENTICATE_CLIENT`
Indique si les clients doivent être authentifiés pour interagir avec le gestionnaire de flux. Toutes les interactions entre les clients et le gestionnaire de flux sont contrôlées par le SDK AWS IoT Greengrass Core. Ce paramètre détermine quels clients peuvent appeler le SDK AWS IoT Greengrass Core pour travailler avec des flux. Pour de plus amples informations, veuillez consulter [Authentification client](stream-manager.md#stream-manager-security-client-authentication).
Les valeurs valides sont `true` ou `false`. La valeur par défaut est `true` (recommandé).
+ `true`. Autorise uniquement les fonctions Greengrass Lambda en tant que clients. Les clients de fonctions Lambda utilisent des protocoles internes de AWS IoT Greengrass base pour s'authentifier auprès du AWS IoT Greengrass SDK principal.
+ `false`. Permet à tout processus exécuté sur le AWS IoT Greengrass noyau d'être un client. Ne définissez pas ce paramètre sur `false`, à moins que votre analyse de rentabilisation ne l'exige. Par exemple, définissez cette valeur `false` uniquement si les processus non Lambda du périphérique principal doivent communiquer directement avec le gestionnaire de flux, tels que les [conteneurs Docker](docker-app-connector.md) exécutés sur le périphérique principal.
Version minimale AWS IoT Greengrass du noyau : 1.10.0
**Bande passante maximum**
Nom du paramètre: `STREAM_MANAGER_EXPORTER_MAX_BANDWIDTH`
Bande passante maximale moyenne (en kilobits par seconde) pouvant être utilisée pour exporter des données. La valeur par défaut permet une utilisation illimitée de la bande passante disponible.
Version minimale AWS IoT Greengrass du noyau : 1.10.0
**Taille du groupe de threads**
Nom du paramètre: `STREAM_MANAGER_EXPORTER_THREAD_POOL_SIZE`
Nombre maximal de threads actifs pouvant être utilisés pour exporter des données. La valeur par défaut est `5`.
La taille optimale dépend de votre matériel, du volume de flux et du nombre planifié de flux d'exportation. Si votre vitesse d'exportation est faible, vous pouvez ajuster ce paramètre afin de trouver la taille optimale en fonction de votre matériel et de votre analyse de rentabilisation. Le processeur et la mémoire de votre appareil principal sont des facteurs limitatifs. Pour commencer, vous pouvez essayer de définir cette valeur par le nombre de cœurs de processeur sur l'appareil.
Veillez à ne pas définir une taille supérieure à ce que votre matériel peut prendre en charge. Chaque flux consomme des ressources matérielles. Vous devez donc essayer de limiter le nombre de flux d'exportation sur les appareils soumis à des contraintes.
Version minimale AWS IoT Greengrass du noyau : 1.10.0
**Arguments JVM**
Nom du paramètre: `JVM_ARGS`
Arguments JVM (machine virtuelle Java) personnalisés à transmettre au gestionnaire de flux au démarrage. Les arguments doivent être séparés par des espaces.
Utilisez ce paramètre uniquement lorsque vous devez remplacer les paramètres par défaut utilisés par la JVM. Par exemple, il peut s'avérer nécessaire d'augmenter la taille de pile par défaut si vous prévoyez d'exporter un grand nombre de flux.
Version minimale AWS IoT Greengrass du noyau : 1.10.0
**Répertoires de fichiers d'entrée en lecture seule**
Nom du paramètre: `STREAM_MANAGER_READ_ONLY_DIRS`
Liste de chemins absolus séparés par des virgules vers les répertoires situés en dehors du système de fichiers racine qui stockent les fichiers d'entrée. Le gestionnaire de flux lit et télécharge les fichiers sur Amazon S3 et monte les répertoires en lecture seule. Pour plus d'informations sur l'exportation vers Amazon S3, consultez[Objets Amazon S3](stream-export-configurations.md#export-to-s3).
Utilisez ce paramètre uniquement si les conditions suivantes sont remplies :
+ Le répertoire des fichiers d'entrée d'un flux exporté vers Amazon S3 se trouve à l'un des emplacements suivants :
+ Une partition autre que le système de fichiers racine.
+ Sous `/tmp` le système de fichiers racine.
+ **La [conteneurisation par défaut](lambda-group-config.md#lambda-containerization-groupsettings) du groupe Greengrass est Greengrass container.**
Exemple de valeur : `/mnt/directory-1,/mnt/directory-2,/tmp`
Version minimale AWS IoT Greengrass du noyau : 1.11.0
**Taille minimale pour le téléchargement en plusieurs parties**
Nom du paramètre: `STREAM_MANAGER_EXPORTER_S3_DESTINATION_MULTIPART_UPLOAD_MIN_PART_SIZE_BYTES`
Taille minimale (en octets) d'une partie dans un chargement partitionné vers Amazon S3. Le gestionnaire de flux utilise ce paramètre et la taille du fichier d'entrée pour déterminer comment regrouper les données dans une requête PUT en plusieurs parties. La valeur minimale par défaut est de 5 `5242880` octets (5 Mo).
Le gestionnaire de flux utilise la `sizeThresholdForMultipartUploadBytes` propriété du flux pour déterminer s'il convient d'exporter vers Amazon S3 sous forme de téléchargement en une ou plusieurs parties. Les fonctions Lambda définies par l'utilisateur définissent ce seuil lorsqu'elles créent un flux exporté vers Amazon S3. Le seuil par défaut est de 5 Mo.
Version minimale AWS IoT Greengrass du noyau : 1.11.0
## Configurer les paramètres du gestionnaire de flux (console)
Vous pouvez utiliser la AWS IoT console pour les tâches de gestion suivantes :
+ [Vérifier si le gestionnaire de flux est activé](#check-stream-manager-console)
+ [Activer ou désactiver le gestionnaire de flux lors de la création de groupe](#enable-stream-manager-console-new-group)
+ [Activer ou désactiver le gestionnaire de flux pour un groupe existant](#enable-stream-manager-console-existing-group)
+ [Modifier les paramètres du gestionnaire de flux](#change-stream-manager-console)
Les modifications prennent effet après le déploiement du groupe Greengrass. Pour un didacticiel expliquant comment déployer un groupe Greengrass contenant une fonction Lambda qui interagit avec le gestionnaire de flux, voir. [Exporter des flux de données vers AWS Cloud (console)](stream-manager-console.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.
### Pour vérifier si le gestionnaire de flux est activé (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. Choisissez l'onglet **Fonctions Lambda.**
1. **Sous **Fonctions Lambda du système**, sélectionnez **Stream Manager**, puis Edit.**
1. Vérifiez l'état activé ou désactivé. Tous les paramètres personnalisés du gestionnaire de flux qui sont configurés sont également affichés.
### Pour activer ou désactiver le gestionnaire de flux lors de la création de groupe (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 **Create Group**. Votre choix sur la page suivante détermine la façon dont vous configurez le gestionnaire de flux pour le groupe.
1. Parcourez les pages **principales de Greengrass** et **nommez votre groupe**.
1. Choisissez **Créer un groupe**.
1. **Sur la page de configuration du groupe, choisissez l'onglet **Fonctions Lambda**, sélectionnez **Stream Manager**, puis Edit.**
+ Pour activer le gestionnaire de flux avec les paramètres par défaut, choisissez **Activer avec les paramètres par défaut**.
+ Pour activer le gestionnaire de flux avec des paramètres personnalisés, choisissez **Customize settings (Personnalisation des paramètres)**.
1. Sur la page **Configurer le gestionnaire de flux**, choisissez **Activer avec des paramètres personnalisés**.
1. Sous **Custom settings (Paramètres personnalisés)**, entrez des valeurs pour les paramètres du gestionnaire de flux. Pour de plus amples informations, veuillez consulter [Paramètres du gestionnaire de flux](#stream-manager-parameters). Laissez les champs vides pour AWS IoT Greengrass autoriser l'utilisation de leurs valeurs par défaut.
+ Pour désactiver le gestionnaire de flux, choisissez **Disable**.
1. Sur la page **Configure stream manager (Configurer le gestionnaire de flux)**, choisissez **Disable (Désactiver)**.
1. Choisissez **Enregistrer**.
1. Continuez à parcourir les pages restantes pour créer votre groupe.
1. Sur la page **Appareils clients**, téléchargez vos ressources de sécurité, consultez les informations, puis choisissez **Terminer**.
**Note**
Une fois le gestionnaire de flux activé, vous devez [installer l'environnement d'exécution Java 8](stream-manager.md#stream-manager-requirements) sur l'appareil principal (noyau) avant de déployer votre groupe.
### Pour activer ou désactiver le gestionnaire de flux pour un groupe existant (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. Choisissez l'onglet **Fonctions Lambda.**
1. **Sous **Fonctions Lambda du système**, sélectionnez **Stream Manager**, puis Edit.**
1. Vérifiez l'état activé ou désactivé. Tous les paramètres personnalisés du gestionnaire de flux qui sont configurés sont également affichés.
### Pour modifier les paramètres du gestionnaire de flux (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. Choisissez l'onglet **Fonctions Lambda.**
1. **Sous **Fonctions Lambda du système**, sélectionnez **Stream Manager**, puis Edit.**
1. Vérifiez l'état activé ou désactivé. Tous les paramètres personnalisés du gestionnaire de flux qui sont configurés sont également affichés.
1. Choisissez **Enregistrer**.
## Configurer les paramètres du gestionnaire de flux (interface de ligne de commande)
Dans le AWS CLI, utilisez la fonction `GGStreamManager` Lambda du système pour configurer le gestionnaire de flux. Les fonctions Lambda du système sont des composants du logiciel de AWS IoT Greengrass base. Pour le gestionnaire de flux et certaines autres fonctions Lambda du système, vous pouvez configurer les fonctionnalités de Greengrass en gérant les objets correspondants `Function` et `FunctionDefinitionVersion` les objets du groupe Greengrass. Pour de plus amples informations, veuillez consulter [Vue d'ensemble du modèle AWS IoT Greengrass d'objet de groupe](deployments.md#api-overview).
Vous pouvez utiliser l'API pour les tâches de gestion suivantes. Les exemples présentés dans cette section montrent comment utiliser le AWS CLI, mais vous pouvez également appeler directement l' AWS IoT Greengrass API ou utiliser un AWS SDK.
+ [Vérifier si le gestionnaire de flux est activé](#check-stream-manager-cli)
+ [Activer, désactiver ou configurer le gestionnaire de flux](#enable-stream-manager-cli)
Les modifications prennent effet après le déploiement du groupe. Pour un didacticiel expliquant comment déployer un groupe Greengrass avec une fonction Lambda qui interagit avec le gestionnaire de flux, voir. [Exporter des flux de données vers le AWS Cloud (CLI)](stream-manager-cli.md)
**Astuce**
Pour vérifier si le gestionnaire de flux est activé et s'exécute à partir de votre appareil principal, vous pouvez exécuter la commande suivante dans un terminal de l'appareil.
```
ps aux | grep -i 'streammanager'
```
### Pour vérifier si le gestionnaire de flux est activé (interface de ligne de commande)
Le gestionnaire de flux est activé si la version de définition de fonction déployée inclut la fonction `GGStreamManager` Lambda du système. Pour vérifier, procédez comme suit :
1. Obtenez le IDs groupe Greengrass cible et la version du groupe. Cette procédure suppose qu'il s'agit de la dernière version du groupe et du groupe. La requête suivante renvoie le dernier groupe créé.
```
aws greengrass list-groups --query "reverse(sort_by(Groups, &CreationTimestamp))[0]"
```
Vous pouvez également procéder à une interrogation par nom. Les noms de groupe ne devant pas nécessairement être uniques, plusieurs groupes peuvent être renvoyés.
```
aws greengrass list-groups --query "Groups[?Name=='MyGroup']"
```
**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.
1. Copiez les valeurs `LatestVersion` et `Id` du groupe cible dans la sortie.
1. Obtenez la version de groupe la plus récente.
+ Remplacez *group-id* par l’`Id` que vous avez copié.
+ Remplacez *latest-group-version-id* par l’`LatestVersion` que vous avez copié.
```
aws greengrass get-group-version \
--group-id group-id \
--group-version-id latest-group-version-id
```
1. À partir de la `FunctionDefinitionVersionArn` sortie, obtenez la définition IDs de la fonction et la version de la définition de la fonction.
+ L'ID de définition de fonction est le GUID qui suit le `functions` segment dans l'Amazon Resource Name (ARN).
+ L'ID de version de la définition de fonction est le GUID qui suit le segment `versions` dans l'ARN.
```
arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/functions/function-definition-id/versions/function-definition-version-id
```
1. Récupérez la version de la définition de fonction
+ Remplacez *function-definition-id* par l'ID de définition de la fonction.
+ Remplacez *function-definition-version-id* par l'ID de version de la définition de la fonction.
```
aws greengrass get-function-definition-version \
--function-definition-id function-definition-id \
--function-definition-version-id function-definition-version-id
```
Si le tableau `functions` dans la sortie inclut la fonction `GGStreamManager`, alors le gestionnaire de flux est activé. Toutes les variables d'environnement définies pour la fonction représentent des paramètres personnalisés pour le gestionnaire de flux.
### Pour activer, désactiver ou configurer le gestionnaire de flux (CLI)
Dans le AWS CLI, utilisez la fonction `GGStreamManager` Lambda du système pour configurer le gestionnaire de flux. Les modifications prennent effet après le déploiement du groupe.
+ Pour activer le gestionnaire de flux, incluez `GGStreamManager` dans le tableau `functions` de votre version de définition de fonction. Pour configurer des paramètres personnalisés, définissez des variables d'environnement pour les [paramètres du gestionnaire de flux](#stream-manager-parameters) correspondants.
+ Pour désactiver le gestionnaire de flux, supprimez `GGStreamManager` du tableau `functions` de votre version de définition de fonction.
**Gestionnaire de flux avec les paramètres par défaut**
L'exemple de configuration suivant active le gestionnaire de flux avec les paramètres par défaut. Il définit l'ID de la fonction arbitraire sur `streamManager`.
```
{
"FunctionArn": "arn:aws:lambda:::function:GGStreamManager:1",
"FunctionConfiguration": {
"MemorySize": 4194304,
"Pinned": true,
"Timeout": 3
},
"Id": "streamManager"
}
```
En ce qui concerne les `FunctionConfiguration` propriétés, vous savez peut-être ce qui suit :
+ `MemorySize`est défini sur 4194 304 Ko (4 Go) avec les paramètres par défaut. Vous pouvez toujours modifier cette valeur. Nous vous recommandons de définir une `MemorySize` valeur d'au moins 128 000 Ko.
+ `Pinned` doit être défini sur `true`.
+ `Timeout` est requis par la version de définition de fonction, mais `GGStreamManager` ne l'utilise pas.
**Gestionnaire de flux avec des paramètres personnalisés**
L'exemple de configuration suivant active le gestionnaire de flux avec des valeurs personnalisées pour le répertoire de stockage, le port du serveur et les paramètres de taille du pool de threads.
```
{
"FunctionArn": "arn:aws:lambda:::function:GGStreamManager:1",
"FunctionConfiguration": {
"Environment": {
"Variables": {
"STREAM_MANAGER_STORE_ROOT_DIR": "/data",
"STREAM_MANAGER_SERVER_PORT": "1234",
"STREAM_MANAGER_EXPORTER_THREAD_POOL_SIZE": "4"
}
},
"MemorySize": 4194304,
"Pinned": true,
"Timeout": 3
},
"Id": "streamManager"
}
```
AWS IoT Greengrass utilise des valeurs par défaut pour les [paramètres du gestionnaire de flux](#stream-manager-parameters) qui ne sont pas spécifiés en tant que variables d'environnement.
**Gestionnaire de flux avec paramètres personnalisés pour les exportations Amazon S3**
L'exemple de configuration suivant active le gestionnaire de flux avec des valeurs personnalisées pour le répertoire de téléchargement et des paramètres de taille minimale de téléchargement en plusieurs parties.
```
{
"FunctionArn": "arn:aws:lambda:::function:GGStreamManager:1",
"FunctionConfiguration": {
"Environment": {
"Variables": {
"STREAM_MANAGER_READ_ONLY_DIRS": "/mnt/directory-1,/mnt/directory-2,/tmp",
"STREAM_MANAGER_EXPORTER_S3_DESTINATION_MULTIPART_UPLOAD_MIN_PART_SIZE_BYTES": "10485760"
}
},
"MemorySize": 4194304,
"Pinned": true,
"Timeout": 3
},
"Id": "streamManager"
}
```
**Pour activer, désactiver ou configurer le gestionnaire de flux (CLI)**
1. Obtenez le IDs groupe Greengrass cible et la version du groupe. Cette procédure suppose qu'il s'agit de la dernière version du groupe et du groupe. La requête suivante renvoie le dernier groupe créé.
```
aws greengrass list-groups --query "reverse(sort_by(Groups, &CreationTimestamp))[0]"
```
Vous pouvez également procéder à une interrogation par nom. Les noms de groupe ne devant pas nécessairement être uniques, plusieurs groupes peuvent être renvoyés.
```
aws greengrass list-groups --query "Groups[?Name=='MyGroup']"
```
**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.
1. Copiez les valeurs `LatestVersion` et `Id` du groupe cible dans la sortie.
1. Obtenez la version de groupe la plus récente.
+ Remplacez *group-id* par l’`Id` que vous avez copié.
+ Remplacez *latest-group-version-id* par l’`LatestVersion` que vous avez copié.
```
aws greengrass get-group-version \
--group-id group-id \
--group-version-id latest-group-version-id
```
1. Copiez la version `CoreDefinitionVersionArn` et toutes les autres ARNs à partir de la sortie, sauf`FunctionDefinitionVersionArn`. Vous utiliserez ces valeurs ultérieurement lorsque vous créerez une version de groupe.
1. Depuis `FunctionDefinitionVersionArn` dans la sortie, copiez l'ID de la définition de fonction. L'ID est le GUID qui suit le segment `functions` dans l'ARN, comme illustré dans l'exemple suivant.
```
arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/functions/bcfc6b49-beb0-4396-b703-6dEXAMPLEcu5/versions/0f7337b4-922b-45c5-856f-1aEXAMPLEsf6
```
**Note**
Vous pouvez également créer une définition de fonction en exécutant la [https://docs.aws.amazon.com/cli/latest/reference/greengrass/create-function-definition.html](https://docs.aws.amazon.com/cli/latest/reference/greengrass/create-function-definition.html)commande, puis en copiant l'ID depuis la sortie.
1. Ajoutez une version de définition de fonction à la définition de fonction.
+ *function-definition-id*Remplacez-le par celui `Id` que vous avez copié pour la définition de la fonction.
+ Dans le `functions` tableau, incluez toutes les autres fonctions que vous souhaitez rendre disponibles sur le noyau de Greengrass. Vous pouvez utiliser la commande `get-function-definition-version` pour obtenir la liste des fonctions existantes.
**Activer le gestionnaire de flux avec les paramètres par défaut**
L'exemple suivant active le gestionnaire de flux en incluant la `GGStreamManager` fonction dans le `functions` tableau. Cet exemple utilise les valeurs par défaut pour les [paramètres du gestionnaire de flux](#stream-manager-parameters).
```
aws greengrass create-function-definition-version \
--function-definition-id function-definition-id \
--functions '[
{
"FunctionArn": "arn:aws:lambda:::function:GGStreamManager:1",
"FunctionConfiguration": {
"MemorySize": 4194304,
"Pinned": true,
"Timeout": 3
},
"Id": "streamManager"
},
{
"FunctionArn": "arn:aws:lambda:us-west-2:123456789012:function:MyLambdaFunction:MyAlias",
"FunctionConfiguration": {
"Executable": "myLambdaFunction.function_handler",
"MemorySize": 16000,
"Pinned": true,
"Timeout": 5
},
"Id": "myLambdaFunction"
},
... more user-defined functions
]
}'
```
La `myLambdaFunction` fonction présentée dans les exemples représente l'une de vos fonctions Lambda définies par l'utilisateur.
**Activer le gestionnaire de flux avec des paramètres personnalisés**
L'exemple suivant active le gestionnaire de flux en incluant la fonction `GGStreamManager` dans le tableau `functions`. Tous les paramètres du gestionnaire de flux sont facultatifs, sauf si vous souhaitez modifier les valeurs par défaut. Cet exemple montre comment utiliser des variables d'environnement pour définir des valeurs personnalisées.
```
aws greengrass create-function-definition-version \
--function-definition-id function-definition-id \
--functions '[
{
"FunctionArn": "arn:aws:lambda:::function:GGStreamManager:1",
"FunctionConfiguration": {
"Environment": {
"Variables": {
"STREAM_MANAGER_STORE_ROOT_DIR": "/data",
"STREAM_MANAGER_SERVER_PORT": "1234",
"STREAM_MANAGER_EXPORTER_THREAD_POOL_SIZE": "4"
}
},
"MemorySize": 4194304,
"Pinned": true,
"Timeout": 3
},
"Id": "streamManager"
},
{
"FunctionArn": "arn:aws:lambda:us-west-2:123456789012:function:MyLambdaFunction:MyAlias",
"FunctionConfiguration": {
"Executable": "myLambdaFunction.function_handler",
"MemorySize": 16000,
"Pinned": true,
"Timeout": 5
},
"Id": "myLambdaFunction"
},
... more user-defined functions
]
}'
```
En ce qui concerne les `FunctionConfiguration` propriétés, vous savez peut-être ce qui suit :
+ `MemorySize`est défini sur 4194 304 Ko (4 Go) avec les paramètres par défaut. Vous pouvez toujours modifier cette valeur. Nous vous recommandons de définir une `MemorySize` valeur d'au moins 128 000 Ko.
+ `Pinned` doit être défini sur `true`.
+ `Timeout` est requis par la version de définition de fonction, mais `GGStreamManager` ne l'utilise pas.
**Désactiver le gestionnaire de flux**
L'exemple suivant omet la fonction `GGStreamManager`, qui désactive le gestionnaire de flux.
```
aws greengrass create-function-definition-version \
--function-definition-id function-definition-id \
--functions '[
{
"FunctionArn": "arn:aws:lambda:us-west-2:123456789012:function:MyLambdaFunction:MyAlias",
"FunctionConfiguration": {
"Executable": "myLambdaFunction.function_handler",
"MemorySize": 16000,
"Pinned": true,
"Timeout": 5
},
"Id": "myLambdaFunction"
},
... more user-defined functions
]
}'
```
Si vous ne souhaitez pas déployer de fonctions Lambda, vous pouvez omettre complètement la version de définition des fonctions.
1. Copiez l'`Arn` de la version de définition de fonction à partir de la sortie.
1. Créez une version de groupe contenant la fonction Lambda du système.
+ Remplacez *group-id* par le `Id` pour le groupe.
+ *core-definition-version-arn*Remplacez-le par celui `CoreDefinitionVersionArn` que vous avez copié à partir de la dernière version du groupe.
+ *function-definition-version-arn*Remplacez-le par celui `Arn` que vous avez copié pour la nouvelle version de définition de fonction.
+ Remplacez le ARNs pour les autres composants du groupe (par exemple, `SubscriptionDefinitionVersionArn` ou`DeviceDefinitionVersionArn`) que vous avez copiés à partir de la dernière version du groupe.
+ Supprimez tous les paramètres inutilisés. Par exemple, supprimez `--resource-definition-version-arn` si votre version de groupe ne contient aucune ressource.
```
aws greengrass create-group-version \
--group-id group-id \
--core-definition-version-arn core-definition-version-arn \
--function-definition-version-arn function-definition-version-arn \
--device-definition-version-arn device-definition-version-arn \
--logger-definition-version-arn logger-definition-version-arn \
--resource-definition-version-arn resource-definition-version-arn \
--subscription-definition-version-arn subscription-definition-version-arn
```
1. Copiez la `Version` à partir de la sortie. Il s'agit de l'ID de la nouvelle version de groupe.
1. Déployez le groupe avec la nouvelle version de groupe.
+ *group-id*Remplacez-le par celui `Id` que vous avez copié pour le groupe.
+ *group-version-id*Remplacez-le par celui `Version` que vous avez copié pour la nouvelle version du groupe.
```
aws greengrass create-deployment \
--group-id group-id \
--group-version-id group-version-id \
--deployment-type NewDeployment
```
Suivez cette procédure si vous souhaitez modifier à nouveau les paramètres du gestionnaire de flux ultérieurement. Assurez-vous de créer une version de définition de fonction qui inclut la `GGStreamManager` fonction avec la configuration mise à jour. La version du groupe doit faire référence à toutes les versions de composants ARNs que vous souhaitez déployer sur le noyau. Les modifications prennent effet après le déploiement du groupe.
## Consultez aussi
+ [Gérez les flux de données sur le AWS IoT Greengrass cœur](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 AWS Cloud (console)](stream-manager-console.md)
+ [Exporter des flux de données vers le AWS Cloud (CLI)](stream-manager-cli.md)
# StreamManagerClient À utiliser pour travailler avec des flux
Les fonctions Lambda définies par l'utilisateur exécutées sur AWS IoT Greengrass le noyau peuvent utiliser `StreamManagerClient` l'objet du SDK [Core pour créer des flux dans AWS IoT Greengrass le](lambda-functions.md#lambda-sdks) [gestionnaire de flux, puis interagir avec les flux](stream-manager.md). Lorsqu'une fonction Lambda crée un flux, elle définit les AWS Cloud destinations, la hiérarchisation et les autres politiques d'exportation et de conservation des données pour le flux. Pour envoyer des données au gestionnaire de flux, les fonctions Lambda ajoutent les données au flux. Si une destination d'exportation est définie pour le flux, le gestionnaire de flux exporte le flux automatiquement.
**Note**
Généralement, les clients du gestionnaire de flux sont des fonctions Lambda définies par l'utilisateur. Si votre analyse de rentabilisation l'exige, vous pouvez également autoriser les processus non Lambda exécutés sur le cœur de Greengrass (par exemple, un conteneur Docker) à interagir avec le gestionnaire de flux. Pour de plus amples informations, veuillez consulter [Authentification client](stream-manager.md#stream-manager-security-client-authentication).
Les extraits de cette rubrique vous montrent comment les clients appellent des `StreamManagerClient` méthodes pour travailler avec des flux. Pour plus de détails sur l'implémentation des méthodes et de leurs arguments, utilisez les liens vers la référence du SDK répertoriée après chaque extrait. Pour les didacticiels qui incluent une fonction Python Lambda complète, consultez [Exporter des flux de données vers AWS Cloud (console)](stream-manager-console.md) ou. [Exporter des flux de données vers le AWS Cloud (CLI)](stream-manager-cli.md)
Votre fonction Lambda doit être instanciée en `StreamManagerClient` dehors du gestionnaire de fonctions. Si la fonction est instanciée dans le gestionnaire, elle crée un `client` et une connexion au gestionnaire de flux chaque fois qu'elle est appelée.
**Note**
Si vous effectuez une instanciation `StreamManagerClient` dans le gestionnaire, vous devez appeler explicitement la méthode `close()` lorsque le `client` termine son travail. Sinon, le `client` maintient la connexion ouverte et un autre thread actif jusqu'à ce que le script se termine.
`StreamManagerClient` prend en charge les opérations suivantes :
+ [Créer un flux de messages](#streammanagerclient-create-message-stream)
+ [Ajouter un message](#streammanagerclient-append-message)
+ [Lire des messages](#streammanagerclient-read-messages)
+ [Afficher la liste des flux](#streammanagerclient-list-streams)
+ [Décrire le flux de messages](#streammanagerclient-describe-message-stream)
+ [Mettre à jour le flux de messages](#streammanagerclient-update-message-stream)
+ [Supprimer le flux de messages](#streammanagerclient-delete-message-stream)
## Créer un flux de messages
Pour créer un flux, une fonction Lambda définie par l'utilisateur appelle la méthode create et transmet un objet. `MessageStreamDefinition` Cet objet spécifie le nom unique du flux et définit comment le gestionnaire de flux doit gérer les nouvelles données lorsque la taille maximale du flux est atteinte. Vous pouvez utiliser `MessageStreamDefinition` et ses types de données (tels que `ExportDefinition`, `StrategyOnFull` et `Persistence`) pour définir d'autres propriétés de flux. Il s’agit des licences suivantes :
+ La cible AWS IoT Analytics, Kinesis Data Streams et AWS IoT SiteWise les destinations Amazon S3 pour les exportations automatiques. Pour de plus amples informations, veuillez consulter [Exporter les configurations pour les AWS Cloud destinations prises en charge](stream-export-configurations.md).
+ Exportez la priorité. Le gestionnaire de flux exporte les flux de priorité supérieure avant les flux de priorité inférieure.
+ Taille de lot et intervalle de lot maximaux pour AWS IoT Analytics Kinesis Data Streams AWS IoT SiteWise et les destinations. Le gestionnaire de flux exporte les messages lorsque l'une ou l'autre des conditions est remplie.
+ Time-to-live (TTL). Temps nécessaire pour garantir que les données du flux sont disponibles pour le traitement. Vous devez vous assurer que les données peuvent être consommées pendant cette période. Il ne s'agit pas d'une stratégie de suppression. Les données peuvent ne pas être supprimées immédiatement après la période de TTL.
+ Persistance des flux. Choisissez d'enregistrer les flux dans le système de fichiers afin de conserver les données lors des redémarrages du noyau ou d'enregistrer les flux en mémoire.
+ Numéro de séquence de départ. Spécifiez le numéro de séquence du message à utiliser comme message de départ lors de l'exportation.
Pour plus d'informations`MessageStreamDefinition`, consultez la référence du SDK pour votre langue cible :
+ [MessageStreamDefinition](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/MessageStreamDefinition.html)dans le SDK Java
+ [MessageStreamDefinition](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.MessageStreamDefinition.html)dans le SDK Node.js
+ [MessageStreamDefinition](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.MessageStreamDefinition)dans le SDK Python
**Note**
`StreamManagerClient`fournit également une destination cible que vous pouvez utiliser pour exporter des flux vers un serveur HTTP. Cette cible n'est destinée qu'à des fins de test. Il n'est pas stable ni pris en charge pour une utilisation dans des environnements de production.
Après la création d'un flux, vos fonctions Lambda peuvent [ajouter des messages](#streammanagerclient-append-message) au flux pour envoyer des données à exporter et [lire les messages](#streammanagerclient-append-message) du flux pour un traitement local. Le nombre de flux que vous créez dépend de vos capacités matérielles et de votre analyse de rentabilisation. L'une des stratégies consiste à créer un flux pour chaque canal cible dans AWS IoT Analytics le flux de données Kinesis, bien que vous puissiez définir plusieurs cibles pour un flux. Un flux a un cycle de vie durable.
### Exigences
Cette opération répond aux exigences suivantes :
+ Version minimale AWS IoT Greengrass du noyau : 1.10.0
+ Version minimale AWS IoT Greengrass du SDK de base : Python : 1.5.0 \$1 Java : 1.4.0 \$1 Node.js : 1.6.0
**Note**
La création de flux avec une destination d'exportation AWS IoT SiteWise ou Amazon S3 répond aux exigences suivantes :
Version minimale AWS IoT Greengrass du noyau : 1.11.0
Version minimale AWS IoT Greengrass du SDK de base : Python : 1.6.0 \$1 Java : 1.5.0 \$1 Node.js : 1.7.0
### Exemples
L'extrait de code suivant crée un flux nommé `StreamName`. Il définit les propriétés du flux dans les types de données `MessageStreamDefinition` et les types de données subordonnés.
------
#### [ Python ]
```
client = StreamManagerClient()
try:
client.create_message_stream(MessageStreamDefinition(
name="StreamName", # Required.
max_size=268435456, # Default is 256 MB.
stream_segment_size=16777216, # Default is 16 MB.
time_to_live_millis=None, # By default, no TTL is enabled.
strategy_on_full=StrategyOnFull.OverwriteOldestData, # Required.
persistence=Persistence.File, # Default is File.
flush_on_write=False, # Default is false.
export_definition=ExportDefinition( # Optional. Choose where/how the stream is exported to the AWS Cloud.
kinesis=None,
iot_analytics=None,
iot_sitewise=None,
s3_task_executor=None
)
))
except StreamManagerException:
pass
# Properly handle errors.
except ConnectionError or asyncio.TimeoutError:
pass
# Properly handle errors.
```
Référence du SDK Python : [create\$1message\$1stream](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html#greengrasssdk.stream_manager.streammanagerclient.StreamManagerClient.create_message_stream) \$1 [MessageStreamDefinition](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.MessageStreamDefinition)
------
#### [ Java ]
```
try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) {
client.createMessageStream(
new MessageStreamDefinition()
.withName("StreamName") // Required.
.withMaxSize(268435456L) // Default is 256 MB.
.withStreamSegmentSize(16777216L) // Default is 16 MB.
.withTimeToLiveMillis(null) // By default, no TTL is enabled.
.withStrategyOnFull(StrategyOnFull.OverwriteOldestData) // Required.
.withPersistence(Persistence.File) // Default is File.
.withFlushOnWrite(false) // Default is false.
.withExportDefinition( // Optional. Choose where/how the stream is exported to the AWS Cloud.
new ExportDefinition()
.withKinesis(null)
.withIotAnalytics(null)
.withIotSitewise(null)
.withS3TaskExecutor(null)
)
);
} catch (StreamManagerException e) {
// Properly handle exception.
}
```
Référence du SDK Java : \$1 [createMessageStream[MessageStreamDefinition](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/MessageStreamDefinition.html)](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#createMessageStream-com.amazonaws.greengrass.streammanager.model.MessageStreamDefinition-)
------
#### [ Node.js ]
```
const client = new StreamManagerClient();
client.onConnected(async () => {
try {
await client.createMessageStream(
new MessageStreamDefinition()
.withName("StreamName") // Required.
.withMaxSize(268435456) // Default is 256 MB.
.withStreamSegmentSize(16777216) // Default is 16 MB.
.withTimeToLiveMillis(null) // By default, no TTL is enabled.
.withStrategyOnFull(StrategyOnFull.OverwriteOldestData) // Required.
.withPersistence(Persistence.File) // Default is File.
.withFlushOnWrite(false) // Default is false.
.withExportDefinition( // Optional. Choose where/how the stream is exported to the AWS Cloud.
new ExportDefinition()
.withKinesis(null)
.withIotAnalytics(null)
.withIotSitewise(null)
.withS3TaskExecutor(null)
)
);
} catch (e) {
// Properly handle errors.
}
});
client.onError((err) => {
// Properly handle connection errors.
// This is called only when the connection to the StreamManager server fails.
});
```
Référence du SDK Node.js : \$1 [createMessageStream[MessageStreamDefinition](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.MessageStreamDefinition.html)](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#createMessageStream)
------
Pour plus d'informations sur la configuration des destinations d'exportation, consultez[Exporter les configurations pour les AWS Cloud destinations prises en charge](stream-export-configurations.md).
## Ajouter un message
Pour envoyer des données au gestionnaire de flux à des fins d'exportation, vos fonctions Lambda ajoutent les données au flux cible. La destination d'exportation détermine le type de données à transmettre à cette méthode.
### Exigences
Cette opération répond aux exigences suivantes :
+ Version minimale AWS IoT Greengrass du noyau : 1.10.0
+ Version minimale AWS IoT Greengrass du SDK de base : Python : 1.5.0 \$1 Java : 1.4.0 \$1 Node.js : 1.6.0
**Note**
L'ajout de messages à une destination d'exportation AWS IoT SiteWise ou à une destination d'exportation Amazon S3 répond aux exigences suivantes :
Version minimale AWS IoT Greengrass du noyau : 1.11.0
Version minimale AWS IoT Greengrass du SDK de base : Python : 1.6.0 \$1 Java : 1.5.0 \$1 Node.js : 1.7.0
### Exemples
#### AWS IoT Analytics ou destinations d'exportation Kinesis Data Streams
L'extrait de code suivant ajoute un message au flux nommé `StreamName`. Pour AWS IoT Analytics nos destinations Kinesis Data Streams, vos fonctions Lambda ajoutent un blob de données.
Cet extrait répond aux exigences suivantes :
+ Version minimale AWS IoT Greengrass du noyau : 1.10.0
+ Version minimale AWS IoT Greengrass du SDK de base : Python : 1.5.0 \$1 Java : 1.4.0 \$1 Node.js : 1.6.0
------
#### [ Python ]
```
client = StreamManagerClient()
try:
sequence_number = client.append_message(stream_name="StreamName", data=b'Arbitrary bytes data')
except StreamManagerException:
pass
# Properly handle errors.
except ConnectionError or asyncio.TimeoutError:
pass
# Properly handle errors.
```
[Référence du SDK Python : append\$1message](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html#greengrasssdk.stream_manager.streammanagerclient.StreamManagerClient.append_message)
------
#### [ Java ]
```
try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) {
long sequenceNumber = client.appendMessage("StreamName", "Arbitrary byte array".getBytes());
} catch (StreamManagerException e) {
// Properly handle exception.
}
```
[Référence du SDK Java : AppendMessage](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#appendMessage-java.lang.String-byte:A-)
------
#### [ Node.js ]
```
const client = new StreamManagerClient();
client.onConnected(async () => {
try {
const sequenceNumber = await client.appendMessage("StreamName", Buffer.from("Arbitrary byte array"));
} catch (e) {
// Properly handle errors.
}
});
client.onError((err) => {
// Properly handle connection errors.
// This is called only when the connection to the StreamManager server fails.
});
```
[Référence du SDK Node.js : AppendMessage](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#appendMessage)
------
#### AWS IoT SiteWise destinations d'exportation
L'extrait de code suivant ajoute un message au flux nommé `StreamName`. Pour les AWS IoT SiteWise destinations, vos fonctions Lambda ajoutent un objet sérialisé. `PutAssetPropertyValueEntry` Pour de plus amples informations, veuillez consulter [Exporter vers AWS IoT SiteWise](stream-export-configurations.md#export-streams-to-sitewise).
**Note**
Lorsque vous envoyez des données à AWS IoT SiteWise, celles-ci doivent répondre aux exigences de l'`BatchPutAssetPropertyValue`action. Pour plus d’informations, consultez [BatchPutAssetPropertyValue](https://docs.aws.amazon.com/iot-sitewise/latest/APIReference/API_BatchPutAssetPropertyValue.html) dans la *Référence d’API AWS IoT SiteWise *.
Cet extrait répond aux exigences suivantes :
+ Version minimale AWS IoT Greengrass du noyau : 1.11.0
+ Version minimale AWS IoT Greengrass du SDK de base : Python : 1.6.0 \$1 Java : 1.5.0 \$1 Node.js : 1.7.0
------
#### [ Python ]
```
client = StreamManagerClient()
try:
# SiteWise requires unique timestamps in all messages. Add some randomness to time and offset.
# Note: To create a new asset property data, you should use the classes defined in the
# greengrasssdk.stream_manager module.
time_in_nanos = TimeInNanos(
time_in_seconds=calendar.timegm(time.gmtime()) - random.randint(0, 60), offset_in_nanos=random.randint(0, 10000)
)
variant = Variant(double_value=random.random())
asset = [AssetPropertyValue(value=variant, quality=Quality.GOOD, timestamp=time_in_nanos)]
putAssetPropertyValueEntry = PutAssetPropertyValueEntry(entry_id=str(uuid.uuid4()), property_alias="PropertyAlias", property_values=asset)
sequence_number = client.append_message(stream_name="StreamName", data=Util.validate_and_serialize_to_json_bytes(putAssetPropertyValueEntry))
except StreamManagerException:
pass
# Properly handle errors.
except ConnectionError or asyncio.TimeoutError:
pass
# Properly handle errors.
```
Référence du SDK Python : [append\$1message \$1 [PutAssetPropertyValueEntry](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.PutAssetPropertyValueEntry)](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html#greengrasssdk.stream_manager.streammanagerclient.StreamManagerClient.append_message)
------
#### [ Java ]
```
try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) {
Random rand = new Random();
// Note: To create a new asset property data, you should use the classes defined in the
// com.amazonaws.greengrass.streammanager.model.sitewise package.
List entries = new ArrayList<>() ;
// IoTSiteWise requires unique timestamps in all messages. Add some randomness to time and offset.
final int maxTimeRandomness = 60;
final int maxOffsetRandomness = 10000;
double randomValue = rand.nextDouble();
TimeInNanos timestamp = new TimeInNanos()
.withTimeInSeconds(Instant.now().getEpochSecond() - rand.nextInt(maxTimeRandomness))
.withOffsetInNanos((long) (rand.nextInt(maxOffsetRandomness)));
AssetPropertyValue entry = new AssetPropertyValue()
.withValue(new Variant().withDoubleValue(randomValue))
.withQuality(Quality.GOOD)
.withTimestamp(timestamp);
entries.add(entry);
PutAssetPropertyValueEntry putAssetPropertyValueEntry = new PutAssetPropertyValueEntry()
.withEntryId(UUID.randomUUID().toString())
.withPropertyAlias("PropertyAlias")
.withPropertyValues(entries);
long sequenceNumber = client.appendMessage("StreamName", ValidateAndSerialize.validateAndSerializeToJsonBytes(putAssetPropertyValueEntry));
} catch (StreamManagerException e) {
// Properly handle exception.
}
```
Référence du SDK Java : [AppendMessage \$1 [PutAssetPropertyValueEntry](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/sitewise/PutAssetPropertyValueEntry.html)](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#appendMessage-java.lang.String-byte:A-)
------
#### [ Node.js ]
```
const client = new StreamManagerClient();
client.onConnected(async () => {
try {
const maxTimeRandomness = 60;
const maxOffsetRandomness = 10000;
const randomValue = Math.random();
// Note: To create a new asset property data, you should use the classes defined in the
// aws-greengrass-core-sdk StreamManager module.
const timestamp = new TimeInNanos()
.withTimeInSeconds(Math.round(Date.now() / 1000) - Math.floor(Math.random() - maxTimeRandomness))
.withOffsetInNanos(Math.floor(Math.random() * maxOffsetRandomness));
const entry = new AssetPropertyValue()
.withValue(new Variant().withDoubleValue(randomValue))
.withQuality(Quality.GOOD)
.withTimestamp(timestamp);
const putAssetPropertyValueEntry = new PutAssetPropertyValueEntry()
.withEntryId(`${ENTRY_ID_PREFIX}${i}`)
.withPropertyAlias("PropertyAlias")
.withPropertyValues([entry]);
const sequenceNumber = await client.appendMessage("StreamName", util.validateAndSerializeToJsonBytes(putAssetPropertyValueEntry));
} catch (e) {
// Properly handle errors.
}
});
client.onError((err) => {
// Properly handle connection errors.
// This is called only when the connection to the StreamManager server fails.
});
```
Référence du SDK Node.js : [AppendMessage \$1 [PutAssetPropertyValueEntry](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.PutAssetPropertyValueEntry.html)](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#appendMessage)
------
#### Destinations d'exportation Amazon S3
L'extrait suivant ajoute une tâche d'exportation au flux nommé. `StreamName` Pour les destinations Amazon S3, vos fonctions Lambda ajoutent un `S3ExportTaskDefinition` objet sérialisé contenant des informations sur le fichier d'entrée source et l'objet Amazon S3 cible. Si l'objet spécifié n'existe pas, Stream Manager le crée pour vous. Pour de plus amples informations, veuillez consulter [Exportation vers Amazon S3](stream-export-configurations.md#export-streams-to-s3).
Cet extrait répond aux exigences suivantes :
+ Version minimale AWS IoT Greengrass du noyau : 1.11.0
+ Version minimale AWS IoT Greengrass du SDK de base : Python : 1.6.0 \$1 Java : 1.5.0 \$1 Node.js : 1.7.0
------
#### [ Python ]
```
client = StreamManagerClient()
try:
# Append an Amazon S3 Task definition and print the sequence number.
s3_export_task_definition = S3ExportTaskDefinition(input_url="URLToFile", bucket="BucketName", key="KeyName")
sequence_number = client.append_message(stream_name="StreamName", data=Util.validate_and_serialize_to_json_bytes(s3_export_task_definition))
except StreamManagerException:
pass
# Properly handle errors.
except ConnectionError or asyncio.TimeoutError:
pass
# Properly handle errors.
```
[Référence du SDK Python : [append\$1message \$1 S3](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html#greengrasssdk.stream_manager.streammanagerclient.StreamManagerClient.append_message) ExportTaskDefinition](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.S3ExportTaskDefinition)
------
#### [ Java ]
```
try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) {
// Append an Amazon S3 export task definition and print the sequence number.
S3ExportTaskDefinition s3ExportTaskDefinition = new S3ExportTaskDefinition()
.withBucket("BucketName")
.withKey("KeyName")
.withInputUrl("URLToFile");
long sequenceNumber = client.appendMessage("StreamName", ValidateAndSerialize.validateAndSerializeToJsonBytes(s3ExportTaskDefinition));
} catch (StreamManagerException e) {
// Properly handle exception.
}
```
[Référence du SDK Java : [AppendMessage \$1](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#appendMessage-java.lang.String-byte:A-) S3 ExportTaskDefinition](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/S3ExportTaskDefinition.html)
------
#### [ Node.js ]
```
const client = new StreamManagerClient();
client.onConnected(async () => {
try {
// Append an Amazon S3 export task definition and print the sequence number.
const taskDefinition = new S3ExportTaskDefinition()
.withBucket("BucketName")
.withKey("KeyName")
.withInputUrl("URLToFile");
const sequenceNumber = await client.appendMessage("StreamName", util.validateAndSerializeToJsonBytes(taskDefinition)));
} catch (e) {
// Properly handle errors.
}
});
client.onError((err) => {
// Properly handle connection errors.
// This is called only when the connection to the StreamManager server fails.
});
```
[Référence du SDK Node.js : [AppendMessage \$1](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#appendMessage) S3 ExportTaskDefinition](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.S3ExportTaskDefinition.html)
------
## Lire des messages
Lisez les messages d'un stream.
### Exigences
Cette opération répond aux exigences suivantes :
+ Version minimale AWS IoT Greengrass du noyau : 1.10.0
+ Version minimale AWS IoT Greengrass du SDK de base : Python : 1.5.0 \$1 Java : 1.4.0 \$1 Node.js : 1.6.0
### Exemples
L'extrait de code suivant lit les messages du flux nommé `StreamName`. La méthode read utilise un objet `ReadMessagesOptions` facultatif qui spécifie le numéro de séquence à partir duquel commencer la lecture, les nombres minimum et maximum à lire et un délai d'expiration pour la lecture des messages.
------
#### [ Python ]
```
client = StreamManagerClient()
try:
message_list = client.read_messages(
stream_name="StreamName",
# By default, if no options are specified, it tries to read one message from the beginning of the stream.
options=ReadMessagesOptions(
desired_start_sequence_number=100,
# Try to read from sequence number 100 or greater. By default, this is 0.
min_message_count=10,
# Try to read 10 messages. If 10 messages are not available, then NotEnoughMessagesException is raised. By default, this is 1.
max_message_count=100, # Accept up to 100 messages. By default this is 1.
read_timeout_millis=5000
# Try to wait at most 5 seconds for the min_messsage_count to be fulfilled. By default, this is 0, which immediately returns the messages or an exception.
)
)
except StreamManagerException:
pass
# Properly handle errors.
except ConnectionError or asyncio.TimeoutError:
pass
# Properly handle errors.
```
Référence du SDK Python : [read\$1messages \$1 [ReadMessagesOptions](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.ReadMessagesOptions)](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html#greengrasssdk.stream_manager.streammanagerclient.StreamManagerClient.read_messages)
------
#### [ Java ]
```
try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) {
List messages = client.readMessages("StreamName",
// By default, if no options are specified, it tries to read one message from the beginning of the stream.
new ReadMessagesOptions()
// Try to read from sequence number 100 or greater. By default this is 0.
.withDesiredStartSequenceNumber(100L)
// Try to read 10 messages. If 10 messages are not available, then NotEnoughMessagesException is raised. By default, this is 1.
.withMinMessageCount(10L)
// Accept up to 100 messages. By default this is 1.
.withMaxMessageCount(100L)
// Try to wait at most 5 seconds for the min_messsage_count to be fulfilled. By default, this is 0, which immediately returns the messages or an exception.
.withReadTimeoutMillis(Duration.ofSeconds(5L).toMillis())
);
} catch (StreamManagerException e) {
// Properly handle exception.
}
```
Référence du SDK Java : [ReadMessages \$1 [ReadMessagesOptions](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/ReadMessagesOptions.html)](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#readMessages-java.lang.String-com.amazonaws.greengrass.streammanager.model.ReadMessagesOptions-)
------
#### [ Node.js ]
```
const client = new StreamManagerClient();
client.onConnected(async () => {
try {
const messages = await client.readMessages("StreamName",
// By default, if no options are specified, it tries to read one message from the beginning of the stream.
new ReadMessagesOptions()
// Try to read from sequence number 100 or greater. By default this is 0.
.withDesiredStartSequenceNumber(100)
// Try to read 10 messages. If 10 messages are not available, then NotEnoughMessagesException is thrown. By default, this is 1.
.withMinMessageCount(10)
// Accept up to 100 messages. By default this is 1.
.withMaxMessageCount(100)
// Try to wait at most 5 seconds for the minMessageCount to be fulfilled. By default, this is 0, which immediately returns the messages or an exception.
.withReadTimeoutMillis(5 * 1000)
);
} catch (e) {
// Properly handle errors.
}
});
client.onError((err) => {
// Properly handle connection errors.
// This is called only when the connection to the StreamManager server fails.
});
```
Référence du SDK Node.js : [ReadMessages \$1 [ReadMessagesOptions](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.ReadMessagesOptions.html)](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#readMessages)
------
## Afficher la liste des flux
Obtenez la liste des flux dans le gestionnaire de flux.
### Exigences
Cette opération répond aux exigences suivantes :
+ Version minimale AWS IoT Greengrass du noyau : 1.10.0
+ Version minimale AWS IoT Greengrass du SDK de base : Python : 1.5.0 \$1 Java : 1.4.0 \$1 Node.js : 1.6.0
### Exemples
L'extrait de code suivant récupère une liste des flux (par nom) dans le gestionnaire de flux.
------
#### [ Python ]
```
client = StreamManagerClient()
try:
stream_names = client.list_streams()
except StreamManagerException:
pass
# Properly handle errors.
except ConnectionError or asyncio.TimeoutError:
pass
# Properly handle errors.
```
[Référence du SDK Python : list\$1streams](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html#greengrasssdk.stream_manager.streammanagerclient.StreamManagerClient.list_streams)
------
#### [ Java ]
```
try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) {
List streamNames = client.listStreams();
} catch (StreamManagerException e) {
// Properly handle exception.
}
```
[Référence du SDK Java : ListStreams](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#listStreams--)
------
#### [ Node.js ]
```
const client = new StreamManagerClient();
client.onConnected(async () => {
try {
const streams = await client.listStreams();
} catch (e) {
// Properly handle errors.
}
});
client.onError((err) => {
// Properly handle connection errors.
// This is called only when the connection to the StreamManager server fails.
});
```
[Référence du SDK Node.js : ListStreams](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#listStreams)
------
## Décrire le flux de messages
Obtenez les métadonnées relatives à un flux, notamment sa définition, sa taille et son statut d'exportation.
### Exigences
Cette opération répond aux exigences suivantes :
+ Version minimale AWS IoT Greengrass du noyau : 1.10.0
+ Version minimale AWS IoT Greengrass du SDK de base : Python : 1.5.0 \$1 Java : 1.4.0 \$1 Node.js : 1.6.0
### Exemples
L'extrait de code suivant récupère des métadonnées sur le flux nommé `StreamName`, en particulier la définition, la taille et les statuts d'exportation du flux.
------
#### [ Python ]
```
client = StreamManagerClient()
try:
stream_description = client.describe_message_stream(stream_name="StreamName")
if stream_description.export_statuses[0].error_message:
# The last export of export destination 0 failed with some error
# Here is the last sequence number that was successfully exported
stream_description.export_statuses[0].last_exported_sequence_number
if (stream_description.storage_status.newest_sequence_number >
stream_description.export_statuses[0].last_exported_sequence_number):
pass
# The end of the stream is ahead of the last exported sequence number
except StreamManagerException:
pass
# Properly handle errors.
except ConnectionError or asyncio.TimeoutError:
pass
# Properly handle errors.
```
[Référence du SDK Python : describe\$1message\$1stream](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html#greengrasssdk.stream_manager.streammanagerclient.StreamManagerClient.describe_message_stream)
------
#### [ Java ]
```
try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) {
MessageStreamInfo description = client.describeMessageStream("StreamName");
String lastErrorMessage = description.getExportStatuses().get(0).getErrorMessage();
if (lastErrorMessage != null && !lastErrorMessage.equals("")) {
// The last export of export destination 0 failed with some error.
// Here is the last sequence number that was successfully exported.
description.getExportStatuses().get(0).getLastExportedSequenceNumber();
}
if (description.getStorageStatus().getNewestSequenceNumber() >
description.getExportStatuses().get(0).getLastExportedSequenceNumber()) {
// The end of the stream is ahead of the last exported sequence number.
}
} catch (StreamManagerException e) {
// Properly handle exception.
}
```
Référence du SDK Java : [describeMessageStream](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#describeMessageStream-java.lang.String-)
------
#### [ Node.js ]
```
const client = new StreamManagerClient();
client.onConnected(async () => {
try {
const description = await client.describeMessageStream("StreamName");
const lastErrorMessage = description.exportStatuses[0].errorMessage;
if (lastErrorMessage) {
// The last export of export destination 0 failed with some error.
// Here is the last sequence number that was successfully exported.
description.exportStatuses[0].lastExportedSequenceNumber;
}
if (description.storageStatus.newestSequenceNumber >
description.exportStatuses[0].lastExportedSequenceNumber) {
// The end of the stream is ahead of the last exported sequence number.
}
} catch (e) {
// Properly handle errors.
}
});
client.onError((err) => {
// Properly handle connection errors.
// This is called only when the connection to the StreamManager server fails.
});
```
Référence du SDK Node.js : [describeMessageStream](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#describeMessageStream)
------
## Mettre à jour le flux de messages
Mettez à jour les propriétés d'un flux existant. Vous souhaiterez peut-être mettre à jour un flux si vos exigences changent après sa création. Par exemple :
+ Ajoutez une nouvelle [configuration d'exportation](stream-export-configurations.md) pour une AWS Cloud destination.
+ Augmentez la taille maximale d'un flux pour modifier la façon dont les données sont exportées ou conservées. Par exemple, la taille du flux associée à votre stratégie en matière de paramètres complets peut entraîner la suppression ou le rejet de données avant que le gestionnaire de flux ne puisse les traiter.
+ Interrompez et reprenez les exportations, par exemple, si les tâches d'exportation sont longues et que vous souhaitez rationner vos données de téléchargement.
Vos fonctions Lambda suivent ce processus de haut niveau pour mettre à jour un flux :
1. [Obtenez la description du stream.](#streammanagerclient-describe-message-stream)
1. Mettez à jour les propriétés cibles sur les objets correspondants `MessageStreamDefinition` et subordonnés.
1. Transmettez la mise à jour`MessageStreamDefinition`. Assurez-vous d'inclure les définitions d'objets complètes pour le flux mis à jour. Les propriétés non définies reprennent leurs valeurs par défaut.
Vous pouvez spécifier le numéro de séquence du message à utiliser comme message de départ lors de l'exportation.
### Exigences
Cette opération répond aux exigences suivantes :
+ Version minimale AWS IoT Greengrass du noyau : 1.11.0
+ Version minimale AWS IoT Greengrass du SDK de base : Python : 1.6.0 \$1 Java : 1.5.0 \$1 Node.js : 1.7.0
### Exemples
L'extrait suivant met à jour le flux nommé. `StreamName` Elle met à jour plusieurs propriétés d'un flux exporté vers Kinesis Data Streams.
------
#### [ Python ]
```
client = StreamManagerClient()
try:
message_stream_info = client.describe_message_stream(STREAM_NAME)
message_stream_info.definition.max_size=536870912
message_stream_info.definition.stream_segment_size=33554432
message_stream_info.definition.time_to_live_millis=3600000
message_stream_info.definition.strategy_on_full=StrategyOnFull.RejectNewData
message_stream_info.definition.persistence=Persistence.Memory
message_stream_info.definition.flush_on_write=False
message_stream_info.definition.export_definition.kinesis=
[KinesisConfig(
# Updating Export definition to add a Kinesis Stream configuration.
identifier=str(uuid.uuid4()), kinesis_stream_name=str(uuid.uuid4()))]
client.update_message_stream(message_stream_info.definition)
except StreamManagerException:
pass
# Properly handle errors.
except ConnectionError or asyncio.TimeoutError:
pass
# Properly handle errors.
```
Référence du SDK Python : \$1 [updateMessageStream[MessageStreamDefinition](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.MessageStreamDefinition)](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html#greengrasssdk.stream_manager.streammanagerclient.StreamManagerClient.update_message_stream)
------
#### [ Java ]
```
try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) {
MessageStreamInfo messageStreamInfo = client.describeMessageStream(STREAM_NAME);
// Update the message stream with new values.
client.updateMessageStream(
messageStreamInfo.getDefinition()
.withStrategyOnFull(StrategyOnFull.RejectNewData) // Required. Updating Strategy on full to reject new data.
// Max Size update should be greater than initial Max Size defined in Create Message Stream request
.withMaxSize(536870912L) // Update Max Size to 512 MB.
.withStreamSegmentSize(33554432L) // Update Segment Size to 32 MB.
.withFlushOnWrite(true) // Update flush on write to true.
.withPersistence(Persistence.Memory) // Update the persistence to Memory.
.withTimeToLiveMillis(3600000L) // Update TTL to 1 hour.
.withExportDefinition(
// Optional. Choose where/how the stream is exported to the AWS Cloud.
messageStreamInfo.getDefinition().getExportDefinition().
// Updating Export definition to add a Kinesis Stream configuration.
.withKinesis(new ArrayList() {{
add(new KinesisConfig()
.withIdentifier(EXPORT_IDENTIFIER)
.withKinesisStreamName("test"));
}})
);
} catch (StreamManagerException e) {
// Properly handle exception.
}
```
Référence du SDK Java : [update\$1message\$1stream](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#updateMessageStream-java.lang.String-) \$1 [MessageStreamDefinition](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/MessageStreamDefinition.html)
------
#### [ Node.js ]
```
const client = new StreamManagerClient();
client.onConnected(async () => {
try {
const messageStreamInfo = await c.describeMessageStream(STREAM_NAME);
await client.updateMessageStream(
messageStreamInfo.definition
// Max Size update should be greater than initial Max Size defined in Create Message Stream request
.withMaxSize(536870912) // Default is 256 MB. Updating Max Size to 512 MB.
.withStreamSegmentSize(33554432) // Default is 16 MB. Updating Segment Size to 32 MB.
.withTimeToLiveMillis(3600000) // By default, no TTL is enabled. Update TTL to 1 hour.
.withStrategyOnFull(StrategyOnFull.RejectNewData) // Required. Updating Strategy on full to reject new data.
.withPersistence(Persistence.Memory) // Default is File. Update the persistence to Memory
.withFlushOnWrite(true) // Default is false. Updating to true.
.withExportDefinition(
// Optional. Choose where/how the stream is exported to the AWS Cloud.
messageStreamInfo.definition.exportDefinition
// Updating Export definition to add a Kinesis Stream configuration.
.withKinesis([new KinesisConfig().withIdentifier(uuidv4()).withKinesisStreamName(uuidv4())])
)
);
} catch (e) {
// Properly handle errors.
}
});
client.onError((err) => {
// Properly handle connection errors.
// This is called only when the connection to the StreamManager server fails.
});
```
Référence du SDK Node.js : \$1 [updateMessageStream[MessageStreamDefinition](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.MessageStreamDefinition.html)](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#updateMessageStream)
------
### Contraintes de mise à jour des flux
Les contraintes suivantes s'appliquent lors de la mise à jour des flux. Sauf indication contraire dans la liste suivante, les mises à jour prennent effet immédiatement.
+ Vous ne pouvez pas mettre à jour la persistance d'un flux. Pour modifier ce comportement, [supprimez le flux](#streammanagerclient-delete-message-stream) et [créez un flux](#streammanagerclient-create-message-stream) qui définit la nouvelle politique de persistance.
+ Vous pouvez mettre à jour la taille maximale d'un flux uniquement dans les conditions suivantes :
+ La taille maximale doit être supérieure ou égale à la taille actuelle du flux. Pour trouver ces informations, [décrivez le flux](#streammanagerclient-describe-message-stream), puis vérifiez l'état de stockage de l'`MessageStreamInfo`objet renvoyé.
+ La taille maximale doit être supérieure ou égale à la taille du segment du flux.
+ Vous pouvez mettre à jour la taille du segment de flux à une valeur inférieure à la taille maximale du flux. Le paramètre mis à jour s'applique aux nouveaux segments.
+ Les mises à jour de la propriété Time to Live (TTL) s'appliquent aux nouvelles opérations d'ajout. Si vous diminuez cette valeur, le gestionnaire de flux peut également supprimer les segments existants qui dépassent le TTL.
+ Les mises à jour de la stratégie relative à la propriété complète s'appliquent aux nouvelles opérations d'ajout. Si vous définissez une stratégie pour remplacer les données les plus anciennes, le gestionnaire de flux peut également remplacer les segments existants en fonction du nouveau paramètre.
+ Les mises à jour de la propriété flush on write s'appliquent aux nouveaux messages.
+ Les mises à jour des configurations d'exportation s'appliquent aux nouvelles exportations. La demande de mise à jour doit inclure toutes les configurations d'exportation que vous souhaitez prendre en charge. Dans le cas contraire, le gestionnaire de flux les supprime.
+ Lorsque vous mettez à jour une configuration d'exportation, spécifiez l'identifiant de la configuration d'exportation cible.
+ Pour ajouter une configuration d'exportation, spécifiez un identifiant unique pour la nouvelle configuration d'exportation.
+ Pour supprimer une configuration d'exportation, omettez-la.
+ Pour [mettre à jour](#streammanagerclient-update-message-stream) le numéro de séquence de départ d'une configuration d'exportation dans un flux, vous devez spécifier une valeur inférieure au dernier numéro de séquence. Pour trouver ces informations, [décrivez le flux](#streammanagerclient-describe-message-stream), puis vérifiez l'état de stockage de l'`MessageStreamInfo`objet renvoyé.
## Supprimer le flux de messages
Supprime un flux. Lorsque vous supprimez un flux, toutes les données stockées dans le flux sont supprimées du disque.
### Exigences
Cette opération répond aux exigences suivantes :
+ Version minimale AWS IoT Greengrass du noyau : 1.10.0
+ Version minimale AWS IoT Greengrass du SDK de base : Python : 1.5.0 \$1 Java : 1.4.0 \$1 Node.js : 1.6.0
### Exemples
L'extrait de code suivant supprime le flux nommé `StreamName`.
------
#### [ Python ]
```
client = StreamManagerClient()
try:
client.delete_message_stream(stream_name="StreamName")
except StreamManagerException:
pass
# Properly handle errors.
except ConnectionError or asyncio.TimeoutError:
pass
# Properly handle errors.
```
Référence du SDK Python : [deleteMessageStream](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html#greengrasssdk.stream_manager.streammanagerclient.StreamManagerClient.delete_message_stream)
------
#### [ Java ]
```
try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) {
client.deleteMessageStream("StreamName");
} catch (StreamManagerException e) {
// Properly handle exception.
}
```
[Référence du SDK Java : delete\$1message\$1stream](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#deleteMessageStream-java.lang.String-)
------
#### [ Node.js ]
```
const client = new StreamManagerClient();
client.onConnected(async () => {
try {
await client.deleteMessageStream("StreamName");
} catch (e) {
// Properly handle errors.
}
});
client.onError((err) => {
// Properly handle connection errors.
// This is called only when the connection to the StreamManager server fails.
});
```
Référence du SDK Node.js : [deleteMessageStream](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#deleteMessageStream)
------
## 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)
+ [Exporter les configurations pour les AWS Cloud destinations prises en charge](stream-export-configurations.md)
+ [Exporter des flux de données vers AWS Cloud (console)](stream-manager-console.md)
+ [Exporter des flux de données vers le AWS Cloud (CLI)](stream-manager-cli.md)
+ `StreamManagerClient`dans la référence du SDK AWS IoT Greengrass Core :
+ [Python](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html)
+ [Java](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html)
+ [Node.js](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html)
# Exporter les configurations pour les AWS Cloud destinations prises en charge
Les fonctions Lambda définies par l'utilisateur sont `StreamManagerClient` utilisées dans AWS IoT Greengrass le SDK Core pour interagir avec le gestionnaire de flux. Lorsqu'une fonction Lambda [crée un flux](work-with-streams.md#streammanagerclient-create-message-stream) ou [met à jour un flux](work-with-streams.md#streammanagerclient-create-message-stream), elle transmet un `MessageStreamDefinition` objet qui représente les propriétés du flux, y compris la définition de l'exportation. L'`ExportDefinition`objet contient les configurations d'exportation définies pour le flux. Le gestionnaire de flux utilise ces configurations d'exportation pour déterminer où et comment exporter le flux.
![\[Schéma du modèle d'objet du type de ExportDefinition propriété.\]](http://docs.aws.amazon.com/fr_fr/greengrass/v1/developerguide/images/stream-manager-exportconfigs.png)
Vous pouvez définir zéro ou plusieurs configurations d'exportation sur un flux, y compris plusieurs configurations d'exportation pour un seul type de destination. Par exemple, vous pouvez exporter un flux vers deux AWS IoT Analytics canaux et un flux de données Kinesis.
En cas d'échec des tentatives d'exportation, le gestionnaire de flux essaie continuellement d'exporter les données à des AWS Cloud intervalles allant jusqu'à cinq minutes. Le nombre de nouvelles tentatives n'est pas limité.
**Note**
`StreamManagerClient`fournit également une destination cible que vous pouvez utiliser pour exporter des flux vers un serveur HTTP. Cette cible n'est destinée qu'à des fins de test. Il n'est pas stable ni pris en charge pour une utilisation dans des environnements de production.
**Topics**
+ [AWS IoT Analytics chaînes](#export-to-iot-analytics)
+ [Flux de données Amazon Kinesis](#export-to-kinesis)
+ [AWS IoT SiteWise propriétés des actifs](#export-to-iot-sitewise)
+ [Objets Amazon S3](#export-to-s3)
Vous êtes responsable de la maintenance de ces AWS Cloud ressources.
## AWS IoT Analytics chaînes
Le gestionnaire de flux prend en charge les exportations automatiques vers AWS IoT Analytics. AWS IoT Analytics vous permet d'effectuer une analyse avancée de vos données afin de prendre des décisions commerciales et d'améliorer les modèles d'apprentissage automatique. Pour plus d'informations, voir [Qu'est-ce que c'est AWS IoT Analytics ?](https://docs.aws.amazon.com/iotanalytics/latest/userguide/welcome.html) dans le *guide de AWS IoT Analytics l'utilisateur*.
Dans le SDK AWS IoT Greengrass principal, vos fonctions Lambda utilisent `IoTAnalyticsConfig` le pour définir la configuration d'exportation pour ce type de destination. Pour plus d'informations, consultez la référence du SDK pour votre langue cible :
+ [Io TAnalytics Config](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.IoTAnalyticsConfig) dans le SDK Python
+ [Io TAnalytics Config](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/export/IoTAnalyticsConfig.html) dans le SDK Java
+ [Io TAnalytics Config](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.IoTAnalyticsConfig.html) dans le SDK Node.js
### Exigences
Cette destination d'exportation répond aux exigences suivantes :
+ Les canaux cibles entrants AWS IoT Analytics doivent appartenir au même groupe Greengrass Compte AWS et Région AWS appartenir à celui-ci.
+ Ils [Rôle de groupe Greengrass](group-role.md) doivent `iotanalytics:BatchPutMessage` autoriser les chaînes cibles. Par exemple :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iotanalytics:BatchPutMessage"
],
"Resource": [
"arn:aws:iotanalytics:us-east-1:123456789012:channel/channel_1_name",
"arn:aws:iotanalytics:us-east-1:123456789012:channel/channel_2_name"
]
}
]
}
```
------
Vous pouvez accorder un accès granulaire ou conditionnel aux ressources, par exemple en utilisant un schéma de `*` dénomination générique. Pour plus d'informations, consultez la section [Ajout et suppression de politiques IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) dans le Guide de l'*utilisateur IAM*.
### Exporter vers AWS IoT Analytics
Pour créer un flux exporté vers AWS IoT Analytics, vos fonctions Lambda [créent un flux avec une](work-with-streams.md#streammanagerclient-create-message-stream) définition d'exportation qui inclut un ou plusieurs `IoTAnalyticsConfig` objets. Cet objet définit les paramètres d'exportation, tels que le canal cible, la taille du lot, l'intervalle entre les lots et la priorité.
Lorsque vos fonctions Lambda reçoivent des données provenant d'appareils, elles [ajoutent des messages](work-with-streams.md#streammanagerclient-append-message) contenant un blob de données au flux cible.
Le gestionnaire de flux exporte ensuite les données en fonction des paramètres de lot et de la priorité définis dans les configurations d'exportation du flux.
## Flux de données Amazon Kinesis
Le gestionnaire de flux prend en charge les exportations automatiques vers Amazon Kinesis Data Streams. Kinesis Data Streams est couramment utilisé pour agréger de gros volumes de données et les charger dans un entrepôt de données ou un cluster Map-Reduce. Pour plus d'informations, consultez [Qu'est-ce qu'Amazon Kinesis Data Streams ?](https://docs.aws.amazon.com/streams/latest/dev/what-is-this-service.html) dans le manuel *Amazon Kinesis Developer Guide*.
Dans le SDK AWS IoT Greengrass principal, vos fonctions Lambda utilisent `KinesisConfig` le pour définir la configuration d'exportation pour ce type de destination. Pour plus d'informations, consultez la référence du SDK pour votre langue cible :
+ [KinesisConfig](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.KinesisConfig)dans le SDK Python
+ [KinesisConfig](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/export/KinesisConfig.html)dans le SDK Java
+ [KinesisConfig](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.KinesisConfig.html)dans le SDK Node.js
### Exigences
Cette destination d'exportation répond aux exigences suivantes :
+ Les flux cibles dans Kinesis Data Streams doivent appartenir au Compte AWS même groupe Greengrass Région AWS et appartenir à celui-ci.
+ Ils [Rôle de groupe Greengrass](group-role.md) doivent `kinesis:PutRecords` autoriser le ciblage des flux de données. Par exemple :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"kinesis:PutRecords"
],
"Resource": [
"arn:aws:kinesis:us-east-1:123456789012:stream/stream_1_name",
"arn:aws:kinesis:us-east-1:123456789012:stream/stream_2_name"
]
}
]
}
```
------
Vous pouvez accorder un accès granulaire ou conditionnel aux ressources, par exemple en utilisant un schéma de `*` dénomination générique. Pour plus d'informations, consultez la section [Ajout et suppression de politiques IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) dans le Guide de l'*utilisateur IAM*.
### Exportation vers Kinesis Data Streams
Pour créer un flux exporté vers Kinesis Data Streams, vos [fonctions Lambda créent un flux avec une](work-with-streams.md#streammanagerclient-create-message-stream) définition d'exportation qui inclut un ou plusieurs objets. `KinesisConfig` Cet objet définit les paramètres d'exportation, tels que le flux de données cible, la taille du lot, l'intervalle entre les lots et la priorité.
Lorsque vos fonctions Lambda reçoivent des données provenant d'appareils, elles [ajoutent des messages](work-with-streams.md#streammanagerclient-append-message) contenant un blob de données au flux cible. Le gestionnaire de flux exporte ensuite les données en fonction des paramètres de lot et de la priorité définis dans les configurations d'exportation du flux.
Le gestionnaire de flux génère un UUID unique et aléatoire comme clé de partition pour chaque enregistrement chargé sur Amazon Kinesis.
## AWS IoT SiteWise propriétés des actifs
Le gestionnaire de flux prend en charge les exportations automatiques vers AWS IoT SiteWise. AWS IoT SiteWise vous permet de collecter, d'organiser et d'analyser les données des équipements industriels à grande échelle. Pour plus d'informations, voir [Qu'est-ce que c'est AWS IoT SiteWise ?](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/what-is-sitewise.html) dans le *guide de AWS IoT SiteWise l'utilisateur*.
Dans le SDK AWS IoT Greengrass principal, vos fonctions Lambda utilisent `IoTSiteWiseConfig` le pour définir la configuration d'exportation pour ce type de destination. Pour plus d'informations, consultez la référence du SDK pour votre langue cible :
+ [Io TSite WiseConfig](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.IoTSiteWiseConfig) dans le SDK Python
+ [Io TSite WiseConfig](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/export/IoTSiteWiseConfig.html) dans le SDK Java
+ [Io TSite WiseConfig](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.IoTSiteWiseConfig.html) dans le SDK Node.js
**Note**
AWS fournit également le[SiteWise Connecteur IoT](iot-sitewise-connector.md), qui est une solution prédéfinie que vous pouvez utiliser avec des sources OPC-UA.
### Exigences
Cette destination d'exportation répond aux exigences suivantes :
+ Les propriétés des actifs cibles AWS IoT SiteWise doivent appartenir aux mêmes Compte AWS et à Région AWS celles du groupe Greengrass.
**Note**
Pour la liste des régions prises AWS IoT SiteWise en charge, voir les [AWS IoT SiteWise points de terminaison et les quotas](https://docs.aws.amazon.com/general/latest/gr/iot-sitewise.html#iot-sitewise_region) dans la *référence AWS générale*.
+ Ils [Rôle de groupe Greengrass](group-role.md) doivent `iotsitewise:BatchPutAssetPropertyValue` autoriser le ciblage des propriétés des actifs. L'exemple de politique suivant utilise la clé de `iotsitewise:assetHierarchyPath` condition pour accorder l'accès à une ressource racine cible et à ses enfants. Vous pouvez le supprimer `Condition` de la politique pour autoriser l'accès à tous vos AWS IoT SiteWise actifs ou spécifier ARNs des actifs individuels.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iotsitewise:BatchPutAssetPropertyValue",
"Resource": "*",
"Condition": {
"StringLike": {
"iotsitewise:assetHierarchyPath": [
"/root node asset ID",
"/root node asset ID/*"
]
}
}
}
]
}
```
------
Vous pouvez accorder un accès granulaire ou conditionnel aux ressources, par exemple en utilisant un schéma de `*` dénomination générique. Pour plus d'informations, consultez la section [Ajout et suppression de politiques IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) dans le Guide de l'*utilisateur IAM*.
Pour obtenir des informations de sécurité importantes, consultez la section [ BatchPutAssetPropertyValue autorisation](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/security_iam_service-with-iam.html#security_iam_service-with-iam-id-based-policies-batchputassetpropertyvalue-action) dans le *guide de AWS IoT SiteWise l'utilisateur*.
### Exporter vers AWS IoT SiteWise
Pour créer un flux exporté vers AWS IoT SiteWise, vos fonctions Lambda [créent un flux avec une](work-with-streams.md#streammanagerclient-create-message-stream) définition d'exportation qui inclut un ou plusieurs `IoTSiteWiseConfig` objets. Cet objet définit les paramètres d'exportation, tels que la taille du lot, l'intervalle entre les lots et la priorité.
Lorsque vos fonctions Lambda reçoivent des données sur les propriétés des actifs de la part d'appareils, elles ajoutent des messages contenant ces données au flux cible. Les messages sont des `PutAssetPropertyValueEntry` objets sérialisés en JSON qui contiennent des valeurs de propriété pour une ou plusieurs propriétés d'actifs. Pour plus d'informations, voir [Ajouter un message pour](work-with-streams.md#streammanagerclient-append-message-sitewise) les destinations AWS IoT SiteWise d'exportation.
**Note**
Lorsque vous envoyez des données à AWS IoT SiteWise, celles-ci doivent répondre aux exigences de l'`BatchPutAssetPropertyValue`action. Pour plus d’informations, consultez [BatchPutAssetPropertyValue](https://docs.aws.amazon.com/iot-sitewise/latest/APIReference/API_BatchPutAssetPropertyValue.html) dans la *Référence d’API AWS IoT SiteWise *.
Le gestionnaire de flux exporte ensuite les données en fonction des paramètres de lot et de la priorité définis dans les configurations d'exportation du flux.
Vous pouvez ajuster les paramètres de votre gestionnaire de flux et la logique de la fonction Lambda pour concevoir votre stratégie d'exportation. Par exemple :
+ Pour les exportations en temps quasi réel, définissez des paramètres de taille de lot et d'intervalle faibles et ajoutez les données au flux dès leur réception.
+ Pour optimiser le traitement par lots, atténuer les contraintes de bande passante ou minimiser les coûts, vos fonctions Lambda peuvent regrouper timestamp-quality-value les points de données (TQV) reçus pour une propriété d'actif unique avant d'ajouter les données au flux. L'une des stratégies consiste à regrouper les entrées pour un maximum de 10 combinaisons propriétés-actifs différentes, ou alias de propriété, dans un seul message au lieu d'envoyer plusieurs entrées pour la même propriété. Cela permet au gestionnaire de flux de rester dans les limites [AWS IoT SiteWise des quotas](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/quotas.html).
## Objets Amazon S3
Le gestionnaire de flux prend en charge les exportations automatiques vers Amazon S3. Vous pouvez utiliser Amazon S3 pour stocker et récupérer de grandes quantités de données. Pour plus d'informations, consultez [Qu'est-ce qu'Amazon S3 ?](https://docs.aws.amazon.com/AmazonS3/latest/dev/Welcome.html) dans le *guide du développeur Amazon Simple Storage Service*.
Dans le SDK AWS IoT Greengrass principal, vos fonctions Lambda utilisent `S3ExportTaskExecutorConfig` le pour définir la configuration d'exportation pour ce type de destination. Pour plus d'informations, consultez la référence du SDK pour votre langue cible :
+ [S3 ExportTaskExecutorConfig](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.S3ExportTaskExecutorConfig) dans le SDK Python
+ [S3 ExportTaskExecutorConfig](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/export/S3ExportTaskExecutorConfig.html) dans le SDK Java
+ [S3 ExportTaskExecutorConfig](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.S3ExportTaskExecutorConfig.html) dans le SDK Node.js
### Exigences
Cette destination d'exportation répond aux exigences suivantes :
+ Les compartiments Amazon S3 cibles doivent appartenir au même groupe Compte AWS que le groupe Greengrass.
+ Si la [conteneurisation par défaut](lambda-group-config.md#lambda-containerization-groupsettings) du groupe Greengrass est le **conteneur** Greengrass, vous devez définir le paramètre [STREAM\$1MANAGER\$1READ\$1ONLY\$1DIRS pour utiliser un répertoire](configure-stream-manager.md#stream-manager-read-only-directories) de fichiers d'entrée situé sous le système de fichiers racine ou non. `/tmp`
+ Si une fonction Lambda exécutée en mode **conteneur Greengrass** écrit des fichiers d'entrée dans le répertoire des fichiers d'entrée, vous devez créer une ressource de volume locale pour le répertoire et monter le répertoire dans le conteneur avec des autorisations d'écriture. Cela garantit que les fichiers sont écrits dans le système de fichiers racine et visibles en dehors du conteneur. Pour de plus amples informations, veuillez consulter [Accédez aux ressources locales grâce aux fonctions et connecteurs Lambda](access-local-resources.md).
+ Ils [Rôle de groupe Greengrass](group-role.md) doivent accorder les autorisations suivantes aux compartiments cibles. Par exemple :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:AbortMultipartUpload",
"s3:ListMultipartUploadParts"
],
"Resource": [
"arn:aws:s3:::bucket-1-name/*",
"arn:aws:s3:::bucket-2-name/*"
]
}
]
}
```
------
Vous pouvez accorder un accès granulaire ou conditionnel aux ressources, par exemple en utilisant un schéma de `*` dénomination générique. Pour plus d'informations, consultez la section [Ajout et suppression de politiques IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) dans le Guide de l'*utilisateur IAM*.
### Exportation vers Amazon S3
Pour créer un flux exporté vers Amazon S3, vos fonctions Lambda utilisent l'`S3ExportTaskExecutorConfig`objet pour configurer la politique d'exportation. La politique définit les paramètres d'exportation, tels que le seuil et la priorité du téléchargement en plusieurs parties. Pour les exportations Amazon S3, le gestionnaire de flux télécharge les données qu'il lit à partir de fichiers locaux sur l'appareil principal. Pour lancer un téléchargement, vos fonctions Lambda ajoutent une tâche d'exportation au flux cible. La tâche d'exportation contient des informations sur le fichier d'entrée et l'objet Amazon S3 cible. Le gestionnaire de flux exécute les tâches dans l'ordre dans lequel elles sont ajoutées au flux.
**Note**
Le compartiment cible doit déjà exister dans votre Compte AWS. Si aucun objet correspondant à la clé spécifiée n'existe, le gestionnaire de flux le crée pour vous.
Ce flux de travail de haut niveau est illustré dans le schéma suivant.
![\[Schéma du flux de travail du gestionnaire de flux pour les exportations Amazon S3.\]](http://docs.aws.amazon.com/fr_fr/greengrass/v1/developerguide/images/stream-manager-s3.png)
Le gestionnaire de flux utilise la propriété de seuil de téléchargement en plusieurs parties, le paramètre de [taille de pièce minimale](configure-stream-manager.md#stream-manager-minimum-part-size) et la taille du fichier d'entrée pour déterminer le mode de téléchargement des données. Le seuil de téléchargement partitionné doit être supérieur ou égal à la taille de pièce minimale. Si vous souhaitez télécharger des données en parallèle, vous pouvez créer plusieurs flux.
Les clés qui spécifient vos objets Amazon S3 cibles peuvent inclure des DateTimeFormatter chaînes [Java](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html) valides dans les `!{timestamp:value}` espaces réservés. Vous pouvez utiliser ces espaces réservés d'horodatage pour partitionner les données dans Amazon S3 en fonction de l'heure à laquelle les données du fichier d'entrée ont été téléchargées. Par exemple, le nom de clé suivant correspond à une valeur telle que`my-key/2020/12/31/data.txt`.
```
my-key/!{timestamp:YYYY}/!{timestamp:MM}/!{timestamp:dd}/data.txt
```
**Note**
Si vous souhaitez surveiller l'état d'exportation d'un flux, créez d'abord un flux d'état, puis configurez le flux d'exportation pour l'utiliser. Pour de plus amples informations, veuillez consulter [Surveiller les tâches d'exportation](#monitor-export-status-s3).
#### Gérer les données d'entrée
Vous pouvez créer du code que les applications IoT utilisent pour gérer le cycle de vie des données d'entrée. L'exemple de flux de travail suivant montre comment vous pouvez utiliser les fonctions Lambda pour gérer ces données.
1. Un processus local reçoit des données provenant d'appareils ou de périphériques, puis écrit les données dans des fichiers situés dans un répertoire du périphérique principal. Il s'agit des fichiers d'entrée pour le gestionnaire de flux.
**Note**
Pour déterminer si vous devez configurer l'accès au répertoire du fichier d'entrée, consultez le paramètre [STREAM\$1MANAGER\$1READ\$1ONLY\$1DIRS](configure-stream-manager.md#stream-manager-read-only-directories).
Le processus dans lequel le gestionnaire de flux s'exécute hérite de toutes les autorisations du système de fichiers associées à l'[identité d'accès par défaut](lambda-group-config.md#lambda-access-identity-groupsettings) du groupe. Le gestionnaire de flux doit être autorisé à accéder aux fichiers d'entrée. Vous pouvez utiliser la `chmod(1)` commande pour modifier l'autorisation des fichiers, si nécessaire.
1. Une fonction Lambda analyse le répertoire et [ajoute une tâche d'exportation](work-with-streams.md#streammanagerclient-append-message-export-task) au flux cible lorsqu'un nouveau fichier est créé. La tâche est un `S3ExportTaskDefinition` objet sérialisé en JSON qui spécifie l'URL du fichier d'entrée, le compartiment et la clé Amazon S3 cibles, ainsi que les métadonnées utilisateur facultatives.
1. Le gestionnaire de flux lit le fichier d'entrée et exporte les données vers Amazon S3 dans l'ordre des tâches ajoutées. Le compartiment cible doit déjà exister dans votre Compte AWS. Si aucun objet correspondant à la clé spécifiée n'existe, le gestionnaire de flux le crée pour vous.
1. La fonction Lambda [lit les messages](work-with-streams.md#streammanagerclient-read-messages) d'un flux d'état pour surveiller le statut de l'exportation. Une fois les tâches d'exportation terminées, la fonction Lambda peut supprimer les fichiers d'entrée correspondants. Pour de plus amples informations, veuillez consulter [Surveiller les tâches d'exportation](#monitor-export-status-s3).
### Surveiller les tâches d'exportation
Vous pouvez créer du code que les applications IoT utilisent pour surveiller le statut de vos exportations Amazon S3. Vos fonctions Lambda doivent créer un flux d'état, puis configurer le flux d'exportation pour écrire des mises à jour de statut dans le flux d'état. Un seul flux de statut peut recevoir des mises à jour de statut provenant de plusieurs flux exportés vers Amazon S3.
[Créez d'abord un flux](work-with-streams.md#streammanagerclient-create-message-stream) à utiliser comme flux d'état. Vous pouvez configurer la taille et les politiques de rétention du flux afin de contrôler la durée de vie des messages d'état. Par exemple :
+ Définissez `Persistence` cette `Memory` option si vous ne souhaitez pas enregistrer les messages d'état.
+ Réglé `StrategyOnFull` sur pour `OverwriteOldestData` que les nouveaux messages d'état ne soient pas perdus.
Créez ou mettez à jour le flux d'exportation pour utiliser le flux d'état. Spécifiquement, définissez la propriété de configuration d'état de la configuration `S3ExportTaskExecutorConfig` d'exportation du flux. Cela indique au gestionnaire de flux d'écrire des messages d'état concernant les tâches d'exportation dans le flux d'état. Dans l'`StatusConfig`objet, spécifiez le nom du flux d'état et le niveau de verbosité. Les valeurs prises en charge suivantes vont de la moins détaillée (`ERROR`) à la plus détaillée (). `TRACE` La valeur par défaut est `INFO`.
+ `ERROR`
+ `WARN`
+ `INFO`
+ `DEBUG`
+ `TRACE`
L'exemple de flux de travail suivant montre comment les fonctions Lambda peuvent utiliser un flux d'état pour surveiller le statut des exportations.
1. Comme décrit dans le flux de travail précédent, une fonction Lambda [ajoute une tâche d'exportation](work-with-streams.md#streammanagerclient-append-message-export-task) à un flux configuré pour écrire des messages d'état concernant les tâches d'exportation dans un flux de statut. L'opération d'ajout renvoie un numéro de séquence qui représente l'ID de tâche.
1. Une fonction Lambda [lit les messages](work-with-streams.md#streammanagerclient-read-messages) de manière séquentielle à partir du flux d'état, puis filtre les messages en fonction du nom du flux et de l'ID de tâche ou en fonction d'une propriété de tâche d'exportation du contexte du message. Par exemple, la fonction Lambda peut filtrer en fonction de l'URL du fichier d'entrée de la tâche d'exportation, qui est représentée par l'`S3ExportTaskDefinition`objet dans le contexte du message.
Les codes d'état suivants indiquent qu'une tâche d'exportation est terminée :
+ `Success`. Le téléchargement a été effectué avec succès.
+ `Failure`. Le gestionnaire de flux a rencontré une erreur. Par exemple, le bucket spécifié n'existe pas. Une fois le problème résolu, vous pouvez à nouveau ajouter la tâche d'exportation au flux.
+ `Canceled`. La tâche a été abandonnée car le flux ou la définition d'exportation a été supprimé, ou parce que la période time-to-live (TTL) de la tâche a expiré.
**Note**
La tâche peut également avoir le statut `InProgress` ou`Warning`. Le gestionnaire de flux émet des avertissements lorsqu'un événement renvoie une erreur qui n'affecte pas l'exécution de la tâche. Par exemple, l'échec du nettoyage d'un téléchargement partiel interrompu renvoie un avertissement.
1. Une fois les tâches d'exportation terminées, la fonction Lambda peut supprimer les fichiers d'entrée correspondants.
L'exemple suivant montre comment une fonction Lambda peut lire et traiter les messages d'état.
------
#### [ Python ]
```
import time
from greengrasssdk.stream_manager import (
ReadMessagesOptions,
Status,
StatusConfig,
StatusLevel,
StatusMessage,
StreamManagerClient,
)
from greengrasssdk.stream_manager.util import Util
client = StreamManagerClient()
try:
# Read the statuses from the export status stream
is_file_uploaded_to_s3 = False
while not is_file_uploaded_to_s3:
try:
messages_list = client.read_messages(
"StatusStreamName", ReadMessagesOptions(min_message_count=1, read_timeout_millis=1000)
)
for message in messages_list:
# Deserialize the status message first.
status_message = Util.deserialize_json_bytes_to_obj(message.payload, StatusMessage)
# Check the status of the status message. If the status is "Success",
# the file was successfully uploaded to S3.
# If the status was either "Failure" or "Cancelled", the server was unable to upload the file to S3.
# We will print the message for why the upload to S3 failed from the status message.
# If the status was "InProgress", the status indicates that the server has started uploading
# the S3 task.
if status_message.status == Status.Success:
logger.info("Successfully uploaded file at path " + file_url + " to S3.")
is_file_uploaded_to_s3 = True
elif status_message.status == Status.Failure or status_message.status == Status.Canceled:
logger.info(
"Unable to upload file at path " + file_url + " to S3. Message: " + status_message.message
)
is_file_uploaded_to_s3 = True
time.sleep(5)
except StreamManagerException:
logger.exception("Exception while running")
except StreamManagerException:
pass
# Properly handle errors.
except ConnectionError or asyncio.TimeoutError:
pass
# Properly handle errors.
```
Référence du SDK Python : [read\$1messages \$1 [StatusMessage](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.StatusMessage)](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html#greengrasssdk.stream_manager.streammanagerclient.StreamManagerClient.read_messages)
------
#### [ Java ]
```
import com.amazonaws.greengrass.streammanager.client.StreamManagerClient;
import com.amazonaws.greengrass.streammanager.client.utils.ValidateAndSerialize;
import com.amazonaws.greengrass.streammanager.model.ReadMessagesOptions;
import com.amazonaws.greengrass.streammanager.model.Status;
import com.amazonaws.greengrass.streammanager.model.StatusConfig;
import com.amazonaws.greengrass.streammanager.model.StatusLevel;
import com.amazonaws.greengrass.streammanager.model.StatusMessage;
try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) {
try {
boolean isS3UploadComplete = false;
while (!isS3UploadComplete) {
try {
// Read the statuses from the export status stream
List messages = client.readMessages("StatusStreamName",
new ReadMessagesOptions().withMinMessageCount(1L).withReadTimeoutMillis(1000L));
for (Message message : messages) {
// Deserialize the status message first.
StatusMessage statusMessage = ValidateAndSerialize.deserializeJsonBytesToObj(message.getPayload(), StatusMessage.class);
// Check the status of the status message. If the status is "Success", the file was successfully uploaded to S3.
// If the status was either "Failure" or "Canceled", the server was unable to upload the file to S3.
// We will print the message for why the upload to S3 failed from the status message.
// If the status was "InProgress", the status indicates that the server has started uploading the S3 task.
if (Status.Success.equals(statusMessage.getStatus())) {
System.out.println("Successfully uploaded file at path " + FILE_URL + " to S3.");
isS3UploadComplete = true;
} else if (Status.Failure.equals(statusMessage.getStatus()) || Status.Canceled.equals(statusMessage.getStatus())) {
System.out.println(String.format("Unable to upload file at path %s to S3. Message %s",
statusMessage.getStatusContext().getS3ExportTaskDefinition().getInputUrl(),
statusMessage.getMessage()));
sS3UploadComplete = true;
}
}
} catch (StreamManagerException ignored) {
} finally {
// Sleep for sometime for the S3 upload task to complete before trying to read the status message.
Thread.sleep(5000);
}
} catch (e) {
// Properly handle errors.
}
} catch (StreamManagerException e) {
// Properly handle exception.
}
```
Référence du SDK Java : [ReadMessages \$1 [StatusMessage](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/StatusMessage.html)](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#readMessages-java.lang.String-com.amazonaws.greengrass.streammanager.model.ReadMessagesOptions-)
------
#### [ Node.js ]
```
const {
StreamManagerClient, ReadMessagesOptions,
Status, StatusConfig, StatusLevel, StatusMessage,
util,
} = require('aws-greengrass-core-sdk').StreamManager;
const client = new StreamManagerClient();
client.onConnected(async () => {
try {
let isS3UploadComplete = false;
while (!isS3UploadComplete) {
try {
// Read the statuses from the export status stream
const messages = await c.readMessages("StatusStreamName",
new ReadMessagesOptions()
.withMinMessageCount(1)
.withReadTimeoutMillis(1000));
messages.forEach((message) => {
// Deserialize the status message first.
const statusMessage = util.deserializeJsonBytesToObj(message.payload, StatusMessage);
// Check the status of the status message. If the status is 'Success', the file was successfully uploaded to S3.
// If the status was either 'Failure' or 'Cancelled', the server was unable to upload the file to S3.
// We will print the message for why the upload to S3 failed from the status message.
// If the status was "InProgress", the status indicates that the server has started uploading the S3 task.
if (statusMessage.status === Status.Success) {
console.log(`Successfully uploaded file at path ${FILE_URL} to S3.`);
isS3UploadComplete = true;
} else if (statusMessage.status === Status.Failure || statusMessage.status === Status.Canceled) {
console.log(`Unable to upload file at path ${FILE_URL} to S3. Message: ${statusMessage.message}`);
isS3UploadComplete = true;
}
});
// Sleep for sometime for the S3 upload task to complete before trying to read the status message.
await new Promise((r) => setTimeout(r, 5000));
} catch (e) {
// Ignored
}
} catch (e) {
// Properly handle errors.
}
});
client.onError((err) => {
// Properly handle connection errors.
// This is called only when the connection to the StreamManager server fails.
});
```
Référence du SDK Node.js : [ReadMessages \$1 [StatusMessage](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StatusMessage.html)](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#readMessages)
------
# 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)
# Exporter des flux de données vers le AWS Cloud (CLI)
Ce didacticiel explique comment utiliser le AWS CLI 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.
Lorsque vous utilisez l' AWS IoT Greengrass API, qui inclut les commandes Greengrass dans AWS CLI, pour créer un groupe, le gestionnaire de flux est désactivé par défaut. Pour activer le gestionnaire de flux sur votre cœur, vous [créez une version de définition de fonction](#stream-manager-cli-create-function-definition) qui inclut la fonction `GGStreamManager` Lambda du système et une version de groupe qui fait référence à la nouvelle version de définition de fonction. Vous déployez ensuite le groupe.
## 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"
]
}
]
}
```
------
+ Ils AWS CLI sont installés et configurés sur votre ordinateur. Pour plus d'informations, voir [Installation AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) et [configuration du AWS CLI dans le](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) *guide de AWS Command Line Interface l'utilisateur*.
Les exemples de commandes de ce didacticiel sont écrits pour Linux et d'autres systèmes Unix. Si vous utilisez Windows, consultez la section [Spécification de valeurs de paramètres pour l'interface de ligne de AWS commande](https://docs.aws.amazon.com/cli/latest/userguide/cli-using-param.html) pour plus d'informations sur les différences de syntaxe.
Si la commande contient une chaîne JSON, le didacticiel fournit un exemple qui possède le fichier JSON sur une seule ligne. Sur certains systèmes, il peut être plus efficace de modifier et d'exécuter des commandes utilisant ce format.
Le didacticiel contient les étapes détaillées suivantes :
1. [Création d'un package de déploiement de fonctions Lambda](#stream-manager-cli-create-deployment-package)
1. [Création d’une fonction Lambda ](#stream-manager-cli-create-function)
1. [Créer une version et une définition de fonction](#stream-manager-cli-create-function-definition)
1. [Créer une définition et une version de l'enregistreur](#stream-manager-cli-create-logger-definition)
1. [Obtenir l'ARN de votre version de définition du noyau](#stream-manager-cli-get-core-definition-version-arn)
1. [Créer une version de groupe](#stream-manager-cli-create-group-version)
1. [Création d’un déploiement](#stream-manager-cli-create-deployment)
1. [Tester l'application](#stream-manager-cli-test-application)
Le didacticiel devrait prendre environ 30 minutes.
## Étape 1 : Création d'un package de déploiement de fonctions Lambda
Dans 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
1. Créez un rôle IAM afin de pouvoir transmettre l'ARN du rôle lors de la création de la fonction.
------
#### [ JSON Expanded ]
```
aws iam create-role --role-name Lambda_empty --assume-role-policy '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}'
```
------
#### [ JSON Single-line ]
```
aws iam create-role --role-name Lambda_empty --assume-role-policy '{"Version": "2012-10-17", "Statement": [{"Effect": "Allow", "Principal": {"Service": "lambda.amazonaws.com"},"Action": "sts:AssumeRole"}]}'
```
------
**Note**
AWS IoT Greengrass n'utilise pas ce rôle car les autorisations pour vos fonctions Greengrass Lambda sont spécifiées dans le rôle du groupe Greengrass. Dans le cadre de ce didacticiel, vous créez un rôle vide.
1. Copiez la `Arn` à partir de la sortie.
1. Utilisez l' AWS Lambda API pour créer la `TransferStream` fonction. La commande suivante suppose que le fichier ZIP se trouve dans le répertoire actuel.
+ Remplacez *role-arn* par l’`Arn` que vous avez copié.
```
aws lambda create-function \
--function-name TransferStream \
--zip-file fileb://transfer_stream_python.zip \
--role role-arn \
--handler transfer_stream.function_handler \
--runtime python3.7
```
1. Publiez une version de la fonction.
```
aws lambda publish-version --function-name TransferStream --description 'First version'
```
1. Créez un alias pour la version publiée.
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.
```
aws lambda create-alias --function-name TransferStream --name GG_TransferStream --function-version 1
```
**Note**
AWS IoT Greengrass **ne prend pas en charge les alias Lambda pour les versions \$1LATEST.**
1. Copiez la `AliasArn` à partir de la sortie. Vous utilisez cette valeur lorsque vous configurez la fonction pour AWS IoT Greengrass.
Vous êtes maintenant prêt à configurer la fonction pour AWS IoT Greengrass.
## Étape 3 : Créer une version et une définition de fonction
Cette étape crée une version de définition de fonction qui fait référence à la fonction `GGStreamManager` Lambda du système et à votre fonction Lambda définie par `TransferStream` l'utilisateur. Pour activer le gestionnaire de flux lorsque vous utilisez l' AWS IoT Greengrass API, votre version de définition de fonction doit inclure la `GGStreamManager` fonction.
1. Créez une définition de fonction avec une version initiale contenant le système et les fonctions Lambda définies par l'utilisateur.
La version de définition suivante active le gestionnaire de flux avec [les paramètres](configure-stream-manager.md) par défaut. Pour configurer des paramètres personnalisés, vous devez définir des variables d'environnement pour les paramètres du gestionnaire de flux correspondants. Pour un exemple, voir[Pour activer, désactiver ou configurer le gestionnaire de flux (CLI)](configure-stream-manager.md#enable-stream-manager-cli). AWS IoT Greengrass utilise les paramètres par défaut pour les paramètres omis. `MemorySize`devrait être au moins`128000`. `Pinned`doit être réglé sur`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).
+ *arbitrary-function-id*Remplacez-le par un nom pour la fonction, tel que**stream-manager**.
+ *alias-arn*Remplacez-le par celui `AliasArn` que vous avez copié lorsque vous avez créé l'alias de la fonction `TransferStream` Lambda.
------
#### [ JSON expanded ]
```
aws greengrass create-function-definition --name MyGreengrassFunctions --initial-version '{
"Functions": [
{
"Id": "arbitrary-function-id",
"FunctionArn": "arn:aws:lambda:::function:GGStreamManager:1",
"FunctionConfiguration": {
"MemorySize": 128000,
"Pinned": true,
"Timeout": 3
}
},
{
"Id": "TransferStreamFunction",
"FunctionArn": "alias-arn",
"FunctionConfiguration": {
"Executable": "transfer_stream.function_handler",
"MemorySize": 16000,
"Pinned": true,
"Timeout": 5
}
}
]
}'
```
------
#### [ JSON single ]
```
aws greengrass create-function-definition \
--name MyGreengrassFunctions \
--initial-version '{"Functions": [{"Id": "arbitrary-function-id","FunctionArn": "arn:aws:lambda:::function:GGStreamManager:1", "FunctionConfiguration": {"Environment": {"Variables":{"STREAM_MANAGER_STORE_ROOT_DIR": "/data","STREAM_MANAGER_SERVER_PORT": "1234","STREAM_MANAGER_EXPORTER_MAX_BANDWIDTH": "20000"}},"MemorySize": 128000,"Pinned": true,"Timeout": 3}},{"Id": "TransferStreamFunction", "FunctionArn": "alias-arn", "FunctionConfiguration": {"Executable": "transfer_stream.function_handler", "MemorySize": 16000,"Pinned": true,"Timeout": 5}}]}'
```
------
**Note**
`Timeout` est requis par la version de définition de fonction, mais `GGStreamManager` ne l'utilise pas. Pour plus d'informations sur les paramètres au niveau du groupe `Timeout` et les autres, consultez. [Contrôle de l'exécution des fonctions Greengrass Lambda à l'aide d'une configuration spécifique au groupe](lambda-group-config.md)
1. Copiez la `LatestVersionArn` à partir de la sortie. Vous utilisez cette valeur pour ajouter la version de définition de fonction à la version de groupe que vous déployez pour le noyau.
## Étape 4 : Créer une définition et une version de l'enregistreur
Configurez les paramètres de journalisation du groupe. Dans ce didacticiel, vous allez configurer les composants AWS IoT Greengrass du système, les fonctions Lambda définies par l'utilisateur et les connecteurs 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. Créez une définition d'enregistreur qui inclut une version initiale.
------
#### [ JSON Expanded ]
```
aws greengrass create-logger-definition --name "LoggingConfigs" --initial-version '{
"Loggers": [
{
"Id": "1",
"Component": "GreengrassSystem",
"Level": "INFO",
"Space": 10240,
"Type": "FileSystem"
},
{
"Id": "2",
"Component": "Lambda",
"Level": "INFO",
"Space": 10240,
"Type": "FileSystem"
}
]
}'
```
------
#### [ JSON Single-line ]
```
aws greengrass create-logger-definition \
--name "LoggingConfigs" \
--initial-version '{"Loggers":[{"Id":"1","Component":"GreengrassSystem","Level":"INFO","Space":10240,"Type":"FileSystem"},{"Id":"2","Component":"Lambda","Level":"INFO","Space":10240,"Type":"FileSystem"}]}'
```
------
1. Copiez l'élément `LatestVersionArn` de la définition de l'enregistreur à partir de la sortie. Vous utilisez cette valeur pour ajouter la version de la définition de l'enregistreur à la version de groupe que vous déployez sur le noyau.
## Étape 5 : Obtenir l'ARN de votre version de définition du noyau
Obtenez l'ARN de la version de définition du noyau pour ensuite l'ajouter à votre nouvelle version de groupe. Pour que vous puissiez déployer une version de groupe, cette dernière doit référencer une version de définition du noyau contenant exactement un noyau.
1. Obtenez le IDs groupe Greengrass cible et la version du groupe. Cette procédure suppose qu'il s'agit de la dernière version du groupe et du groupe. La requête suivante renvoie le dernier groupe créé.
```
aws greengrass list-groups --query "reverse(sort_by(Groups, &CreationTimestamp))[0]"
```
Vous pouvez également procéder à une interrogation par nom. Les noms de groupe ne devant pas nécessairement être uniques, plusieurs groupes peuvent être renvoyés.
```
aws greengrass list-groups --query "Groups[?Name=='MyGroup']"
```
**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.
1. Copiez l'`Id` du groupe cible à partir de la sortie. Vous utilisez cela pour obtenir la version de définition du noyau et lorsque vous déployez le groupe.
1. Copiez l'élément `LatestVersion` à partir de la sortie (ID de la dernière version ajoutée au groupe). Vous utilisez cela pour obtenir la version de la définition du noyau.
1. Obtenir l'ARN de la version de la définition du noyau :
1. Obtenez la version de groupe.
+ *group-id*Remplacez-le par celui `Id` que vous avez copié pour le groupe.
+ *group-version-id*Remplacez-le par celui `LatestVersion` que vous avez copié pour le groupe.
```
aws greengrass get-group-version \
--group-id group-id \
--group-version-id group-version-id
```
1. Copiez la `CoreDefinitionVersionArn` à partir de la sortie. Vous utilisez cette valeur pour ajouter la version de définition du noyau à la version de groupe que vous déployez sur le noyau.
## Étape 6 : Créer une version de groupe
Maintenant, vous êtes prêt à créer une version de groupe contenant tous les éléments que vous souhaitez déployer. Pour ce faire, vous devez créer une version de groupe qui fait référence à la version cible de chaque type de composant. Pour ce didacticiel, vous incluez une version de définition du noyau, une version de définition de fonction et une version de définition de l'enregistreur.
1. Créer une version de groupe.
+ *group-id*Remplacez-le par celui `Id` que vous avez copié pour le groupe.
+ *core-definition-version-arn*Remplacez-le par celui `CoreDefinitionVersionArn` que vous avez copié pour la version de définition de base.
+ *function-definition-version-arn*Remplacez-le par celui `LatestVersionArn` que vous avez copié pour votre nouvelle version de définition de fonction.
+ *logger-definition-version-arn*Remplacez-le par celui `LatestVersionArn` que vous avez copié pour votre nouvelle version de définition de l'enregistreur.
```
aws greengrass create-group-version \
--group-id group-id \
--core-definition-version-arn core-definition-version-arn \
--function-definition-version-arn function-definition-version-arn \
--logger-definition-version-arn logger-definition-version-arn
```
1. Copiez la `Version` à partir de la sortie. Il s'agit de l'ID de la nouvelle version de groupe.
## Étape 7 : Créer un déploiement
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. Créez un déploiement .
+ *group-id*Remplacez-le par celui `Id` que vous avez copié pour le groupe.
+ *group-version-id*Remplacez-le par celui `Version` que vous avez copié pour la nouvelle version du groupe.
```
aws greengrass create-deployment \
--deployment-type NewDeployment \
--group-id group-id \
--group-version-id group-version-id
```
1. Copiez la `DeploymentId` à partir de la sortie.
1. Obtenir le statut du déploiement.
+ *group-id*Remplacez-le par celui `Id` que vous avez copié pour le groupe.
+ *deployment-id*Remplacez-le par celui `DeploymentId` que vous avez copié pour le déploiement.
```
aws greengrass get-deployment-status \
--group-id group-id \
--deployment-id deployment-id
```
Si le statut est le cas`Success`, le déploiement a réussi. 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 8 : 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-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. Suivez l'[Étape 6 : Créer une version de groupe](#stream-manager-cli-create-group-version) pour créer une nouvelle version de groupe, mais supprimez l'option `--function-definition-version-arn` dans la commande `create-group-version`. Vous pouvez également créer une version de définition de fonction qui n'inclut pas la fonction **TransferStream**Lambda.
**Note**
En omettant la fonction `GGStreamManager` Lambda du système dans la version du groupe déployé, vous désactivez la gestion des flux sur le cœur.
1. Suivez l'[Étape 7 : Créer un déploiement](#stream-manager-cli-create-deployment) pour déployer la nouvelle version du groupe.
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 de plus d'informations de dépannage, vous pouvez définir le niveau de journalisation `Lambda` sur `DEBUG`, puis créer et déployer une nouvelle version de groupe.
## Consultez aussi
+ [Gérez les flux de données sur le AWS IoT Greengrass cœur](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)
+ [Configuration du gestionnaire de AWS IoT Greengrass flux](configure-stream-manager.md)
+ [Exporter des flux de données vers AWS Cloud (console)](stream-manager-console.md)
+ Gestion des identités et des accès AWS commandes [(IAM) dans la référence des *AWS CLI commandes*](https://docs.aws.amazon.com/cli/latest/reference/iam)
+ [AWS Lambda commandes](https://docs.aws.amazon.com/cli/latest/reference/lambda) dans la *référence des AWS CLI commandes*
+ [AWS IoT Greengrass commandes](https://docs.aws.amazon.com/cli/latest/reference/greengrass/index.html) dans la *référence des AWS CLI commandes*