Exécuter les fonctions Lambda sur le noyau AWS IoT Greengrass - AWS IoT Greengrass

AWS IoT Greengrass Version 1 est entré dans la phase de durée de vie prolongée le 30 juin 2023. Pour plus d'informations, consultez la politique de AWS IoT Greengrass V1 maintenance. Après cette date, AWS IoT Greengrass V1 ne publiera pas de mises à jour fournissant des fonctionnalités, des améliorations, des corrections de bogues ou des correctifs de sécurité. Les appareils qui fonctionnent AWS IoT Greengrass V1 sous tension ne seront pas perturbés et continueront à fonctionner et à se connecter au cloud. Nous vous recommandons vivement de migrer vers AWS IoT Greengrass Version 2, qui ajoute de nouvelles fonctionnalités importantes et prend en charge des plateformes supplémentaires.

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.

Exécuter les fonctions Lambda sur le noyau AWS IoT Greengrass

AWS IoT Greengrassfournit un environnement d'exécution Lambda conteneurisé pour le code défini par l'utilisateur dans lequel vous créez. AWS Lambda Les fonctions Lambda déployées sur un AWS IoT Greengrass cœur s'exécutent dans le moteur d'exécution Lambda local du cœur. Les fonctions Lambda locales peuvent être déclenchées par des événements locaux, des messages provenant du cloud et d'autres sources, ce qui apporte des fonctionnalités de calcul locales aux appareils clients. Par exemple, vous pouvez utiliser les fonctions Lambda de Greengrass pour filtrer les données des appareils avant de les transmettre au cloud.

Pour déployer une fonction Lambda sur un noyau, vous ajoutez la fonction à un groupe Greengrass (en faisant référence à la fonction Lambda existante), vous configurez les paramètres spécifiques au groupe pour la fonction, puis vous déployez le groupe. Si la fonction accède AWS aux services, vous devez également ajouter les autorisations requises au rôle de groupe Greengrass.

Vous pouvez configurer les paramètres qui déterminent le mode d'exécution des fonctions Lambda, notamment les autorisations, l'isolation, les limites de mémoire, etc. Pour plus d’informations, consultez Contrôle de l'exécution des fonctions Greengrass Lambda à l'aide d'une configuration spécifique au groupe.

Note

Ces paramètres permettent également d'exécuter AWS IoT Greengrass dans un conteneur Docker. Pour plus d’informations, consultez Exécution de AWS IoT Greengrass dans un conteneur Docker.

Le tableau suivant répertorie les environnements d'exécution AWS Lambda pris en charge et les versions du logiciel AWS IoT Greengrass Core qu'ils peuvent y exécuter.

Langage ou plateforme Version de GGC
Python 3.8 1.11
Python 3.7 1.9 ou version ultérieure
Python 2.7 * 1.0 ou version ultérieure
Java 8 1.1 ou version ultérieure
Node.js 12,x * 1.10 ou version ultérieure
Node.js 8.10 * 1.9 ou version ultérieure
Node.js 6.10 * 1.1 ou version ultérieure
C, C++ 1.6 ou version ultérieure

* Vous pouvez exécuter des fonctions Lambda qui utilisent ces environnements d'exécution sur les versions prises en charge deAWS IoT Greengrass, mais vous ne pouvez pas les créer dans. AWS Lambda Si le runtime de votre appareil est différent du runtime AWS Lambda spécifié pour cette fonction, vous pouvez choisir votre propre environnement d'exécution en utilisant FunctionRuntimeOverride in. FunctionDefintionVersion Pour plus d'informations, consultez CreateFunctionDefinition. Pour plus d'informations sur les environnements d'exécution pris en charge, consultez la politique de support des environnements d'exécution dans le manuel du AWS Lambda développeur.

SDK pour les fonctions Greengrass Lambda

AWSfournit trois SDK qui peuvent être utilisés par les fonctions Greengrass Lambda exécutées sur un cœur. AWS IoT Greengrass Ces kits SDK se trouvent dans différents packages, de sorte que les fonctions peuvent les utiliser simultanément. Pour utiliser un SDK dans une fonction Lambda Greengrass, incluez-le dans le package de déploiement de la fonction Lambda vers lequel vous le téléchargez. AWS Lambda

Kits SDK AWS IoT Greengrass Core

Permet aux fonctions Lambda locales d'interagir avec le cœur pour :

  • Échange de messages MQTT avec AWS IoT Core.

  • Échangez des messages MQTT avec des connecteurs, des appareils clients et d'autres fonctions Lambda du groupe Greengrass.

  • Interagissez avec le service shadow local.

  • Appelez d'autres fonctions Lambda locales.

  • Accédez aux ressources de secret.

  • Interagissez avec le gestionnaire de flux.

AWS IoT Greengrassfournit le SDK de AWS IoT Greengrass base dans les langues et plateformes suivantes sur GitHub.

Pour inclure la dépendance du SDK AWS IoT Greengrass principal dans le package de déploiement de la fonction Lambda :

  1. Téléchargez la langue ou la plate-forme du package AWS IoT Greengrass Core SDK correspondant au temps d'exécution de votre fonction Lambda.

  2. Décompressez le package téléchargé pour obtenir le kit SDK. Le kit SDK est représenté par le dossier greengrasssdk.

  3. Incluez-le greengrasssdk dans le package de déploiement de la fonction Lambda qui contient votre code de fonction. Il s'agit du package dans lequel vous téléchargez la fonction Lambda AWS Lambda lorsque vous créez la fonction Lambda.

 

StreamManagerClient

Seuls les kits SDK AWS IoT Greengrass Core suivants peuvent être utilisés pour les opérations de 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)

Pour utiliser le SDK AWS IoT Greengrass Core pour Python afin d'interagir avec le gestionnaire de flux, vous devez installer Python 3.7 ou version ultérieure. Vous devez également installer les dépendances à inclure dans vos packages de déploiement de fonctions Python Lambda :

  1. Accédez au répertoire SDK qui contient le fichier requirements.txt. Ce fichier répertorie les dépendances.

  2. 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

 

Installez le SDK AWS IoT Greengrass Core pour Python sur l'appareil principal

Si vous exécutez des fonctions Lambda en Python, vous pouvez également les utiliser pippour installer le SDK AWS IoT Greengrass Core pour Python sur le périphérique principal. Vous pouvez ensuite déployer vos fonctions sans inclure le SDK dans le package de déploiement des fonctions Lambda. Pour plus d'informations, consultez greengrasssdk.

Cette prise en charge est destinée aux noyaux avec des contraintes de taille. Nous vous recommandons d'inclure le SDK dans vos packages de déploiement de fonctions Lambda lorsque cela est possible.

 

AWS IoT GreengrassKit de développement logiciel (SDK) pour le Machine Learning

Permet aux fonctions Lambda locales d'utiliser des modèles d'apprentissage automatique (ML) déployés sur le cœur de Greengrass sous forme de ressources ML. Les fonctions Lambda peuvent utiliser le SDK pour appeler et interagir avec un service d'inférence local déployé sur le cœur en tant que connecteur. Les fonctions Lambda et les connecteurs ML peuvent également utiliser le SDK pour envoyer des données au connecteur ML Feedback à des fins de téléchargement et de publication. Pour plus d'informations, y compris des exemples de code qui utilisent le kit SDK, consultez Connecteur de classification d'images ML, Connecteur de détection d'objets ML et Connecteur ML Feedback.

Le tableau suivant répertorie chaque plateforme ou langage pris en charge, ainsi que les versions compatibles du logiciel AWS IoT Greengrass Core.

Version de SDK Langage ou plateforme Version GGC requise Journal des modifications
1.1.0 Python 3.7 ou 2.7 1.9.3 ou version ultérieure Ajout de la prise en charge de Python 3.7 et d'un nouveau client feedback.
1.0.0 Python 2.7 1.7 ou version ultérieure Première version.

Pour obtenir des informations sur le téléchargement, consultez AWS IoT Greengrass Logiciel ML SDK.

Kits SDK AWS

Permet aux fonctions Lambda locales d'effectuer des appels directs vers AWS des services tels qu'Amazon S3, DynamoDB et. AWS IoT AWS IoT Greengrass Pour utiliser un AWS SDK dans une fonction Greengrass Lambda, vous devez l'inclure dans votre package de déploiement. Lorsque vous utilisez le AWS SDK dans le même package que le SDK AWS IoT Greengrass principal, assurez-vous que vos fonctions Lambda utilisent les espaces de noms corrects. Les fonctions Greengrass Lambda ne peuvent pas communiquer avec les services cloud lorsque le cœur est hors ligne.

Téléchargez les kits SDK AWS depuis le Centre de ressources du démarrage.

Pour plus d'informations sur la création d'un package de déploiement, reportez-vous Création et empaquetage d'une fonction Lambda au didacticiel de démarrage ou à la création d'un package de déploiement dans le guide du AWS Lambda développeur.

Migration de fonctions Lambda basées sur le cloud

Le SDK AWS IoT Greengrass principal suit le modèle de programmation du AWS SDK, qui facilite le portage des fonctions Lambda développées pour le cloud vers des fonctions Lambda exécutées sur un cœur. AWS IoT Greengrass

Par exemple, la fonction Lambda Python suivante utilise le AWS SDK for Python (Boto3) pour publier un message sur le sujet some/topic dans le cloud :

import boto3 iot_client = boto3.client("iot-data") response = iot_client.publish( topic="some/topic", qos=0, payload="Some payload".encode() )

Pour porter la fonction pour un AWS IoT Greengrass noyau, dans l'importinstruction et l'clientinitialisation, remplacez le nom du boto3 module pargreengrasssdk, comme indiqué dans l'exemple suivant :

import greengrasssdk iot_client = greengrasssdk.client("iot-data") iot_client.publish(topic="some/topic", qos=0, payload="Some payload".encode())
Note

Le kit de développement logiciel (SDK) AWS IoT Greengrass Core ne prend en charge que l'envoi des messages MQTT avec QoS = 0. Pour plus d’informations, consultez Message de qualité de service.

La similitude entre les modèles de programmation vous permet également de développer vos fonctions Lambda dans le cloud, puis de les migrer vers celles-ci AWS IoT Greengrass avec un minimum d'effort. Les exécutables Lambda ne s'exécutent pas dans le cloud. Vous ne pouvez donc pas utiliser le AWS SDK pour les développer dans le cloud avant le déploiement.

Référencer les fonctions Lambda par alias ou par version

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. Les alias sont convertis en numéros de version lors du déploiement en groupe. Lorsque vous utilisez des alias, la version résolue est mise à jour dans la version vers laquelle l'alias pointe au moment de déploiement.

AWS IoT Greengrassne prend pas en charge les alias Lambda pour les versions $LATEST. Les versions $LATEST ne sont pas liées à des versions de fonctions immuables publiées et peuvent être modifiées à tout moment, ce qui va à l'encontre du AWS IoT Greengrass principe d'immuabilité des versions.

Une pratique courante pour maintenir vos fonctions Greengrass Lambda à jour en cas de modification du code consiste à utiliser un alias nommé dans votre groupe Greengrass et dans PRODUCTION vos abonnements. Lorsque vous mettez en production de nouvelles versions de votre fonction Lambda, pointez l'alias vers la dernière version stable, puis redéployez le groupe. Vous pouvez également utiliser cette méthode pour restaurer une version précédente.

Flux de communication pour les fonctions Greengrass Lambda

Les fonctions Greengrass Lambda prennent en charge plusieurs méthodes de communication avec les autres membres du AWS IoT Greengrass groupe, les services locaux et les services cloud (y compris les services). AWS

Communication à l'aide de messages MQTT

Les fonctions Lambda peuvent envoyer et recevoir des messages MQTT en utilisant un modèle de publication et d'abonnement contrôlé par les abonnements.

Ce flux de communication permet aux fonctions Lambda d'échanger des messages avec les entités suivantes :

  • Appareils clients du groupe.

  • Connecteurs dans le groupe.

  • Autres fonctions Lambda du groupe.

  • AWS IoT.

  • Le service Device Shadow local.

Un abonnement définit la source d'un message, la cible d'un message et une rubrique (ou sujet) qui est utilisée pour acheminer des messages de la source vers la cible. Les messages publiés dans une fonction Lambda sont transmis au gestionnaire enregistré de la fonction. Les abonnements permettent une sécurité accrue et des interactions prévisibles. Pour plus d’informations, consultez Abonnements gérés dans le flux de travail de messagerie MQTT.

Note

Lorsque le noyau est hors ligne, les fonctions Greengrass Lambda peuvent échanger des messages avec des appareils clients, des connecteurs, d'autres fonctions et des ombres locales, mais les messages à destination sont mis en file d'attente. AWS IoT Pour plus d’informations, consultez File d'attente de messages MQTT pour les cibles cloud.

Autres flux de communication

  • Pour interagir avec les ressources locales des appareils et des volumes ainsi qu'avec les modèles d'apprentissage automatique sur un appareil principal, les fonctions Greengrass Lambda utilisent des interfaces de système d'exploitation spécifiques à la plate-forme. Par exemple, vous pouvez utiliser la méthode open dans le module os pour les fonctions Python. Pour qu'une fonction ait l'autorisation d'accéder à une ressource, elle doit être affiliée à la ressource et disposer de l'autorisation read-only ou read-write. Pour plus d'informations, notamment sur la disponibilité des versions AWS IoT Greengrass principales, consultez Accédez à des ressources locales avec des fonctions et des connecteurs Lambda etAccès aux ressources d'apprentissage automatique à partir du code de fonction Lambda.

    Note

    Si vous exécutez votre fonction Lambda sans conteneurisation, vous ne pouvez pas utiliser les ressources de périphérique et de volume locales connectées et vous devez accéder directement à ces ressources.

  • Les fonctions Lambda peuvent utiliser le Lambda client du SDK AWS IoT Greengrass principal pour appeler d'autres fonctions Lambda du groupe Greengrass.

  • Les fonctions Lambda peuvent utiliser le AWS SDK pour communiquer avec les services. AWS Pour plus d'informations, consultez la section AWSSDK.

  • Les fonctions Lambda peuvent utiliser des interfaces tierces pour communiquer avec des services cloud externes, comme les fonctions Lambda basées sur le cloud.

Note

Les fonctions Lambda de Greengrass ne peuvent pas communiquer avec d'autres services cloud AWS ou avec d'autres services lorsque le cœur est hors ligne.

Récupération de la rubrique (ou sujet) MQTT en entrée

AWS IoT Greengrassutilise des abonnements pour contrôler l'échange de messages MQTT entre les appareils clients, les fonctions Lambda et les connecteurs d'un groupe, ainsi qu'AWS IoTavec ou avec le service fantôme local. Les abonnements définissent la source d'un message, la cible d'un message ainsi qu'une rubrique MQTT utilisée pour acheminer les messages. Lorsque la cible est une fonction Lambda, le gestionnaire de la fonction est invoqué lorsque la source publie un message. Pour plus d’informations, consultez Communication à l'aide de messages MQTT.

L'exemple suivant montre comment une fonction Lambda peut obtenir le sujet d'entrée à partir du context sujet transmis au gestionnaire. Pour cela, la fonction accède à la clé subject à partir de la hiérarchie de contexte (context.client_context.custom['subject']). L'exemple convertit également le message JSON entrant, puis publie la rubrique et le message analysés.

Note

Dans l'API AWS IoT Greengrass, la rubrique d'un abonnement est représentée par la propriété subject.

import greengrasssdk import logging client = greengrasssdk.client('iot-data') OUTPUT_TOPIC = 'test/topic_results' def get_input_topic(context): try: topic = context.client_context.custom['subject'] except Exception as e: logging.error('Topic could not be parsed. ' + repr(e)) return topic def get_input_message(event): try: message = event['test-key'] except Exception as e: logging.error('Message could not be parsed. ' + repr(e)) return message def function_handler(event, context): try: input_topic = get_input_topic(context) input_message = get_input_message(event) response = 'Invoked on topic "%s" with message "%s"' % (input_topic, input_message) logging.info(response) except Exception as e: logging.error(e) client.publish(topic=OUTPUT_TOPIC, payload=response) return

Pour tester la fonction, ajoutez-la à votre groupe à l'aide des paramètres de configuration par défaut. Ajoutez ensuite les abonnements suivants et déployez le groupe. Pour obtenir des instructions, veuillez consulter Module 3 (partie 1) : Fonctions Lambda surAWS IoT Greengrass.

Source Cible Filtre de rubriques
Cloud IoT Cette fonction test/input_message
Cette fonction Cloud IoT test/topic_results

Une fois le déploiement terminé, appelez la fonction.

  1. Dans la AWS IoT console, ouvrez la page du client de test MQTT.

  2. Abonnez-vous au test/topic_results sujet en sélectionnant l'onglet S'abonner à un sujet.

  3. Publiez un message dans le test/input_message sujet en sélectionnant l'onglet Publier dans un sujet. Dans le cadre de cet exemple, vous devez inclure la propriété test-key dans le message JSON.

    { "test-key": "Some string value" }

    En cas de réussite, la fonction publie la rubrique en entrée et la chaîne de message dans la rubrique test/topic_results.

Configuration du cycle de vie pour les fonctions Greengrass Lambda

Le cycle de vie de la fonction Greengrass Lambda détermine le moment où une fonction démarre et la manière dont elle crée et utilise les conteneurs. Le cycle de vie détermine également comment les variables et la logique de prétraitement se trouvant à l'extérieur du gestionnaire de fonctions sont conservées.

AWS IoT Greengrass prend en charge les cycles de vie à la demande (par défaut) ou à longue durée de vie :

  • Les fonctions à la demande démarrent lorsqu'elles sont appelées et s'arrêtent lorsqu'il n'y a plus de tâche à exécuter. Un appel de la fonction crée un conteneur séparé (ou sandbox) pour traiter les appels, sauf si un conteneur existant peut être réutilisé. Les données qui sont envoyées à la fonction peuvent être extraites par n'importe quel conteneur.

    Plusieurs appels d'une fonction à la demande peuvent être exécutés en parallèle.

    Les variables et la logique de prétraitement définies à l'extérieur du gestionnaire de fonctions ne sont pas conservées quand de nouveaux conteneurs sont créés.

  • Les fonctions à longue durée de vie (ou épinglées) démarrent automatiquement lorsque le AWS IoT Greengrass noyau démarre et s'exécutent dans un seul conteneur. Toutes les données qui sont envoyées à la fonction sont extraites par le même conteneur.

    Les appels sont mis en file d'attente jusqu'à ce que les appels précédents soient exécutées.

    Les variables et la logique de prétraitement définies à l'extérieur du gestionnaire de fonctions sont conservées pour chaque appel du gestionnaire.

    Les fonctions Lambda à longue durée de vie sont utiles lorsque vous devez commencer à travailler sans aucune intervention initiale. Par exemple, une fonction à longue durée de vie peut se charger et commencer à traiter un modèle ML pour qu'il soit prêt lorsque la fonction commencera à recevoir des données des appareils.

    Note

    N'oubliez pas que les fonctions à longue durée de vie ont des délais d'attente associés aux appels de leur gestionnaire. Si vous souhaitez exécuter indéfiniment du code d'exécution, vous devez démarrer celui-ci à l'extérieur du gestionnaire. Assurez-vous qu'il n'y a pas de code de blocage à l'extérieur du gestionnaire qui peut empêcher la fonction de terminer son initialisation.

    Ces fonctions s'exécutent à moins que le cœur ne s'arrête (par exemple, lors d'un déploiement de groupe ou du redémarrage d'un appareil) ou que la fonction n'entre dans un état d'erreur (tel qu'un délai d'expiration du gestionnaire, une exception non détectée ou lorsqu'elle dépasse ses limites de mémoire).

Pour plus d'informations sur la réutilisation des conteneurs, consultez la section Comprendre la réutilisation des conteneurs AWS Lambda dans le blog AWS Compute.

Exécutables Lambda

Cette fonctionnalité est disponible pour AWS IoT Greengrass Core v1.6 et versions ultérieures.

Un exécutable Lambda est un type de fonction Greengrass Lambda que vous pouvez utiliser pour exécuter du code binaire dans l'environnement principal. Il vous permet d'exécuter des fonctionnalités spécifiques à l'appareil de manière native et de bénéficier de l'encombrement réduit du code compilé. Les exécutables Lambda peuvent être invoqués par des événements, invoquer d'autres fonctions et accéder aux ressources locales.

Les exécutables Lambda supportent uniquement le type d'encodage binaire (pas JSON), mais sinon vous pouvez les gérer dans votre groupe Greengrass et les déployer comme les autres fonctions Lambda de Greengrass. Cependant, le processus de création d'exécutables Lambda est différent de celui de création de fonctions Lambda Python, Java et Node.js :

  • Vous ne pouvez pas utiliser la AWS Lambda console pour créer (ou gérer) un exécutable Lambda. Vous pouvez créer un exécutable Lambda uniquement à l'aide de l'AWS LambdaAPI.

  • Vous téléchargez le code de fonction AWS Lambda sous forme d'exécutable compilé qui inclut le SDK AWS IoT Greengrass Core pour C.

  • Vous spécifiez le nom de l'exécutable en tant que gestionnaire de fonctions.

Les exécutables Lambda doivent implémenter certains appels et modèles de programmation dans leur code de fonction. Par exemple, la méthode main doit :

  • Appeler gg_global_init pour initialiser des variables globales internes Greengrass. Cette fonction doit être appelée avant la création des threads et avant l'appel à toute autre fonction du kit SDK AWS IoT Greengrass Core.

  • Appelez gg_runtime_start pour enregistrer le gestionnaire de fonctions auprès du moteur d'exécution Greengrass Lambda. Cette fonction doit être appelée lors de l'initialisation. L'appel à cette fonction entraîne l'utilisation du thread actuel par l'environnement d'exécution. Le paramètre facultatif GG_RT_OPT_ASYNC indique à cette fonction de ne pas se bloquer, mais de créer un nouveau thread pour l'environnement d'exécution. Cette fonction utilise un gestionnaire SIGTERM.

L'extrait de code suivant est la main méthode tirée de l'exemple de code simple_handler.c sur. GitHub

int main() { gg_error err = GGE_SUCCESS; err = gg_global_init(0); if(err) { gg_log(GG_LOG_ERROR, "gg_global_init failed %d", err); goto cleanup; } gg_runtime_start(handler, 0); cleanup: return -1; }

Pour plus d'informations sur les exigences, les contraintes et les autres détails de mise en œuvre, consultez le SDK AWS IoT Greengrass Core pour C.

Création d'un exécutable Lambda

Après avoir compilé votre code avec le SDK, utilisez l'AWS LambdaAPI pour créer une fonction Lambda et téléchargez votre exécutable compilé.

Note

Votre fonction doit être compilée avec un compilateur compatible avec C89.

L'exemple suivant utilise la commande create-function CLI pour créer un exécutable Lambda. La commande spécifie :

  • Le nom de l'exécutable pour le gestionnaire. Il doit s'agir du nom exact de votre exécutable compilé.

  • Le chemin d'accès au fichier .zip qui contient l'exécutable compilé.

  • arn:aws:greengrass:::runtime/function/executable pour l'environnement d'exécution. Il s'agit de l'environnement d'exécution de tous les exécutables Lambda.

Note

En effetrole, vous pouvez spécifier l'ARN de n'importe quel rôle d'exécution Lambda. AWS IoT Greengrassn'utilise pas ce rôle, mais le paramètre est obligatoire pour créer la fonction. Pour plus d'informations sur les rôles d'exécution Lambda, consultez le modèle AWS Lambda d'autorisations dans le Guide du AWS Lambdadéveloppeur.

aws lambda create-function \ --region aws-region \ --function-name function-name \ --handler executable-name \ --role role-arn \ --zip-file fileb://file-name.zip \ --runtime arn:aws:greengrass:::runtime/function/executable

Ensuite, utilisez l'API AWS Lambda pour publier une version et créer un alias.

  • Utilisez publish-version pour publier une version de fonction.

    aws lambda publish-version \ --function-name function-name \ --region aws-region
  • Utilisez create-alias pour créer un alias pointant vers la version que vous venez de publier. Nous vous recommandons de référencer les fonctions Lambda par alias lorsque vous les ajoutez à un groupe Greengrass.

    aws lambda create-alias \ --function-name function-name \ --name alias-name \ --function-version version-number \ --region aws-region
Note

La AWS Lambda console n'affiche pas les exécutables Lambda. Pour mettre à jour le code de fonction, vous devez utiliser l'API AWS Lambda.

Ajoutez ensuite l'exécutable Lambda à un groupe Greengrass, configurez-le pour accepter les données d'entrée binaires dans ses paramètres spécifiques au groupe, puis déployez le groupe. Vous pouvez effectuer cette opération dans la console AWS IoT Greengrass ou à l'aide de l'API AWS IoT Greengrass.