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.

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.

* 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

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())

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 :

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.

Autres flux de communication

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.

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.

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

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 :

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 :

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 :

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

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

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.

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.