AWS Greengrass - Guide de l'utilisateur · AWS Greengrass Guide de l'utilisateur Versions de AWS Greengrass Core • Répertoire en écriture configurable. Le logiciel Noyau AWS Greengrass

AWS GreengrassGuide de l'utilisateur

AWS Greengrass Guide de l'utilisateur

AWS Greengrass: Guide de l'utilisateurCopyright © 2018 Amazon Web Services, Inc. and/or its affiliates. All rights reserved.

Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any mannerthat is likely to cause confusion among customers, or in any manner that disparages or discredits Amazon. All other trademarks notowned by Amazon are the property of their respective owners, who may or may not be affiliated with, connected to, or sponsored byAmazon.


Table of ContentsPrésentation de AWS Greengrass ......................................................................................................... 1

Logiciel AWS Greengrass Core .................................................................................................... 2Versions de AWS Greengrass Core ...................................................................................... 2

Groupes AWS Greengrass ........................................................................................................... 4Appareils dans AWS Greengrass .................................................................................................. 5Kits SDK ................................................................................................................................... 6Exigences et plateformes prises en charge ................................................................................... 13Nous voulons entendre parler de vous ......................................................................................... 17AWS Greengrass Core ................................................................................................................ 2

Fichier de configuration AWS Greengrass Core ..................................................................... 18Répertoire en écriture ........................................................................................................ 24File d'attente de messages MQTT ....................................................................................... 27Lancement de Greengrass au démarrage système ................................................................. 30

Démarrez avec AWS Greengrass ........................................................................................................ 31Prérequis ................................................................................................................................. 31Créez un compte AWS. ............................................................................................................. 32Module 1 : Configuration de l'environnement pour Greengrass ......................................................... 32

Configuration d'une carte Raspberry Pi ................................................................................ 32Configuration d'une instance Amazon EC2 ........................................................................... 38Configuration d'autres appareils .......................................................................................... 41

Module 2 : Installation du logiciel Greengrass Core ........................................................................ 45Configuration d'AWS Greengrass sur AWS IoT ...................................................................... 45Démarrage d'AWS Greengrass sur l'appareil Core ................................................................. 50

Module 3 (Partie 1) : Fonctions Lambda sur AWS Greengrass ......................................................... 53Création et empaquetage d'une fonction Lambda ................................................................... 53Configuration de la fonction Lambda pour AWS Greengrass .................................................... 60Déploiement des configurations cloud sur un appareil Core ..................................................... 66Vérification de l'exécution de la fonction Lambda sur l'appareil ................................................. 68

Module 3 (Partie 2) : Fonctions Lambda sur AWS Greengrass ......................................................... 71Création et empaquetage de la fonction Lambda ................................................................... 71Configuration de fonctions Lambda longue durée pour AWS Greengrass ................................... 73Test des fonctions Lambda longue durée ............................................................................. 75Test des fonctions Lambda à la demande ............................................................................ 80

Module 4 : Interaction avec les appareils dans un groupe AWS Greengrass ....................................... 83Création d'appareils AWS IoT dans un groupe AWS Greengrass .............................................. 84Configuration des abonnements .......................................................................................... 88Installation du kit Kit SDK des appareils AWS IoT pour Python ................................................. 89Test des communications ................................................................................................... 94

Module 5 : Interaction avec les Device Shadows ............................................................................ 96Configuration des appareils et des abonnements ................................................................... 97Téléchargement des fichiers requis .................................................................................... 100Test des communications (synchronisation des appareils désactivée) ...................................... 101Test des communications (synchronisation des appareils activée) ........................................... 102

Module 6 : Accès à Services de cloud AWS ................................................................................ 103Configuration des rôles IAM .............................................................................................. 104Création et configuration de la fonction Lambda ................................................................... 108Configuration des abonnements ........................................................................................ 113Test des communications ................................................................................................. 116

Mises à jour OTA des principaux logiciels AWS Greengrass .................................................................. 119Agent OTA Greengrass ............................................................................................................ 120Intégration à des systèmes d'initialisation .................................................................................... 122

Mise à jour automatique OTA avec commande Respawn gérée .............................................. 123Mise à jour de AWS Greengrass Core avec commande Respawn gérée .................................. 123

Mise à jour automatique de l'agent OTA ..................................................................................... 124

iii


Mise à jour du logiciel Greengrass Core ..................................................................................... 124Réinitialiser les déploiements ............................................................................................................ 125Exécution de fonctions Lambda locales .............................................................................................. 127

Kits SDK ................................................................................................................................ 127Migration des fonctions Lambda basées sur le cloud ............................................................ 128

Alias et versions de fonction ..................................................................................................... 128Configuration spécifique au groupe ............................................................................................ 129Flux de communication ............................................................................................................ 130

Messages MQTT ............................................................................................................. 130Autres flux de communication ........................................................................................... 130

Configuration de cycle de vie .................................................................................................... 131Exécutables Lambda ............................................................................................................... 131

Création d'un exécutable Lambda ...................................................................................... 132Accès aux ressources locales avec les fonctions Lambda ..................................................................... 134

Types de ressource pris en charge ............................................................................................ 134Prérequis ............................................................................................................................... 135

Ressources de volume sous le répertoire /proc .................................................................... 135Autorisation d'accès fichier pour le propriétaire du groupe ............................................................. 136

Voir aussi ....................................................................................................................... 136Utilisation de l'interface de ligne de commande ............................................................................ 136

Création de ressources locales ......................................................................................... 136Création de la fonction Greengrass .................................................................................... 138Ajout de la fonction Lambda au groupe .............................................................................. 139Dépannage ..................................................................................................................... 140

Utilisation de la console ........................................................................................................... 141Prérequis ....................................................................................................................... 141Création du package de déploiement d'une fonction Lambda ................................................. 142Création et publication d'une fonction Lambda ..................................................................... 144Ajout de la fonction Lambda au groupe .............................................................................. 148Ajout d'une ressource locale au groupe .............................................................................. 151Ajout d'abonnements au groupe Greengrass ....................................................................... 152Déploiement du groupe .................................................................................................... 154Test de l'accès aux ressources locales ............................................................................... 156

Exécuter l'inférence de Machine Learning ........................................................................................... 159Fonctionnement de l'inférence de Machine Learning AWS Greengrass ............................................ 159Ressources de Machine Learning .............................................................................................. 160

Sources de modèles prises en charge ................................................................................ 160Prérequis ............................................................................................................................... 162Bibliothèques précompilées pour les infrastructures de Machine Learning ......................................... 162

Gestion des versions MXNet ............................................................................................. 162Limitations d'utilisation des modèles TensorFlow sur Raspberry Pi .......................................... 163

Comment configurer Amazon SageMaker pour utiliser MXNet v0.11 ................................................ 163Configuration de l'inférence Machine Learning ............................................................................. 164

Prérequis ....................................................................................................................... 165Configuration du Raspberry Pi ........................................................................................... 165Installation de l'infrastructure MXNet .................................................................................. 166Création d'un package de modèle ...................................................................................... 168Création et publication d'une fonction Lambda ..................................................................... 168Ajout de la fonction Lambda au groupe .............................................................................. 173Ajout de ressources au groupe ......................................................................................... 175Ajout d'un abonnement au groupe ..................................................................................... 178Déploiement du groupe .................................................................................................... 180Vérification de l'application ................................................................................................ 181Étapes suivantes ............................................................................................................. 185Configuration d'un NVIDIA Jetson TX2 ............................................................................... 185

API RESTful de découverte de Greengrass ......................................................................................... 186Requête ................................................................................................................................. 186

iv


Réponse ................................................................................................................................ 186Autorisation ............................................................................................................................ 187Exemple de documents de réponse à une découverte .................................................................. 187

Greengrass OPC-UA ........................................................................................................................ 189Présentation de l'architecture .................................................................................................... 189Configurer un serveur OPC-UA de test ....................................................................................... 190Vérifier que le groupe Greengrass est prêt .................................................................................. 191Utiliser Greengrass OPC-UA pour interagir avec un serveur OPC-UA .............................................. 191Vérifier que la fonction Lambda reçoit des publications OPC-UA et les publie sur Greengrass .............. 193Étapes suivantes ..................................................................................................................... 194

Sécurité AWS Greengrass ................................................................................................................ 195Configuration de la sécurité Greengrass ..................................................................................... 196Flux de connexion des appareils ............................................................................................... 196Flux des messages Greengrass ................................................................................................ 197Rotation du certificat du serveur noyau MQTT ............................................................................. 197Suites de chiffrement AWS Greengrass ...................................................................................... 197

Surveillance .................................................................................................................................... 199CloudWatch Logs .................................................................................................................... 199Journaux du système de fichiers ............................................................................................... 199Configuration de journalisation par défaut ................................................................................... 200Configurer la journalisation pour AWS Greengrass ....................................................................... 200

Configurer la journalisation (console) .................................................................................. 201Configurer la journalisation (API) ....................................................................................... 201Exemple de configuration ................................................................................................. 202

Limites de journalisation ........................................................................................................... 203Transactions par seconde ................................................................................................ 203Mémoire ........................................................................................................................ 203Décalage d'horloge .......................................................................................................... 203Utilisation du disque ........................................................................................................ 203Perte de journaux ........................................................................................................... 204

Résolution des problèmes des applications AWS Greengrass ................................................................ 205............................................................................................................................................ 205

Résolution des problèmes avec les journaux ............................................................................... 208Résolution des problèmes de stockage ....................................................................................... 212Messages de résolution des problèmes ...................................................................................... 212Dépannage des problèmes de temporisation de la synchronisation shadow ...................................... 212

Historique du document ................................................................................................................... 216Mises à jour antérieures ........................................................................................................... 216

v


Présentation de AWS GreengrassAWS Greengrass est un logiciel qui étend les capacités de cloud AWS aux appareils locaux, leurdonnant ainsi la possibilité de collecter et d'analyser des données plus près de la source d'information,et de communiquer entre eux de manière sécurisée sur les réseaux locaux. Plus spécifiquement, lesdéveloppeurs qui utilisent AWS Greengrass peuvent créer du code sans serveur (fonctions AWS Lambda)dans le cloud et le déployer facilement sur des appareils pour exécuter localement des applications.

Le schéma suivant illustre l'architecture de base de AWS Greengrass.

AWS Greengrass permet aux clients d'utiliser les fonctions Lambda pour construire des appareils IoT et lalogique d'application. En particulier, AWS Greengrass permet de gérer dans le cloud des applications quipeuvent être déployées en vue de leur exécution locale. Les fonctions Lambda déployées localement sontdéclenchées par des événements locaux, par des messages depuis le cloud ou par d'autres sources.

Dans AWS Greengrass, les appareils communiquent en toute sécurité sur un réseau local et échangentdes messages sans avoir à se connecter au cloud. AWS Greengrass fournit un gestionnaire de messagespub/sub local qui peut mettre les messages en mémoire tampon de façon intelligente en cas de perte deconnexion. Les messages entrants et sortants échangés avec le cloud sont ainsi préservés.

AWS Greengrass protège les données utilisateur :

• par le biais de l'authentification sécurisée et de l'autorisation des appareils ;• grâce à la connectivité sécurisée dans le réseau local ;• entre les appareils locaux et le cloud.

Les informations d'identification de sécurité d'un appareil fonctionnent dans un groupe jusqu'à leurrévocation et ce, même si la connectivité au cloud est interrompue, afin que les appareils puissentcontinuer à communiquer de manière sécurisée en local.

AWS Greengrass fournit des mises à jour logicielles terrestres sécurisées des fonctions Lambda.

AWS Greengrass comprend :

• Des distributions logicielles• Le logiciel Noyau AWS Greengrass• Le kit SDK Noyau AWS Greengrass

1

AWS Greengrass Guide de l'utilisateurLogiciel AWS Greengrass Core

• Le services cloud• L'API AWS Greengrass

• Fonctions• Le fichier d'exécution Lambda• Implémentation des shadows• Le gestionnaire de messages• La gestion des groupes• Le service de découverte• Agent de mise à jour OTA• Accès aux ressources locales• Inférence de Machine Learning

Logiciel AWS Greengrass CoreLe logiciel Noyau AWS Greengrass fournit les fonctionnalités suivantes :

• Autorise le déploiement et l'exécution des applications locales créées à l'aide des fonctions Lambda etgérées par le biais de l'API de déploiement.

• Permet l'utilisation de la messagerie locale entre les appareils sur un réseau sécurisé à l'aide d'unschéma d'abonnement géré par le protocole MQTT.

• Garantit des connexions sécurisées entre les appareils et le cloud à l'aide de l'authentification et del'autorisation des appareils.

• Fournit des mises à jour logicielles terrestres sécurisées des fonctions Lambda définies par l'utilisateur.

Le logiciel Noyau AWS Greengrass comprend :

Les instances d'Noyau AWS Greengrass sont configurées par les API AWS Greengrass qui créent etmettent à jour les définitions de groupe AWS Greengrass stockées dans le cloud.

Versions de AWS Greengrass CoreLes onglets suivants décrivent les nouveautés et les modifications dans les versions du logiciel Noyau AWSGreengrass.

GGC v1.6.0

Version actuelle.

Nouvelles fonctions:

• exécutant du code binaire sur le noyau Greengrass. Utilisez le nouveau pour écrire des en C et C++.Pour plus d'informations, consultez the section called “Exécutables Lambda” (p. 131).

• Mise en cache des messages de stockage local (facultative) qui peuvent être conservés lors desredémarrages. Vous pouvez configurer les paramètres de stockage pour les messages MQTT misen file d'attente pour traitement. Pour plus d'informations, consultez the section called “File d'attentede messages MQTT” (p. 27).

• Intervalle maximal de tentative de reconnexion configurable lorsque l'appareildu noyau est déconnecté. Pour plus d'informations, consultez la propriétémqttMaxConnectionRetryInterval dans the section called “Fichier de configuration AWSGreengrass Core” (p. 18).

• Accès aux ressources locales du répertoire /proc de l'hôte. Pour plus d'informations, consultez Accèsaux ressources locales avec les fonctions Lambda (p. 134).

2

AWS Greengrass Guide de l'utilisateurVersions de AWS Greengrass Core

• Répertoire en écriture configurable. Le logiciel Noyau AWS Greengrass peut être déployé sur desemplacements en lecture seule et en lecture-écriture. Pour plus d'informations, consultez the sectioncalled “Répertoire en écriture” (p. 24).

Correctifs de bogues et améliorations :

• Amélioration des performances pour la publication de messages dans le noyau Greengrass, et entreles appareils et le noyau.

• Réduisez les ressources de calcul requises pour traiter les journaux générés par des fonctionsLambda définies par l'utilisateur.

GGC v1.5.0


• L'inférence de Machine Learning AWS Greengrass est généralement disponible. Vous pouvezexécuter l'inférence de Machine Learning localement sur des appareils AWS Greengrass à l'aide demodèles créés et formés dans le cloud. Pour plus d'informations, consultez Exécuter l'inférence deMachine Learning (p. 159).

• Les fonctions Lambda Greengrass prennent désormais en charge les données binaires commecharge utile d'entrée, en plus de JSON. Pour utiliser cette fonctionnalité, vous devez effectuer unemise à niveau vers la version 1.1.0 du kit SDK AWS Greengrass Core, que vous pouvez téléchargerà partir de la page Logiciel de la console AWS IoT.

Correctifs de bogues et améliorations :

• Réduction de l'empreinte mémoire globale.• Amélioration des performances lors de l'envoi de messages dans le cloud.• Amélioration des performances et de la stabilité de l'agent de téléchargement, du gestionnaire de

certificats de l'appareilet de l'agent de mise à jour OTA.• Correctifs de bogues mineurs.

GGC v1.3.0


• Agent de mise à jour OTA capable de gérer les tâches de mise à jour Greengrass déployées dans lecloud. L'agent se trouve dans le nouveau répertoire /greengrass/ota. Pour plus d'informations,consultez Mises à jour OTA des principaux logiciels AWS Greengrass (p. 119).

• La fonction d'accès aux ressources locales permet aux fonctions Lambda Greengrass d'accéder auxressources locales, telles que des périphériques et des volumes. Pour plus d'informations, consultezAccès aux ressources locales avec les fonctions Lambda (p. 134).

GGC v1.1.0


• Les groupes AWS Greengrass déployés peuvent être réinitialisés en supprimant les fonctionsLambda, les abonnements et les configurations. Pour plus d'informations, consultez Réinitialiser lesdéploiements (p. 125).

• Prise en charge des environnements d'exécution Node.js 6.10 et Lambda Java 8, en plus dePython 2.7.

3

AWS Greengrass Guide de l'utilisateurGroupes AWS Greengrass

Pour migrer depuis la version précédente d'Noyau AWS Greengrass :

• Copiez les certificats du dossier /greengrass/configuration/certs dans /greengrass/certs.

• Copiez /greengrass/configuration/config.json dans /greengrass/config/config.json.

• Exécutez /greengrass/ggc/core/greengrassd au lieu de /greengrass/greengrassd.• Déployez le groupe sur le nouveau noyau.

GGC v1.0.0

Première version.

Groupes AWS GreengrassUne définition de groupe AWS Greengrass est un ensemble de paramètres destinés aux appareils NoyauAWS Greengrass et aux appareils qui communiquent avec eux. Le schéma suivant montre les objets quiconstituent un Groupe AWS Greengrass.

Dans le schéma précédent :

A : Définition de groupe AWS Greengrass

Ensemble d'informations sur le Groupe AWS Greengrass.B : Paramètres du groupe AWS Greengrass

parmi lesquelles :• Rôle du Groupe AWS Greengrass• Configuration des journaux

4

AWS Greengrass Guide de l'utilisateurAppareils dans AWS Greengrass

• Autorité de certification (CA) et configuration de la connexion locale• Informations de connectivité Noyau AWS Greengrass

C : Noyau AWS Greengrass

Objet AWS IoT que représente le Noyau AWS GreengrassD : définition de la fonction Lambda

Liste des fonctions Lambda à déployer sur le Noyau AWS Greengrass du groupe, avec les donnéesde configuration associées. Pour plus d'informations, consultez Exécution de fonctions Lambdalocales (p. 127).

E : Définition de l'abonnement

Liste des abonnements qui permettent de communiquer à l'aide des messages MQTT. Un abonnementdéfinit :• Une source de message. Il peut s'agir d'un thing AWS IoT (appareil), d'une fonction Lambda, d'AWS

IoT ou du service shadow AWS Greengrass local.• Un objet, constitué par une rubrique MQTT ou un filtre de rubrique utilisé pour filtrer les données des

messages• Une cible de message, qui identifie la destination des messages publiés par la source du message.

Il peut s'agir d'un thing AWS IoT (appareil), d'une fonction Lambda, d'AWS IoT ou du service shadowAWS Greengrass local.

Pour plus d'informations, consultez the section called “Flux des messages Greengrass” (p. 197).F : Définition de l'appareil

Une liste contenant un Noyau AWS Greengrass et des things AWS IoT qui sont membres du GroupeAWS Greengrass avec les données de configuration associées. Ces données spécifient quelsappareils sont des cœurs AWS Greengrass et lesquels doivent synchroniser les données shadow avecAWS IoT.

G : Définition des ressources

Liste des ressources locales et des ressources d'apprentissage automatique sur le Noyau AWSGreengrass, avec les données de configuration associées. Pour plus d'informations, consultez Accèsaux ressources locales avec les fonctions Lambda (p. 134) et Exécuter l'inférence de MachineLearning (p. 159).

Après leur déploiement, la définition Groupe AWS Greengrass, les fonctions Lambda, les ressources et letableau d'abonnement sont copiés sur un appareil Noyau AWS Greengrass.

Appareils dans AWS GreengrassIl existe deux types d'appareils :

• Cœurs AWS Greengrass.• Les appareils AWS IoT connectés à un Noyau AWS Greengrass

Un Noyau AWS Greengrass est un appareil AWS IoT qui exécute un logiciel AWS Greengrass spécialisécommuniquant directement avec les services cloud AWS IoT et AWS Greengrass. Il s'agit d'un appareilAWS IoT possédant son propre certificat d'authentification auprès d'AWS IoT. Il possède un shadowd'appareil et existe dans le registre des appareils AWS IoT. Les cœurs AWS Greengrass exécutent unfichier d'exécution Lambda local, un agent de déploiement et un module de suivi des adresses IP quienvoie des informations d'adresse IP au service cloud AWS Greengrass pour autoriser les appareils AWSIoT à découvrir automatiquement leur groupe et les informations de connexion du noyau.

5

AWS Greengrass Guide de l'utilisateurKits SDK

N'importe quel appareil AWS IoT peut se connecter à un appareil Noyau AWS Greengrass. Ces dispositifsexécutent un logiciel écrit avec le kit de développement logiciel (SDK) de l'appareil AWS IoT.

Le tableau suivant montre comment ces types d'appareils sont associés.

L'appareil Noyau AWS Greengrass stocke les certificats dans deux emplacements :

• Certificat de l'appareil principal dans /greengrass/certs - Le certificat de l'appareil principal est nomméhash.cert.pem (par exemple, 86c84488a5.cert.pem). Ce certificat est utilisé pour authentifierl'appareil principal lors de la connexion aux services AWS IoT et AWS Greengrass.

• Certificat du serveur principal MQTT dans /greengrass/ggc/var/state/server - Le certificat du serveurprincipal MQTT est nommé server.crt. Ce certificat est utilisé pour l'authentification mutuelle entre leservice MQTT local (sur l'appareil Greengrass principal) et les appareils Greengrass avant l'échange demessages.

Kits SDKLes kits SDK suivants sont utilisés lors de l'utilisation de AWS Greengrass :

GGC 1.6.0

Kits de développement logiciel (SDK) AWS

En utilisant les kits de développement logiciel (SDK) AWS, vous pouvez concevoir desapplications qui fonctionnent avec n'importe quel service AWS, parmi lesquels Amazon S3,Amazon DynamoDB, AWS IoT, AWS Greengrass. Dans le contexte de AWS Greengrass, vous

6


pouvez utiliser le kit de développement logiciel (SDK) AWS dans les fonctions Lambda déployéespour envoyer directement des appels à n'importe quel service AWS. Pour plus d'informations,consultez the section called “Kits SDK” (p. 127).

SDKs pour les appareils AWS IoT

Les kits de développement logiciel (SDK) des appareils AWS IoT facilitent la connexion desappareils aux services AWS IoT ou AWS Greengrass. Les appareils doivent connaître le GroupeAWS Greengrass auquel ils appartiennent et l'adresse IP du Noyau AWS Greengrass auquel ilsdoivent se connecter.

Bien que vous puissiez utiliser n'importe quel kit de développement logiciel (SDK) d'un appareilAWS IoT pour vous connecter à un Noyau AWS Greengrass, seuls les kits SDK C++ et Pythonfournissent des fonctionnalités propres à AWS Greengrass, telles que l'accès au service dedécouverte de AWS Greengrass et aux téléchargements de l'autorité de certification racine NoyauAWS Greengrass. Pour plus d'informations, consultez Kits SDK pour les appareils AWS IoT.

Kits SDK AWS Greengrass Core

Le kit SDK AWS Greengrass Core permet aux fonctions Lambda d'interagir avec Noyau AWSGreengrass sur lequel elles s'exécutent afin de publier des messages, d'interagir avec le servicelocal Device Shadow ou d'appeler d'autres fonctions Lambda déployées. Ce kit SDK est utiliséexclusivement pour écrire des fonctions Lambda s'exécutant dans la version d'exécution Lambdasur un Noyau AWS Greengrass. Pour plus d'informations, consultez the section called “KitsSDK” (p. 127).

GGC v1.5.0


En utilisant les kits de développement logiciel (SDK) AWS, vous pouvez concevoir desapplications qui fonctionnent avec n'importe quel service AWS, parmi lesquels Amazon S3,Amazon DynamoDB, AWS IoT, AWS Greengrass. Dans le contexte de AWS Greengrass, vouspouvez utiliser le kit de développement logiciel (SDK) AWS dans les fonctions Lambda déployéespour envoyer directement des appels à n'importe quel service AWS.





Le kit SDK AWS Greengrass Core permet aux fonctions Lambda d'interagir avec Noyau AWSGreengrass sur lequel elles s'exécutent afin de publier des messages, d'interagir avec leservice local Device Shadow ou d'appeler d'autres fonctions Lambda déployées. Ce kit SDK estutilisé exclusivement pour écrire des fonctions Lambda s'exécutant dans la version d'exécutionLambda sur un Noyau AWS Greengrass. Les fonctions Lambda s'exécutant sur un NoyauAWS Greengrass peuvent interagir directement avec les services cloud AWS à l'aide du kit dedéveloppement logiciel (SDK) AWS. Les kits SDK AWS Greengrass Core et AWS sont descontenus dans différents packages. Vous pouvez donc utiliser les deux packages simultanément.Vous pouvez télécharger le kit SDK du AWS Greengrass Core à partir de la page Logiciel de laconsole AWS IoT.

7

https://aws.amazon.com/iot/sdk/


https://console.aws.amazon.com/iot/home


Le kit SDK du AWS Greengrass Core suit le modèle de programmation du kit SDK AWS. Il vouspermet de porter facilement les fonctions Lambda développées pour le cloud vers les fonctionsLambda qui s'exécutent sur un Noyau AWS Greengrass. Par exemple, à l'aide du kit SDK AWS, lafonction Lambda suivante publie un message sur la rubrique "/some/topic" dans le cloud :

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

Pour porter cette fonction Lambda en vue de son exécution sur un Noyau AWS Greengrass,remplacez l'instruction import boto3 par import greengrasssdk, comme indiqué dansl'extrait ci-dessous :

Note

Le kit de développement logiciel (SDK) AWS Greengrass Core ne prend en charge quel'envoi des messages MQTT avec QoS = 0.

import greengrasssdk client = greengrasssdk.client('iot-data')response = client.publish( topic='/some/topic', qos=0, payload='some payload'.encode())

Cela vous permet de tester vos fonctions Lambda dans le cloud et de les migrer vers AWSGreengrass avec un minimum d'efforts.

Note

Le kit SDK AWS est intégré en natif à l'environnement lors de l'exécution d'une fonctionLambda dans le cloud AWS. Si vous souhaitez utiliser boto3 dans une fonction Lambdadéployée sur un Noyau AWS Greengrass, veillez à inclure le kit de développement logiciel(SDK) AWS dans votre package. De plus, si vous choisissez d'utiliser les kits SDK AWSGreengrass Core et AWS simultanément dans le même package, vos fonctions Lambdadoivent utiliser l'espace de noms approprié. Pour plus d'informations sur la création de votrepackage de déploiement, consultez :

• AWS Lambda Création d'un package de déploiement (Python)• AWS Lambda Création d'un package de déploiement (NodeJS)• AWS Lambda Création d'un package de déploiement (Java)

GGC v1.3.0



8

http://docs.aws.amazon.com/lambda/latest/dg/lambda-python-how-to-create-deployment-package.html

http://docs.aws.amazon.com/lambda/latest/dg/nodejs-create-deployment-pkg.html

http://docs.aws.amazon.com/lambda/latest/dg/lambda-java-how-to-create-deployment-package.html










Note




9




Note



GGC v1.1.0









import boto3 client = boto3.client('iot-data')

10







response = client.publish( topic = "/some/topic", qos = 0, payload = "Some payload".encode())


Note




Note



GGC v1.0.0





11











Note




Note

Le kit SDK AWS est intégré en natif à l'environnement lors de l'exécution d'une fonctionLambda dans le cloud AWS. Si vous souhaitez utiliser boto3 dans une fonction Lambdadéployée sur un Noyau AWS Greengrass, veillez à inclure le kit de développement logiciel

12



AWS Greengrass Guide de l'utilisateurExigences et plateformes prises en charge

(SDK) AWS dans votre package. De plus, si vous choisissez d'utiliser les kits SDK AWSGreengrass Core et AWS simultanément dans le même package, vos fonctions Lambdadoivent utiliser l'espace de noms approprié. Pour plus d'informations sur la création de votrepackage de déploiement, consultez :

• AWS Lambda Création d'un package de déploiement (Python)

Exigences et plateformes prises en chargeLe logiciel Noyau AWS Greengrass est pris en charge sur les plates-formes répertoriées ici, et implique peude dépendances.

GGC v1.6.0

• Plateformes prises en charge:• Architecture : ARMv7l ; Système d'exploitation : Linux ; Distribution : Raspbian Jessie, 2017-03-02• Architecture : x86_64 ; Système d'exploitation : Linux ; Distribution : Amazon Linux (amzn-ami-

hvm-2016.09.1.20170119-x86_64-ebs)• Architecture : x86_64 ; Système d'exploitation : Linux ; Distribution : Ubuntu 14.04 – 16.04• Architecture : ARMv8 (AArch64) ; Système d'exploitation : Linux ; Distribution : Ubuntu 14.04 -

16.04 (Annapurna Alpine V2)• Configuration minimale requise :

• 128 Mo de mémoire RAM alloués à l'appareil Noyau AWS Greengrass.• Noyau Linux version 4.4 ou supérieure : bien que plusieurs versions puissent fonctionner avec

AWS Greengrass, il est recommandé d'utiliser la version 4.4 ou supérieure pour bénéficier d'unesécurité et de performances optimales.

• Bibliothèque Glibc version 2.14 ou supérieure.• Le répertoire /var/run doit être présent sur l'appareil.• AWS Greengrass nécessite que les protections hardlink/softlink soient activées sur l'appareil.

Sinon, AWS Greengrass ne peut s'exécuter qu'en mode non sécurisé, à l'aide de l'indicateur -i.• L'utilisateur ggc_user et le groupe ggc_group doivent être présents sur l'appareil.• Les configurations suivantes du noyau Linux doivent être activées sur l'appareil :

• Espace de noms : CONFIG_IPC_NS, CONFIG_UTS_NS, CONFIG_USER_NS,CONFIG_PID_NS

• CGroups : CONFIG_CGROUP_DEVICE, CONFIG_CGROUPS, CONFIG_MEMCG• Autres : CONFIG_POSIX_MQUEUE, CONFIG_OVERLAY_FS,

CONFIG_HAVE_ARCH_SECCOMP_FILTER, CONFIG_SECCOMP_FILTER, CONFIG_KEYS,CONFIG_SECCOMP

• /dev/stdin, /dev/stdout et /dev/stderr doivent être activés.• Le noyau Linux doit prendre en charge cgroups.• Le groupe mémoire cgroup doit être activé et monté pour autoriser AWS Greengrass à définir la

limite mémoire pour les fonctions Lambda.• Le certificat racine pour Amazon S3 et AWS IoT doit être présent dans le magasin d'approbation

du système.• Les éléments suivants sont facultatifs :

• Les appareils cgroup doivent être activés et montés si des fonctions Lambda avec LRA (LocalResource Access, Accès aux ressources locales) (p. 134) sont utilisées pour ouvrir des fichierssur l'appareil Noyau AWS Greengrass.

• Python version 2.7 est requis si des fonctions Lambda Python sont utilisées. Si tel est le cas,assurez-vous qu'il est ajouté à votre variable d'environnement PATH.

13


https://downloads.raspberrypi.org/raspbian/images/raspbian-2017-03-03/

https://www.gnu.org/software/libc/

https://en.wikipedia.org/wiki/Cgroups

https://www.python.org/


• NodeJS version 6.10 ou version supérieure est requis si des fonctions Lambda Node.JS sontutilisées. Si tel est le cas, assurez-vous qu'il est ajouté à votre variable d'environnement PATH.

• Java version 8 ou version supérieure est requis si des fonctions Lambda Java sont utilisées. Si telest le cas, assurez-vous qu'il est ajouté à votre variable d'environnement PATH.

• OpenSSL 1.01 ou version supérieure est requis pour Agent OTA Greengrass (p. 120) ainsi queles commandes suivantes : wget, realpath, tar, readlink, basename, dirname, pidof, df,grep et umount.

GGC v1.5.0




• 128 Mo de mémoire RAM alloués à l'appareil Noyau AWS Greengrass.• Noyau Linux version 4.4 ou supérieure : bien que plusieurs versions puissent fonctionner avec

AWS Greengrass, il est recommandé d'utiliser la version 4.4 ou supérieure pour bénéficier d'unesécurité et de performances optimales.

• Bibliothèque Glibc version 2.14 ou supérieure.• Le répertoire /var/run doit être présent sur l'appareil.• AWS Greengrass nécessite que les protections hardlink/softlink soient activées sur l'appareil.










• NodeJS version 6.10 ou version supérieure est requis si des fonctions Lambda Node.JS sontutilisées. Si tel est le cas, assurez-vous qu'il est ajouté à votre variable d'environnement PATH.

• Java version 8 ou version supérieure est requis si des fonctions Lambda Java sont utilisées. Si telest le cas, assurez-vous qu'il est ajouté à votre variable d'environnement PATH.

14

https://www.nodejs.org/

http://www.oracle.com/technetwork/java/javase/downloads/jre8-downloads-2133155.html

https://www.openssl.org/








• OpenSSL 1.01 ou version supérieure est requis pour Agent OTA Greengrass (p. 120) ainsi queles commandes suivantes : wget, realpath, tar, readlink, basename, dirname, pidof, df,grep et umount.

GGC v1.3.0




• 128 Mo de mémoire RAM alloués à l'appareil Noyau AWS Greengrass.• Noyau Linux 4.4 ou version ultérieure. Bien que plusieurs versions puissent fonctionner avec AWS

Greengrass, pour une sécurité et des performances optimales, nous vous recommandons d'utiliserla version 4.4 ou ultérieure.

• Bibliothèque Glibc 2.14 ou version ultérieure.• Le répertoire /var/run doit être présent sur l'appareil.• AWS Greengrass nécessite que les protections hardlink/softlink soient activées sur l'appareil.





• Le package sqlite3 est requis pour les device shadows AWS IoT. Assurez-vous qu'il est ajoutéà votre variable d'environnement PATH.






• Node.js 6.10 ou version ultérieure est requis si des fonctions Lambda Node.js sont utilisées. Si telest le cas, assurez-vous qu'il est ajouté à votre variable d'environnement PATH.

• Java 8 ou version ultérieure est requis si des fonctions Lambda Java sont utilisées. Si tel est lecas, assurez-vous qu'il est ajouté à votre variable d'environnement PATH.

15




https://www.sqlite.org/






• OpenSSL 1.01 ou version ultérieure est requis pour Agent OTA Greengrass (p. 120) ainsi queles commandes suivantes : wget, realpath, tar, readlink, basename, dirname, pidof, df,grep et umount.

GGC v1.1.0
















• Node.js 6.10 ou version ultérieure est requis si des fonctions Lambda Node.js sont utilisées. Si telest le cas, assurez-vous qu'il est ajouté à votre variable d'environnement PATH.

• Java 8 ou version ultérieure est requis si des fonctions Lambda Java sont utilisées. Si tel est lecas, assurez-vous qu'il est ajouté à votre variable d'environnement PATH.

GGC v1.0.0

• Plateformes prises en charge:16









AWS Greengrass Guide de l'utilisateurNous voulons entendre parler de vous

• Architecture : ARMv7l ; Système d'exploitation : Linux ; Distribution : Raspbian Jessie, 2017-03-02• Architecture : x86_64 ; Système d'exploitation : Linux ; Distribution : Amazon Linux (amzn-ami-















Nous voulons entendre parler de vousNous apprécions vos commentaires. Pour nous contacter, consultez le forum AWS Greengrass.

Configuration de AWS Greengrass CoreUn Noyau AWS Greengrass est un thing AWS IoT. Comme les autres appareils AWS IoT, un noyau existedans le registre, possède un shadow d'appareil et utilise un certificat d'appareil pour s'authentifier auprèsd'AWS IoT. L'appareil principal exécute le logiciel Noyau AWS Greengrass, ce qui lui permet de gérer lesprocessus locaux pour les groupes Greengrass, tels que la communication, la synchronisation de shadowset l'échange de jetons.

Le logiciel Noyau AWS Greengrass comprend :

17






https://forums.aws.amazon.com/forum.jspa?forumID=254

AWS Greengrass Guide de l'utilisateurFichier de configuration AWS Greengrass Core

Note

Fichier de configuration AWS Greengrass CoreLe fichier de configuration pour le logiciel Noyau AWS Greengrass est le fichier config.json, qui setrouve dans le répertoire /greengrass-root/config. Vous pouvez vérifier le contenu de ce fichier enexécutant la commande suivante :

cat /greengrass-root/config/config.json

Note

Dans AWS Greengrass Core v1.0.0, config.json est déployé sur /greengrass-root/configuration.

Voici un exemple de fichier config.json.

GGC v1.6.0

{ "coreThing": { "caPath": "root-ca-pem", "certPath": "cloud-pem-crt", "keyPath": "cloud-pem-key", "thingArn": "thing-arn", "iotHost": "host-prefix.iot.aws-region.amazonaws.com", "ggHost": "greengrass.iot.aws-region.amazonaws.com", "keepAlive": 600, "mqttMaxConnectionRetryInterval": 60 }, "runtime": { "cgroup": { "useSystemd": "yes" } }, "managedRespawn": true, "writeDirectory": "/write-directory"}

Note

Si vous utilisez l'option Easy group creation (Création facile de groupe) à partir de la ConsoleAWS Greengrass, le fichier config.json est déployé sur l'appareil principal dans un état defonctionnement qui spécifie la configuration par défaut.

Le fichier config.json prend en charge les propriétés suivantes :

Champ Description Remarques

caPath Le chemin d'accès au certificatd'authentification racineAWS IoT relatif au répertoire/greengrass-root/certs.

Enregistrez le fichier sous/greengrass-root/certs.

certPath Le chemin d'accès au certificatNoyau AWS Greengrass relatifau répertoire /greengrass-root/certs.


18

http://www.symantec.com/content/en/us/enterprise/verisign/roots/VeriSign-Class%203-Public-Primary-Certification-Authority-G5.pem





keyPath Le chemin d'accès à laclé privée Noyau AWSGreengrass relatif au répertoire/greengrass/certs.


thingArn L'ARN (Amazon ResourceName) du thing AWS IoT quireprésente l'appareil NoyauAWS Greengrass.

Retrouvez cette informationpour votre noyau dans laConsole AWS Greengrasssous Noyaux, ou en exécutantla commande de l'interfacede ligne de commande awsgreengrass list-core-definitions.

iotHost Votre point de terminaison AWSIoT

Retrouvez cette informationdans la Console IoT AWSsous Settings (Paramètres),ou en exécutant la commandede l'interface de ligne decommande aws iotdescribe-endpoint.

ggHost Votre point de terminaison AWSGreengrass.

Cette valeur utilise le formatgreengrass.iot.region.amazonaws.com.Utilisez la même région queiotHost.

keepAlive Période KeepAlive MQTT, ensecondes

Cette valeur est facultative. Lavaleur par défaut est 600.

mqttMaxConnectionRetryIntervalL'intervalle maximal (ensecondes) entre les tentativesde connexion MQTT si laconnexion est abandonnée.

Spécifiez cette valeur en tantqu'entier non signé. Cettevaleur est facultative. La valeurpar défaut est 60.

useSystemd Indique si votre appareil utilisesystemd.

Les valeurs valides sont yesou no. Exécutez le scriptcheck_ggc_dependenciesdans Module 1 (p. 32) pourvoir si votre appareil utilisesystemd.

managedRespawn Fonctionnalité de mises à jourOTA facultative, elle indiqueque l'agent OTA doit exécuterun code personnalisé avant unemise à jour.

Les valeurs valides sonttrue ou false. Pour plusd'informations, consultezMises à jour OTA desprincipaux logiciels AWSGreengrass (p. 119).

writeDirectory Le répertoire en écriture danslequel AWS Greengrass créetoutes les ressources enlecture-écriture.

Cette valeur est facultative.Pour plus d'informations,consultez Configuration d'unrépertoire en écriture pour AWSGreengrass (p. 24).

19

http://docs.aws.amazon.com/cli/latest/reference/greengrass/list-core-definitions.html



http://docs.aws.amazon.com/cli/latest/reference/iot/describe-endpoint.html


https://en.wikipedia.org/wiki/Systemd


GGC v1.5.0

{ "coreThing": { "caPath": "ROOT_CA_PEM_HERE", "certPath": "CLOUD_PEM_CRT_HERE", "keyPath": "CLOUD_PEM_KEY_HERE", "thingArn": "THING_ARN_HERE", "iotHost": "HOST_PREFIX_HERE.iot.AWS_REGION_HERE.amazonaws.com", "ggHost": "greengrass.iot.AWS_REGION_HERE.amazonaws.com", "keepAlive": 600 }, "runtime": { "cgroup": { "useSystemd": "yes|no" } }, "managedRespawn": true}

Le fichier config.json apparaît dans /greengrass/config/ et contient les paramètres suivants :


caPath Le chemin d'accès au certificatd'authentification racineAWS IoT relatif au dossier /greengrass/certs.

Enregistrez le fichier sous ledossier /greengrass/certs.

certPath Le chemin d'accès au certificatNoyau AWS Greengrass relatifau dossier /greengrass/certs.


keyPath Chemin d'accès à la clé privéeNoyau AWS Greengrass relatifau dossier /greengrass/certs.


thingArn Amazon Resource Name(ARN) de l'objet AWS IoT quireprésente le Noyau AWSGreengrass.

Retrouvez cette informationpour votre noyau dans laConsole AWS Greengrass sousNoyaux, ou en exécutant lacommande aws greengrasslist-core-definitions.


Retrouvez cette informationdans la Console IoT AWS sousSettings (Paramètres), ou enexécutant la commande awsiot describe-endpoint.


Cette valeur utilise le formatgreengrass.iot.region.amazonaws.com.Utilisez la même région queiotHost.

20











Cette valeur est facultative.La valeur par défaut est de600 secondes.

useSystemd Indique si votre appareil utilisesystemd.

Les valeurs sont yes ou no.Utilisez le script de dépendancedu Module 1 (p. 32) pourvoir si votre appareil utilisesystemd.


Pour plus d'informations,consultez Mises à jour OTAdes principaux logiciels AWSGreengrass (p. 119).

GGC v1.3.0

{ "coreThing": { "caPath": "ROOT_CA_PEM_HERE", "certPath": "CLOUD_PEM_CRT_HERE", "keyPath": "CLOUD_PEM_KEY_HERE", "thingArn": "THING_ARN_HERE", "iotHost": "HOST_PREFIX_HERE.iot.AWS_REGION_HERE.amazonaws.com", "ggHost": "greengrass.iot.AWS_REGION_HERE.amazonaws.com", "keepAlive": 600 }, "runtime": { "cgroup": { "useSystemd": "yes|no" } }, "managedRespawn": true}

Le fichier config.json apparaît dans /greengrass/config/ et contient les paramètres suivants :


caPath Le chemin d'accès au certificatd'authentification racineAWS IoT relatif au dossier /greengrass/certs.






21








Vous le trouverez dans laConsole AWS Greengrass sousla définition de votre objet AWSIoT.


Vous le trouverez dans laConsole IoT AWS sousParamètres.


Vous le trouverez dans laConsole IoT AWS sousParamètres, préfixé pargreengrass..



useSystemd Indicateur binaire, si votreappareil utilise systemd.



Pour plus d'informations,consultez Mises à jour OTAdes principaux logiciels AWSGreengrass (p. 119).

GGC v1.1.0

{ "coreThing": { "caPath": "ROOT_CA_PEM_HERE", "certPath": "CLOUD_PEM_CRT_HERE", "keyPath": "CLOUD_PEM_KEY_HERE", "thingArn": "THING_ARN_HERE", "iotHost": "HOST_PREFIX_HERE.iot.AWS_REGION_HERE.amazonaws.com", "ggHost": "greengrass.iot.AWS_REGION_HERE.amazonaws.com", "keepAlive": 600 }, "runtime": { "cgroup": { "useSystemd": "yes|no" } }}

Le fichier config.json existe dans /greengrass/config/ et contient les paramètres suivants :


caPath Le chemin d'accès au certificatd'authentification racine


22





Champ Description RemarquesAWS IoT relatif au dossier /greengrass/certs.













useSystemd Indicateur binaire, si votreappareil utilise systemd.


GGC v1.0.0

{ "coreThing": { "caPath": "ROOT_CA_PEM_HERE", "certPath": "CLOUD_PEM_CRT_HERE", "keyPath": "CLOUD_PEM_KEY_HERE", "thingArn": "THING_ARN_HERE", "iotHost": "HOST_PREFIX_HERE.iot.AWS_REGION_HERE.amazonaws.com", "ggHost": "greengrass.iot.AWS_REGION_HERE.amazonaws.com", "keepAlive": 600 }, "runtime": { "cgroup": { "useSystemd": "yes|no" } }}

23



AWS Greengrass Guide de l'utilisateurRépertoire en écriture

Le fichier config.json existe dans /greengrass/configuration/ et contient les paramètressuivants :


caPath Le chemin d'accès aucertificat d'authentificationracine AWS IoT relatif audossier /greengrass/configuration/certs.

Enregistrez le fichier sousle dossier /greengrass/configuration/certs.

certPath Le chemin d'accès au certificatNoyau AWS Greengrass relatifau dossier /greengrass/configuration/certs.


keyPath Chemin d'accès à la clé privéeNoyau AWS Greengrass relatifau dossier /greengrass/configuration/certs.










useSystemd Indicateur binaire si votreappareil utilise systemd.


Configuration d'un répertoire en écriture pour AWSGreengrassPar défaut, le logiciel Noyau AWS Greengrass est déployé dans un répertoire racine unique où AWSGreengrass effectue toutes les opérations de lecture et d'écriture. Cependant, vous pouvez configurer AWSGreengrass pour qu'il utilise un répertoire distinct pour toutes les opérations d'écriture, y compris la créationde répertoires et de fichiers. Dans ce cas, AWS Greengrass utilise deux répertoires de niveau supérieur :

• Le répertoire greengrass-root, que vous pouvez conserver accessible en lecture et en écritureou, si vous le souhaitez, rendre accessible en lecture seule. Celui-ci contient le logiciel Noyau AWS

24





Greengrass et d'autres composants critiques qui doivent rester immuables lors de l'exécution ('parexemple, les certificats et config.json).

• Le répertoire en écriture spécifié. Celui-ci contient le contenu accessible en écriture, tel que les journaux,les informations d'état et les fonctions Lambda définies par l'utilisateur déployées.

Cette configuration entraîne la structure de répertoires suivante.

Répertoire racine Greengrass

greengrass-root/|-- certs/| |-- root.ca.pem| |-- hash.cert.pem| |-- hash.private.key| |-- hash.public.key|-- config/| |-- config.json|-- ggc/| |-- packages/| |-- package-version/| |-- bin/| |-- daemon | |-- greengrassd| |-- lambda/| |-- LICENSE/| |-- release_notes_package-version.html| |-- runtime/| |-- java8/| |-- nodejs6.10/| |-- python2.7/| |-- core/

Répertoire en écriture

write-directory/|-- packages/| |-- package-version/| |-- ggc_root/| |-- rootfs_nosys/| |-- rootfs_sys/| |-- var/|-- deployment/| |-- group/| |-- group.json| |-- lambda/| |-- mlmodel/|-- var/| |-- log/| |-- state/

Pour configurer un répertoire en écriture

1. Exécutez la commande suivante pour arrêter le démon AWS Greengrass :

cd /greengrass-root/ggc/core/sudo ./greengrassd stop

2. Ouvrez greengrass-root/config/config.json pour le modifier en tant qu'utilisateur su.

25


3. Ajoutez writeDirectory en tant que paramètre et spécifiez le chemin d'accès au répertoire cible,comme illustré dans l'exemple suivant.

{ "coreThing": { "caPath": "root-CA.pem", "certPath": "hash.pem.crt", ... }, ... "writeDirectory" : "/write-directory"}

Note

Vous pouvez mettre à jour le paramètre writeDirectory aussi souvent que vous lesouhaitez. Une fois que le paramètre est mis à jour, AWS Greengrass utilise le répertoired'écriture nouvellement spécifié lors du démarrage suivant, mais ne migre pas le contenu durépertoire en écriture précédent.

4. Maintenant que votre répertoire en écriture est configuré, vous pouvez, si vous le souhaitez, rendre lerépertoire greengrass-root accessible en lecture seule. Pour en savoir plus, consultez Pour rendrele répertoire racine Greengrass accessible en lecture seule (p. 26).

Sinon, démarrez le démon AWS Greengrass :

cd /greengrass-root/ggc/core/sudo ./greengrassd start

Pour rendre le répertoire racine Greengrass accessible en lecture seule

1. Attribuez l'accès requis au AWS Greengrass :

Note

Cette étape est nécessaire uniquement si vous souhaitez que le répertoire racine Greengrasssoit accessible en lecture seule. Le répertoire en écriture doit être configuré avant decommencer cette procédure.

a. Accordez les autorisations en lecture et en écriture au propriétaire de config.json.

sudo chmod 0600 /greengrass-root/config/config.json

b. Définissez ggc_user en tant que propriétaire des répertoires certs et Lambda système.

sudo chown -R ggc_user:ggc_group /greengrass-root/certs/sudo chown -R ggc_user:ggc_group /greengrass-root/ggc/packages/1.5.0/lambda/

2. Rendez le répertoire greengrass-root accessible en lecture seule en utilisant la méthode de votrechoix.

Note

Une des méthodes pour rendre le répertoire greengrass-root accessible en lecture seuleconsiste à monter le répertoire en lecture seule. Toutefois, pour appliquer les mises à jourOTA sur le logiciel de base dans un répertoire monté, vous devez d'abord démonter celui-ci,puis le remonter après la mise à jour. Vous pouvez ajouter ces opérations umount et mount

26

AWS Greengrass Guide de l'utilisateurFile d'attente de messages MQTT

aux scripts ota_pre_update et ota_post_update. Pour plus d'informations sur les misesà jour OTA, consultez the section called “Agent OTA Greengrass” (p. 120) et the sectioncalled “Mise à jour de AWS Greengrass Core avec commande Respawn gérée” (p. 123).

3. Lancez le démon.

cd /greengrass-root/ggc/core/sudo ./greengrassd start

Si les autorisations de l'étape 1 ne sont pas correctement définies, le démon ne démarre pas.

File d'attente de messages MQTTLes messages MQTT destinés aux cibles de cloud sont mis en file d'attente avant d'être traités. Lesmessages en attente sont traités selon l'ordre FIFO (premier entré, premier sorti). Lorsqu'un message esttraité et publié dans le cloud, il est supprimé de la file d'attente. AWS Greengrass gère la file d'attente àl'aide d'une fonction Lambda GGCloudSpooler définie par le système.

Configuration de la file d'attente des messages MQTTVous pouvez configurer AWS Greengrass pour stocker les messages non traités en mémoire ou dansun cache de stockage local. Contrairement au stockage en mémoire, le cache de stockage local peutêtre conservé malgré les redémarrages du noyau (par exemple, après le déploiement d'un groupe ou unredémarrage de l'appareil), ce qui permet à AWS Greengrass de continuer à traiter les messages. Vouspouvez également configurer la taille du stockage.

Note

Les versions 1.5.0 et antérieures utilisent le stockage en mémoire avec une file d'attente d'unetaille de 2,5 Mo. Vous ne pouvez pas configurer les paramètres de stockage pour les versionsantérieures.

Les variables d'environnement suivantes pour la fonction Lambda GGCloudSpooler sont utilisées pourdéfinir les paramètres de stockage.

• GG_CONFIG_STORAGE_TYPE. Emplacement de la file d'attente de messages. Les valeurs suivantessont valides :• FileSystem. Les messages non traités sont stockés dans le cache de stockage local. Lorsque le

noyau redémarre, les messages mis en file d'attente sont conservés en vue de leur traitement. Lesmessages sont supprimés une fois qu'ils sont traités.

• Memory (default). Les messages non traités sont stockés en mémoire. Lorsque le noyau redémarre,les messages mis en file d'attente sont perdus.

Cette option est optimisée pour les périphériques avec des capacités matérielles restreintes. Lorsquevous utilisez cette configuration, nous vous recommandons de déployer des groupes ou de redémarrerl'appareil lorsque l'interruption de service est la moins importante.

• GG_CONFIG_MAX_SIZE_BYTES. Taille du stockage, en octets. Cette valeur peut être n'importequel nombre entier non négatif supérieur ou égal à 262 144 (256 Ko) ; une taille plus petite empêchele logiciel Noyau AWS Greengrass de démarrer. La taille par défaut est de 2.5 Mo. Lorsque la taillelimite est atteinte, les messages les plus anciens de la file d'attente sont remplacés par de nouveauxmessages.

27


Pour mettre en cache des messages dans le stockage local

Pour configurer AWS Greengrass de sorte que les messages soient mis en cache dans le système defichiers et qu'ils soient conservés malgré les redémarrages du noyau, créez une version de la définitionde fonction dans laquelle la fonction GGCloudSpooler spécifie le type de stockage FileSystem. Vousdevez utiliser l'API AWS Greengrass pour configurer le cache de stockage local. Vous ne pouvez pasréaliser cette opération dans la console.

La procédure suivante utilise la commande CLI create-function-definition-version pourconfigurer le spouleur de sorte qu'il enregistre les messages en file d'attente dans le système de fichiers.Elle configure également une file d'attente d'une taille de 2,6 Mo.

Note

Cette procédure suppose que vous mettez à jour la configuration de la version de groupe la plusrécente d'un groupe existant.

1. Obtenez les ID du groupe et de la version de groupe Greengrass cible.

aws greengrass list-groups

2. Copiez les propriétés Id et LatestVersion de votre groupe cible à partir de la sortie.3. Obtenez la version de groupe la plus récente.

• Remplacez group-id par la propriété Id que vous avez copiée.• Remplacez latest-group-version-id par la propriété LatestVersion que vous avez copiée.

aws greengrass get-group-version \--group-id group-id \--group-version-id latest-group-version-id

4. À partir de l'objet Definition dans la sortie, copiez le ComponentDefinitionVersionArn pourchaque composant de groupe à l'exception de FunctionDefinitionVersionArn. Vous utilisez cesvaleurs lorsque vous créez une nouvelle version de groupe.

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

Note

Si vous le souhaitez, vous pouvez créer une définition de fonction en exécutant la commandecreate-function-definition, puis copier l'ID à partir de la sortie.

6. Ajoutez une version de définition de fonction à la définition de fonction.

• Remplacez function-definition-id par l'Id que vous avez copié pour la définition de fonction.• Remplacez arbitrary-function-id par le nom attribué à la fonction, par exemple, spooler-function.

• Ajoutez toutes les fonctions Lambda que vous souhaitez inclure dans cette version dans le tableaufunctions. Vous pouvez utiliser la commande get-function-definition-version pourobtenir les fonctions à partir d'une version de définition de fonction existante.

Warning

Assurez-vous de spécifier une valeur pour GG_CONFIG_MAX_SIZE_BYTES qui soitsupérieure ou égale à 262 144. Une taille plus petite empêche le logiciel Noyau AWSGreengrass de démarrer.

28

http://docs.aws.amazon.com/cli/latest/reference/greengrass/create-function-definition-version.html

http://docs.aws.amazon.com/cli/latest/reference/greengrass/create-function-definition.html

http://docs.aws.amazon.com/cli/latest/reference/greengrass/get-function-definition-version.html


aws greengrass create-function-definition-version \--function-definition-id function-definition-id \--functions '[{"FunctionArn": "arn:aws:lambda:::function:GGCloudSpooler:1","FunctionConfiguration": {"Environment": {"Variables":{"GG_CONFIG_MAX_SIZE_BYTES":"2621440","GG_CONFIG_STORAGE_TYPE":"FileSystem"}},"Executable": "spooler","MemorySize": 32768,"Pinned": true,"Timeout": 3},"Id": "arbitrary-function-id"}]'

7. Copiez l'Arn de la version de définition de fonction à partir de la sortie.8. Créez une version de groupe qui contient la fonction Lambda définie par le système.

• Remplacez group-id par l'Id du groupe.• Remplacez core-definition-version-arn par l'élément CoreDefinitionVersionArn que

vous avez copié à partir de la dernière version de groupe.• Remplacez function-definition-version-arn par l'Arn que vous avez copié pour la

nouvelle version de définition de fonction.• Remplacez l'ARN des autres composants de groupe en utilisant les valeursComponentDefinitionVersionArn que vous avez copiées à partir de la version de groupe laplus récente.

• 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

9. Copiez la Version à partir de la sortie. Il s'agit de l'ID de la nouvelle version de groupe.10. Déployez le groupe.

• Remplacez group-id par l'Id que vous avez copié pour le groupe.• Remplacez group-version-id par la Version que vous avez copiée pour la nouvelle version de

groupe.

aws greengrass create-deployment \--group-id group-id \--group-version-id group-version-id \--deployment-type NewDeployment

Pour mettre à jour les paramètres de stockage, utilisez l'API AWS Greengrass pour créer une nouvelleversion de définition de fonction qui contient la fonction GGCloudSpooler avec la configuration miseà jour. Ensuite, ajoutez la version de définition de fonction à une nouvelle version de groupe (avecvos autres composants de groupe) et déployez la version de groupe. Si vous souhaitez restaurer laconfiguration par défaut, vous pouvez créer une version de définition de fonction qui n'inclut pas la fonctionGGCloudSpooler.

Cette fonction Lambda définie par le système n'est pas visible dans la console. Toutefois, lorsque lafonction est ajoutée à la version de groupe la plus récente, elle est incluse dans les déploiements que vouseffectuez à partir de la console (sauf si vous utilisez l'API pour la remplacer ou la supprimer).

29

AWS Greengrass Guide de l'utilisateurLancement de Greengrass au démarrage système

Configuration du système d'initialisation pour lelancement du démon GreengrassIl est recommandé de configurer votre système d'initialisation de manière à lancer le démon Greengrass audémarrage système, en particulier lorsque vous gérez d'importantes flottes d'appareils.

Il existe différents types de système d'initialisation, par exemple initd, systemd et SystemV, qui utilisentdes paramètres de configuration similaires. L'exemple suivant est un fichier de service pour systemd. Leparamètre Type est défini sur forking, car greengrassd (utilisé pour lancer Greengrass) duplique leprocessus du démon Greengrass, et le paramètre Restart est défini sur on-failure pour demander àsystemd de relancer Greengrass si celui-ci entre dans un état d'échec.

Note

Pour voir si votre appareil utilise systemd, exécutez le script check_ggc_dependencies commedécrit dans Module 1 (p. 32). Ensuite, pour utiliser systemd, assurez-vous que le paramètreuseSystemd dans config.json (p. 18) est défini sur yes.

[Unit]Description=Greengrass Daemon

[Service]Type=forkingPIDFile=/var/run/greengrassd.pidRestart=on-failureExecStart=/greengrass/ggc/core/greengrassd startExecReload=/greengrass/ggc/core/greengrassd restartExecStop=/greengrass/ggc/core/greengrassd stop

[Install]WantedBy=multi-user.target

Pour plus d'informations sur la façon de créer et d'activer un fichier de service pour systemd sur unRaspberry Pi, consultez SYSTEMD dans la documentation du Raspberry Pi.

30

https://www.raspberrypi.org/documentation/linux/usage/systemd.md

AWS Greengrass Guide de l'utilisateurPrérequis

Démarrez avec AWS GreengrassCe didacticiel comprend six modules, chacun conçu pour vous montrer les bases d'AWS Greengrass etvous aider à démarrer en utilisant le moins d'étapes possible. Ce tutoriel couvre les sujets suivants :

• Le modèle de programmation AWS Greengrass.• Les concepts fondamentaux, comme les noyaux, les groupes et les abonnements AWS Greengrass.• Le processus de déploiement pour l'exécution des fonctions AWS Lambda à la périphérie.

PrérequisPour suivre ce didacticiel, vous aurez besoin des éléments suivants :

• Un Mac, un PC Windows ou un ordinateur UNIX ou similaire.• Un compte Amazon Web Services (AWS). Si vous n'avez pas de compte AWS, consultez the section

called “Créez un compte AWS.” (p. 32).• L'utilisation d'une région AWS qui prend en charge AWS Greengrass. Pour obtenir la liste des régions

prises en charge pour AWS Greengrass, consultez Régions et points de terminaison AWS dans lemanuel AWS General Reference.

Important

Prenez note de votre région afin de vous assurer qu'elle est utilisée de façon systématiquedans ce didacticiel (le fait de passer à une autre région par inadvertance en cours de routeposerait problème). Notez que le dernier exercice de ce didacticiel se base sur la région USAEst (Virginie du Nord) ; nous vous conseillons donc, dans la mesure du possible, d'utiliseruniquement cette région.

• Une carte mère Raspberry Pi 3 Model B avec une carte microSD 8 Go, ou une instance Amazon EC2.Dans la mesure où AWS Greengrass est destiné à être utilisé avec un matériel physique, nous vousrecommandons d'utiliser une carte mère Raspberry Pi.

Note

Si le modèle de votre carte Raspberry Pi est inconnu, vous pouvez exécuter la commandesuivante :

cat /proc/cpuinfo

À proximité du bas de la liste, vous remarquerez la valeur de l'attribut Revision. Vous pouvezdéterminer le modèle de votre carte Pi en utilisant cette valeur avec le tableau de la rubriqueWhich Pi have I got? Par exemple, si la valeur de Revision est a02082, on voit dans la tableque Pi correspond à 3 Model B. En outre, l'architecture de votre Pi doit être supérieure ou égaleà armv71. Pour déterminer l'architecture de votre carte Raspberry Pi, exécutez la commandesuivante :

uname -m

Le résultat doit être supérieur ou égal à armv71.

31

https://en.wikipedia.org/wiki/Amazon_Web_Services#Availability_and_topology

http://docs.aws.amazon.com/general/latest/gr/rande.html#greengrass_region

https://www.amazon.com/Raspberry-Model-1-2GHz-64-bit-quad-core/dp/B01CD5VC92/ref=sr_1_3?ie=UTF8&qid=1510013943&sr=8-3&keywords=Raspberry+Pi+Model+3&dpID=51wEoDfvlIL&preST=_SX300_QL70_&dpSrc=srch

https://elinux.org/RPi_HardwareHistory#Which_Pi_have_I_got.3F

AWS Greengrass Guide de l'utilisateurCréez un compte AWS.

• Connaissances de base de Python 2.7.

Bien que ce didacticiel se concentre sur l'exécution d'AWS Greengrass sur une Raspberry Pi ou sur uneinstance Amazon EC2, d'autres plateformes sont prises en charge. Pour plus d'informations, consultezExigences et plateformes prises en charge (p. 13).

Créez un compte AWS.Si vous n'avez pas de compte AWS, suivez ces étapes :

1. Ouvrez la page d'accueil AWS et choisissez Create an AWS Account.

Note

Si vous vous êtes inscrit à AWS récemment, le message Connectez-vous à la console risquede s'afficher à la place.

2. Suivez les instructions en ligne. Dans le cadre de la procédure d'inscription, vous recevrez un appeltéléphonique et vous saisirez un code PIN en utilisant le clavier numérique de votre téléphone.

Important

Assurez-vous que votre compte dispose de privilèges d'administrateur avant de continuer.

Module 1 : Configuration de l'environnement pourGreengrass

Ce module vous montre comment obtenir une carte Raspberry Pi prête à l'emploi, une instance AmazonEC2 ou tout autre appareil prêt à être utilisé par AWS Greengrass.

Important

Utilisez la liste déroulante Filter View dans l'angle supérieur droit de cette page web pour choisirvotre plateforme.

Le module dure approximativement 30 minutes.

Configuration d'une carte Raspberry PiSi vous configurez une carte Raspberry Pi pour la première fois, vous devez suivre toutes ces étapes. Sivous utilisez une carte Raspberry Pi existante, vous pouvez passer directement à l'étape 9. Toutefois, nousvous recommandons de recréer une image de votre carte Raspberry Pi avec le système d'exploitation,comme recommandé à l'étape 2.

1. Téléchargez et installez un logiciel de formatage de carte SD tel que SD Memory Card Formatter ouPiBakery. Insérez la carte SD dans votre ordinateur. Démarrez le programme et choisissez le lecteuroù vous avez inséré votre carte SD. Vous pouvez formater rapidement la carte SD.

2. Téléchargez le système d'exploitation Raspbian Jessie sous la forme d'un fichier .zip. Actuellement,seul 2017-03-02-raspbian-jessie.zip est pris en charge par AWS Greengrass.

3. Lors de l'utilisation d'un outil d'écriture sur carte SD (par exemple, Etcher), suivez les instructionsde l'outil pour flasher le fichier 2017-03-02-raspbian-jessie.zip téléchargé sur la carte SD.Comme l'image du système d'exploitation est volumineuse, cette étape peut prendre un peu de temps.Ejectez votre carte SD de votre ordinateur et insérez la carte microSD dans votre Raspberry Pi.

32

http://aws.amazon.com/

https://www.sdcard.org/downloads/formatter_4/index.html

http://www.pibakery.org/download.html


https://etcher.io/

AWS Greengrass Guide de l'utilisateurConfiguration d'une carte Raspberry Pi

4. Pour le premier démarrage, nous vous recommandons de connecter la carte Raspberry Pi à unmoniteur (via HDMI), un clavier et une souris. Connectez ensuite votre carte Pi à une sourced'alimentation micro USB et le système d'exploitation Raspbian doit démarrer.

5. Vous voudrez peut-être configurer la disposition du clavier de la carte Pi avant de continuer. Pour cefaire, cliquez sur l'icône Raspberry dans l'angle supérieur droit, choisissez Preferences, puis Mouseand Keyboard Settings. Choisissez ensuite l'onglet Keyboard, Keyboard Layout, puis sélectionnez unevariante de clavier appropriée.

6. Puis connectez votre Raspberry Pi à Internet via un réseau Wi-Fi ou un câble Ethernet.

Note

Connectez votre Raspberry Pi au même réseau que votre ordinateur et assurez-vous quevotre ordinateur et votre Raspberry Pi ont tous deux accès à Internet avant de continuer.Si vous vous trouvez dans un environnement de travail ou derrière un pare-feu, vousdevrez peut-être connecter votre Pi et votre ordinateur au réseau invité afin que les deuxappareils soient sur le même réseau. Cette approche risque néanmoins de déconnectervotre ordinateur de certaines ressources du réseau local, comme l'intranet. Une solutionpossible consiste à connecter le Pi ainsi que votre ordinateur au réseau Wi-Fi invité et derelier votre ordinateur au réseau local via un câble Ethernet. Avec cette configuration, votreordinateur devrait pouvoir se connecter à la carte Raspberry Pi via le réseau Wi-Fi invité etaux ressources de votre réseau local grâce au câble Ethernet.

7. Vous devez configurer SSH sur votre carte Pi pour pouvoir vous y connecter à distance. Sur votreRaspberry Pi, ouvrez une fenêtre de terminal et exécutez la commande suivante :

sudo raspi-config

Vous devez voir ce qui suit :

Faites défiler la page vers le bas et choisissez Interfacing Options, puis P2 SSH. Lorsque vous y êtesinvité, choisissez Yes à l'aide de la touche Tabulation (suivie de la touche Entrée). SSH doit désormaisêtre activé. Cliquez sur OK. Appuyez sur la touche Tabulation pour Terminer et appuyez ensuite sur latouche Entrée. Enfin, redémarrez votre Pi en exécutant la commande suivante :

sudo reboot

8. Sur votre Raspberry Pi, dans la fenêtre de terminal, exécutez la commande suivante :

hostname -I

33

https://www.raspberrypi.org/documentation/configuration/wireless/desktop.md

https://en.wikipedia.org/wiki/Secure_Shell

https://www.raspberrypi.org/documentation/usage/terminal/


Cela renvoie l'adresse IP de votre Raspberry Pi.

Note

Pour les éléments suivants, si vous recevez un message concernant l'empreinte digitalede clé ECDSA Are you sure you want to continue connecting (yes/no)?,indiquez yes. Le mot de passe par défaut de la carte Raspberry Pi est raspberry.

Si vous utilisez macOS, ouvrez une fenêtre Terminal et tapez :

ssh pi@IP-address

IP-address correspond ici à l'adresse IP de votre Raspberry Pi, obtenue en utilisant la commandehostname -I précédente.

Si vous utilisez Windows, vous devez installer et configurer PuTTY. Choisissez Connection, Data etassurez-vous que Prompt est sélectionné :

Choisissez ensuite Session, saisissez l'adresse IP du Raspberry Pi, puis sélectionnez Open enutilisant les paramètres par défaut. Par exemple (votre adresse IP sera très probablement différente) :

34

https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html


Si une boîte de dialogue PuTTY Security Alert s'affiche, choisissez une réponse appropriée telle queYes (Oui).

Une fenêtre de terminal similaire à la suivante apparaîtra alors. L'ID de connexion et le mot de passepar défaut de la carte Raspberry Pi sont respectivement pi et raspberry.

35


Note

Si votre ordinateur est connecté à un réseau à distance à l'aide de VPN (par exemple, unréseau professionnel), vous pouvez rencontrer des difficultés pour vous connecter à la carteRaspberry Pi à partir de l'ordinateur à l'aide de SSH.

9. Vous êtes maintenant prêt à configurer la carte Raspberry Pi pour AWS Greengrass. Tout d'abord,exécutez les commandes suivantes à partir d'une fenêtre de terminal Raspberry Pi locale ou d'unefenêtre de terminal SSH :

sudo adduser --system ggc_usersudo addgroup --system ggc_group

10. Exécutez les commandes suivantes pour mettre à jour la version du noyau Linux de votre RaspberryPi.

sudo apt-get install rpi-updatesudo rpi-update b81a11258fc911170b40a0b09bbd63c84bc5ad59

Même si plusieurs versions du noyau peuvent fonctionner avec AWS Greengrass, pour des raisonsde sécurité optimale et de performances, nous vous recommandons d'utiliser la version du noyauindiquée à l'étape 2. Redémarrez votre Raspberry Pi afin d'activer le nouveau microprogramme :

sudo reboot

Le cas échéant, reconnectez-vous à la carte Raspberry Pi à l'aide de SSH après environ une minute.Exécutez ensuite la commande suivante afin de vous assurer que vous disposez de la version denoyau correcte :

uname -a

Vous devriez recevoir des résultats similaires à ce qui suit, l'élément principal étant les informations deversion de Linux Raspberry Pi 4.9.30 :

36


11. Pour améliorer la sécurité sur l'appareil Pi, exécutez les commandes suivantes afin d'activer lesprotections hardlink et softlink au démarrage du système d'exploitation.

cd /etc/sysctl.dls

Si vous consultez le fichier 98-rpi.conf, utilisez un éditeur de texte (tel que leafpad, nano ou vi)pour ajouter les deux lignes suivantes à la fin du fichier (vous pouvez exécuter l'éditeur de texte à l'aidede la commande sudo afin d'éviter les problèmes d'autorisation d'écriture, comme dans sudo nano98-rpi.conf).

fs.protected_hardlinks = 1fs.protected_symlinks = 1

Si vous ne voyez pas le fichier 98-rpi.conf, suivez les instructions fournies dans le fichierREADME.sysctl.

Maintenant, redémarrez le Pi :

sudo reboot

Après environ une minute, connectez-vous à la carte Pi à l'aide de SSH le cas échéant, puisexécutez les commandes suivantes à partir d'une fenêtre de terminal Raspberry Pi pour confirmer lamodification de hardlink ou symlink :

sudo sysctl -a 2> /dev/null | grep fs.protected

Vous devez voir fs.protected_hardlinks = 1 et fs.protected_symlinks = 1.12. Votre Raspberry Pi doit maintenant être prêt pour AWS Greengrass. Pour vous assurer que vous

disposez de toutes les dépendances requises pour AWS Greengrass, téléchargez le vérificateur dedépendance AWS Greengrass à partir du référentiel GitHub et exécutez-le sur le Pi comme suit :

cd /home/pi/Downloadsgit clone https://github.com/aws-samples/aws-greengrass-samples.gitcd aws-greengrass-samplescd greengrass-dependency-checker-GGCv1.5.0sudo modprobe configssudo ./check_ggc_dependencies | more

En ce qui concerne la commande more, appuyez sur la barre d'espace pour afficher un autre écran detexte.

Important

Dans la mesure où ce didacticiel utilise uniquement le Kit SDK des appareils AWS IoT pourPython, vous pouvez ignorer les avertissements sur les prérequis facultatifs NodeJS 6.10 etJava 8 que le script check_ggc_dependencies peut générer.

Pour en savoir plus sur la commande modprobe, vous pouvez exécuter man modprobe dans lafenêtre de terminal.

37

https://github.com/aws-samples/aws-greengrass-samples

AWS Greengrass Guide de l'utilisateurConfiguration d'une instance Amazon EC2

Votre configuration Raspberry Pi est terminée. Passez au the section called “Module 2 : Installation dulogiciel Greengrass Core” (p. 45).

Configuration d'une instance Amazon EC21. Connectez-vous à AWS Management Console et lancez une instance Amazon EC2 en utilisant une

AMI Amazon Linux. Pour en savoir plus sur les instances Amazon EC2, consultez le Amazon EC2Getting Started Guide.

2. Une fois que votre instance Amazon EC2 est en cours d'exécution, activez le port 8883 pour autoriserles communications MQTT entrantes afin que d'autres appareils puissent se connecter au Noyau AWSGreengrass. Dans le volet de gauche de la console Amazon EC2 Management, choisissez Groupes desécurité.

Choisissez l'instance que vous venez de lancer, puis sélectionnez l'onglet Entrant.

38

https://console.aws.amazon.com/

http://docs.aws.amazon.com/AWSEC2/latest/GettingStartedGuide/

http://docs.aws.amazon.com/AWSEC2/latest/GettingStartedGuide/


Par défaut, un seul port SSH est activé. Pour activer le port 8883, cliquez sur le bouton Modifier.Cliquez ensuite sur le bouton Add Rule et créez une règle TCP personnalisée comme indiqué ci-dessous, puis choisissez Enregistrer.

3. Dans le volet de gauche, choisissez Instances, sélectionnez votre instance, puis cliquez sur le boutonConnexion. Connectez-vous à votre instance Amazon EC2 à l'aide de SSH. Vous pouvez utiliserPuTTY pour Windows ou Terminal pour macOS.

39



4. Une fois connecté à votre instance Amazon EC2 via SSH, exécutez les commandes suivantes pourcréer l'utilisateur ggc_user et le groupe ggc_group :

sudo adduser --system ggc_usersudo groupadd --system ggc_group

5. Pour améliorer la sécurité sur l'appareil, activez les protections hardlink/softlink au démarrage dusystème d'exploitation. Pour ce faire, exécutez les commandes suivantes :

cd /etc/sysctl.dls

À l'aide de votre éditeur de texte favori (leadpad, nano, vi, etc.), ajoutez les deux lignes suivantes àla fin du fichier 00-defaults.conf. Vous devrez peut-être modifier les autorisations (à l'aide de lacommande chmod) afin de pouvoir écrire sur le fichier, ou utiliser la commande sudo pour modifier entant qu'utilisateur racine (par exemple, sudo nano 00-defaults.conf).

fs.protected_hardlinks = 1fs.protected_symlinks = 1

Exécutez la commande suivante pour redémarrer l'instance Amazon EC2.

40

AWS Greengrass Guide de l'utilisateurConfiguration d'autres appareils

sudo reboot

Au bout de quelques minutes, connectez-vous à votre instance à l'aide de SSH comme indiqué ci-dessus. Ensuite, exécutez la commande suivante pour confirmer la modification.

sudo sysctl -a | grep fs.protected

Vous devriez voir que les protections hardlink et softlink sont définies avec la valeur 1.6. Extrayez et exécutez le script suivant pour monter les groupes de contrôle Linux (cgroups). Il s'agit

d'une dépendance AWS Greengrass :

curl https://raw.githubusercontent.com/tianon/cgroupfs-mount/951c38ee8d802330454bdede20d85ec1c0f8d312/cgroupfs-mount > cgroupfs-mount.shchmod +x cgroupfs-mount.sh sudo bash ./cgroupfs-mount.sh

Votre instance Amazon EC2 doit maintenant être prête pour AWS Greengrass. Pour être sûr que vousdisposez de toutes les dépendances, extrayez et exécutez le script de dépendance AWS Greengrasssuivant depuis le référentiel GitHub :

sudo yum install gitgit clone https://github.com/aws-samples/aws-greengrass-samples.gitcd aws-greengrass-samplescd greengrass-dependency-checker-GGCv1.5.0sudo ./check_ggc_dependencies

La configuration de votre instance Amazon EC2 est terminée. Passez au the section called “Module 2 :Installation du logiciel Greengrass Core” (p. 45).

Configuration d'autres appareilsSi vous utilisez AWS Greengrass pour la première fois, nous vous recommandons d'utiliser une carteRaspberry Pi ou une instance Amazon EC2, puis de suivre les étapes indiquées ci-dessus pour configurerl'appareil. Suivez les étapes ci-dessous pour que votre propre appareil pris en charge par AWS Greengrasssoit prêt pour AWS Greengrass.

1. Pour vous assurer que vous disposez d'autres appareils prêts à exécuter AWS Greengrass,téléchargez et extrayez le vérificateur de dépendance Greengrass depuis le référentiel GitHub, puisexécutez les commandes suivantes :

git clone https://github.com/aws-samples/aws-greengrass-samples.gitcd aws-greengrass-samplescd greengrass-dependency-checker-GGCv1.5.0 sudo ./check_ggc_dependencies

Ce script s'exécute sur les plateformes AWS Greengrass prises en charge et nécessite lescommandes système Linux suivantes :

printf, uname, cat, ls, head, find, zcat, awk, sed, sysctl, wc, cut, sort, expr, grep, test, dirname, readlink, xargs, strings, uniq

2. Installez toutes les dépendances requises sur votre appareil, comme indiqué par le script dedépendance. S'il manque des dépendances au niveau du noyau, il se peut que vous ayez besoin de

41

https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/6/html/resource_management_guide/ch01




recompiler votre noyau. Pour monter les groupes de contrôle Linux (cgroups), vous pouvez exécuterle script cgroupfs-mount.

Note

Si aucune erreur n'apparaît dans la sortie, AWS Greengrass doit être en mesure des'exécuter avec succès sur votre appareil.

Pour obtenir la liste des exigences et des dépendances AWS Greengrass, consultez Exigences etplateformes prises en charge (p. 13).

Configuration de NVIDIA Jetson TX2 pour AWS GreengrassSi votre appareil principal est un NVIDIA Jetson TX2, vous devez le configurer avant de pouvoir installer leAWS Greengrass. Les étapes suivantes décrivent comment flasher le microprogramme sur un programmed'installation JetPack et recompiler le noyau afin que l'appareil soit prêt à installer le logiciel Noyau AWSGreengrass.

Note

La version du programme d'installation JetPack que vous utilisez est basée sur la version ciblede votre boîte à outils CUDA. Les instructions suivantes supposent que vous utilisez JetPack3.1 et la boîte à outils CUDA 8.0, les fichiers binaires de TensorFlow v1.4.0 fournis par AWSGreengrass pour l'inférence de Machine Learning étant compilés pour cette version de CUDA.Pour plus d'informations sur l'inférence de Machine Learning AWS Greengrass, consultezExécuter l'inférence de Machine Learning (p. 159).

Flasher le microprogramme JetPack 3.1

1. Sur un ordinateur de bureau physique exécutant Ubuntu 14 ou 16, flashez le microprogramme surJetPack 3.1, comme décrit dans la section Télécharger et installer JetPack L4T.

Suivez les instructions affichées dans le programme d'installation pour installer tous les packageset toutes les dépendances sur la carte Jetson connectée à l'ordinateur de bureau à l'aide d'un câbleMicro-B. Démarrez l'appareil en mode de récupération forcée.

Note

Une fois l'installation de JetPack terminée, utilisez les informations d'identification ubuntu pourvous connecter à l'appareil. L'agent SSH se bloque lorsqu'il essaie de se connecter à l'aided'un autre compte, même si vous utilisez SSH directement sur la carte à l'aide du compteconcerné.

2. Redémarrez votre carte en mode normal, puis connectez un écran à la carte.

Recompiler le noyau NVIDIA Jetson TX2Exécutez les commandes suivantes sur la carte Jetson.

1. Vérifiez les configuration du noyau :

nvidia@tegra-ubuntu:~$ zcat /proc/config.gz | grep -e CONFIG_KEYS -e CONFIG_POSIX_MQUEUE -e CONFIG_OF_OVERLAY -e CONFIG_OVERLAY_FS -e CONFIG_HAVE_ARCH_SECCOMP_FILTER -e CONFIG_SECCOMP_FILTER -e CONFIG_SECCOMP -e CONFIG_DEVPTS_MULTIPLE_INSTANCES -e CONFIG_IPC_NS -e CONFIG_NET_NS -e CONFIG_UTS_NS -e CONFIG_USER_NS -e CONFIG_PID_NS -e CONFIG_CGROUPS –e CONFIG_MEMCG -e CONFIG_CGROUP_FREEZER -e CONFIG_CGROUP_DEVICE# CONFIG_POSIX_MQUEUE is not setCONFIG_CGROUPS=yCONFIG_CGROUP_FREEZER=y

42

https://raw.githubusercontent.com/tianon/cgroupfs-mount/master/cgroupfs-mount

http://docs.nvidia.com/jetpack-l4t/index.html#developertools/mobile/jetpack/l4t/3.0/jetpack_l4t_install.htm


# CONFIG_CGROUP_DEVICE is not set# CONFIG_MEMCG is not setCONFIG_UTS_NS=yCONFIG_IPC_NS=y# CONFIG_USER_NS is not setCONFIG_PID_NS=yCONFIG_NET_NS=yCONFIG_HAVE_ARCH_SECCOMP_FILTER=yCONFIG_SECCOMP_FILTER=yCONFIG_SECCOMP=y# CONFIG_OF_OVERLAY is not setCONFIG_DEVPTS_MULTIPLE_INSTANCES=y# CONFIG_OVERLAY_FS is not set# CONFIG_KEYS is not set

2. Vérifiez les paramètres de performances et de puissance :

nvidia@tegra-ubuntu:~$ sudo nvpmodel –qNV Power Mode: MAXP_CORE_ARM3

3. Réglez le Jetson en mode de performances élevées :

nvidia@tegra-ubuntu:~$ sudo nvpmodel –m 0

4. Clonez le référentiel git :

nvidia@tegra-ubuntu:~$ cd /nvidia@tegra-ubuntu:~$ sudo git clone https://github.com/jetsonhacks/buildJetsonTX2Kernel.git

5. Modifiez le script getKernelSources.sh en fonction de la différence de changement suivante :

index f47f28d..3dd863a 100755--- a/scripts/getKernelSources.sh+++ b/scripts/getKernelSources.sh@@ -1,12 +1,15 @@ #!/bin/bash apt-add-repository universe apt-get update-apt-get install qt5-default pkg-config -y+apt-get install qt5-default pkg-config libncurses5-dev libssl-dev -y cd /usr/src wget http://developer.download.nvidia.com/embedded/L4T/r28_Release_v1.0/BSP/source_release.tbz2 tar -xvf source_release.tbz2 sources/kernel_src-tx2.tbz2 tar -xvf sources/kernel_src-tx2.tbz2 cd kernel/kernel-4.4+make clean zcat /proc/config.gz > .config-make xconfig+echo "type something to continue"+read+make menuconfig

6. Exécutez le script getKernelSources :

nvidia@tegra-ubuntu:~$ cd /buildJetsonTX2Kernelnvidia@tegra-ubuntu:~$ sudo ./getKernelSources.sh

7. Lorsque l'invite « type something to continue » (saisissez des caractères pour continuer) s'affiche,appuyez sur CTRL + Z pour mettre le script en arrière-plan.

43


8. Accédez à /usr/src/kernel/kernel-4.4/security/keys et modifiez le fichier Kconfig en ajoutant les lignessuivantes entre KEYS et PERSISTENT_KEYRINGS :

config KEYS_COMPAT def_bool y depends on COMPAT && KEYS

9. Relancez le script :

nvidia@tegra-ubuntu:~$ cd /usr/src/kernel/kernel-4.4/nvidia@tegra-ubuntu:~$ fg

Saisissez quelques caractères pour débloquer le script.10. Dans la fenêtre de configuration qui s'ouvre, choisissez Enable loadable module support (Activer

le support des modules chargeables), puis ouvrez le sous-menu pour activer la vérification de lasignature optionModule. Utilisez les touches fléchées pour vous déplacer et la barre d'espace poursélectionner une option. Enregistrez les modifications et quittez la fenêtre.

11. Vérifiez que KEYS_COMPAT est activé :

nvidia@tegra-ubuntu:~$ grep --color KEYS_COMPAT /usr/src/kernel/kernel-4.4/.config

12. Ouvrez l'interface de configuration du noyau et activez les configurations du noyau :

nvidia@tegra-ubuntu:~$ sudo make xconfig

Une fenêtre répertoriant toutes les configurations du noyau s'ouvre. Utilisez l'option FIND(RECHERCHER) pour rechercher les mots-clés suivants et cochez-les.

Note

Les mots-clés varient en fonction de la configuration. La liste suivante contient d'autresversions entre parenthèses qui peuvent vous aider à trouver les mots-clés équivalents pourvotre configuration.

• CONFIG_POSIX_MQUEUE (file d'attente de messages POSIX)• CONFIG_OF_OVERLAY (prise en charge de systèmes de fichiers superposés)• CONFIG_OVERLAY_FS (prise en charge de systèmes de fichiers superposés)• CONFIG_USER_NS (espace de noms de utilisateur)• CONFIG_MEMCG (contrôleur de ressources mémoire pour groupe de contrôle)• CONFIG_CGROUP_DEVICE (contrôleur de périphériques pour cgroups)

13. Compilez le noyau :

nvidia@tegra-ubuntu:~$ cd /buildJetsonTX2Kernelnvidia@tegra-ubuntu:~$ sudo ./makeKernel.sh

14. Vérifiez que les configurations du noyau sont activées :

nvidia@tegra-ubuntu:~$ grep --color CONFIG_POSIX_MQUEUE /usr/src/kernel/kernel-4.4/.confignvidia@tegra-ubuntu:~$ grep --color CONFIG_OF_OVERLAY /usr/src/kernel/kernel-4.4/.confignvidia@tegra-ubuntu:~$ grep --color CONFIG_OVERLAY_FS /usr/src/kernel/kernel-4.4/.confignvidia@tegra-ubuntu:~$ grep --color CONFIG_USER_NS /usr/src/kernel/kernel-4.4/.confignvidia@tegra-ubuntu:~$ grep --color CONFIG_MEMCG /usr/src/kernel/kernel-4.4/.config

44

AWS Greengrass Guide de l'utilisateurModule 2 : Installation du logiciel Greengrass Core

nvidia@tegra-ubuntu:~$ grep --color CONFIG_CGROUP_DEVICE /usr/src/kernel/kernel-4.4/.confignvidia@tegra-ubuntu:~$ grep --color CONFIG_KEYS_COMPAT /usr/src/kernel/kernel-4.4/.confignvidia@tegra-ubuntu:~$ grep --color CONFIG_COMPAT /usr/src/kernel/kernel-4.4/.confignvidia@tegra-ubuntu:~$ grep --color CONFIG_KEYS /usr/src/kernel/kernel-4.4/.config

15. Copiez l'image :

nvidia@tegra-ubuntu:~$ sudo ./copyImage.sh

Module 2 : Installation du logiciel Greengrass CoreCe module explique comment installer le logiciel Noyau AWS Greengrass sur votre appareil. Avant decommencer, assurez-vous d'avoir terminé le Module 1 (p. 32).

Le logiciel Noyau AWS Greengrass fournit les fonctionnalités suivantes :

• Autorise le déploiement et l'exécution d'applications locales créées à l'aide des fonctions AWS Lambdaet gérées par le biais de l'API de déploiement.

• Permet l'utilisation de la messagerie locale entre les appareils sur un réseau sécurisé à l'aide d'unschéma d'abonnement géré par le protocole MQTT.

• Garantit des connexions sécurisées entre les appareils et le cloud à l'aide de l'authentification et del'autorisation des appareils.

• Fournit les mises à jour logicielles OTA sécurisées des fonctions Lambda définies par l'utilisateur.

Le module dure approximativement 30 minutes.

Configuration d'AWS Greengrass sur AWS IoT1. Connectez-vous à AWS Management Console sur votre ordinateur et ouvrez la Console IoT AWS. S'il

s'agit de la première ouverture de cette console, choisissez Mise en route.

Choisissez ensuite Greengrass :

45

https://console.aws.amazon.com/

AWS Greengrass Guide de l'utilisateurConfiguration d'AWS Greengrass sur AWS IoT

2. Sur la page Bienvenue dans AWS Greengrass, choisissez Mise en route :

46


3. Créez un Groupe AWS Greengrass. Un Groupe AWS Greengrass contient des informations surles appareils et sur la façon dont les messages sont traités dans le groupe. Chaque Groupe AWSGreengrass nécessite un appareil Noyau AWS Greengrass qui traite les messages envoyés au seindu groupe. Un Noyau AWS Greengrass requiert un certificat et une stratégie AWS IoT pour accéder àAWS Greengrass et Services de cloud AWS. Sur la page Configurer un groupe, choisissez Utiliser lacréation simplifiée.

4. Saisissez un nom pour votre groupe (par exemple, MyFirstGroup), puis choisissez Suivant :

47


5. Utilisez le nom par défaut pour Noyau AWS Greengrass, puis cliquez sur Suivant :

6. Sur la page Exécuter une création de groupe simplifiée scriptée, choisissez Créer un groupe et unnoyau.

48


AWS IoT crée automatiquement un Groupe AWS Greengrass avec les stratégies de sécurité pardéfaut et les fichiers de configuration pour que vous les chargiez sur votre appareil.

7. Sur la page de confirmation, téléchargez les ressources de sécurité de votre noyau et le logiciel AWSGreengrass Core, comme suit :

a. Sous Télécharger et stocker les ressources de sécurité de Core, choisissez Télécharger cesressources au format tar.gz pour télécharger les ressources de sécurité requises pour votre NoyauAWS Greengrass.

b. Sous Software configurations (Configurations des logiciels), pour le logiciel Noyau AWSGreengrass, choisissez la distribution et l'architecture d'UC (ainsi que le système d'exploitation, sinécessaire) de votre appareil principal :

• Si vous utilisez un Raspberry Pi, téléchargez le ARMv7l pour le package Raspbian Jessie.• Si vous utilisez une instance Amazon EC2, téléchargez l'un des packages x86_64.

49

AWS Greengrass Guide de l'utilisateurDémarrage d'AWS Greengrass sur l'appareil Core

Important

Vous devez télécharger à la fois les ressources de sécurité et le logiciel AWS GreengrassCore avant de choisir Terminer.

8. Après le téléchargement des ressources de sécurité et du logiciel AWS Greengrass Core, choisissezTerminer.

La page de configuration de groupe s'affiche dans la console :

Démarrage d'AWS Greengrass sur l'appareil Core1. À l'étape précédente (p. 49), vous avez téléchargé deux fichiers à partir de la Console AWS

Greengrass :

• greengrass-OS-architecture-1.5.0.tar.gz : ce fichier compressé contient le logicielNoyau AWS Greengrass qui s'exécute sur l'appareil Noyau AWS Greengrass.

• GUID-setup.tar.gz : ce fichier compressé contient des certificats de sécurité permettant desécuriser les communications avec le cloud AWS IoT et config.json qui contient des informationsde configuration spécifiques à votre Noyau AWS Greengrass et au point de terminaison AWS IoT.

50


Si vous ne vous souvenez pas de l'adresse IP de votre appareil Noyau AWS Greengrass, ouvrez unefenêtre de terminal sur l'appareil Noyau AWS Greengrass et exécutez la commande suivante :

hostname -I

Selon votre système d'exploitation, choisissez un onglet pour transférer les deux fichiers compressésdepuis votre ordinateur vers l'appareil Noyau AWS Greengrass :

Note

Souvenez-vous que l'ID de connexion et le mot de passe par défaut de la carte Raspberry Pisont respectivement pi et raspberry.

Windows

Pour transférer les fichiers compressés depuis votre ordinateur vers un appareil Raspberry PiNoyau AWS Greengrass, utilisez un outil pratique tel que WinSCP ou la commande pscp dePuTTY. Pour utiliser la commande pscp, ouvrez une fenêtre d'invite de commande sur votreordinateur et exécutez les éléments suivants :

cd path-to-downloaded-filespscp -pw Pi-password greengrass-OS-architecture-1.5.0.tar.gz pi@IP-address:/home/pipscp -pw Pi-password GUID-setup.tar.gz pi@IP-address:/home/pi

Exemples :

macOS

Pour transférer les fichiers compressés depuis votre Mac vers un appareil Raspberry PiNoyau AWS Greengrass, ouvrez une fenêtre de terminal sur votre ordinateur et exécutez lescommandes suivantes (notez que path-to-downloaded-files correspond généralement à ~/Downloads).

Note

Il se peut que vous soyez invité à saisir deux mots de passe. Dans ce cas, le premier motde passe est celui de la commande sudo du Mac, et le deuxième celui du Raspberry Pi.

cd path-to-downloaded-filessudo scp greengrass-OS-architecture-1.5.0.tar.gz pi@IP-address:/home/pisudo scp GUID-setup.tar.gz pi@IP-address:/home/pi

Système UNIX

Pour transférer les fichiers compressés depuis votre ordinateur vers un appareil Raspberry PiNoyau AWS Greengrass, ouvrez une fenêtre de terminal sur votre ordinateur et exécutez lescommandes suivantes :

cd path-to-downloaded-filessudo scp greengrass-OS-architecture-1.5.0.tar.gz pi@IP-address:/home/pi

51

https://winscp.net/eng/download.php



sudo scp GUID-setup.tar.gz pi@IP-address:/home/pi

Navigateur web Raspberry Pi

Si vous avez utilisé le navigateur web du Raspberry Pi pour télécharger les fichiers compressés,ceux-ci doivent se trouver dans le dossier ~/Downloads du Pi (c-à-d. /home/pi/Downloads). Àdéfaut, les fichiers compressés doivent se trouver dans le dossier ~ du Pi (c-à-d. /home/pi).

Ouvrez une fenêtre de terminal sur l'appareil Noyau AWS Greengrass et accédez au dossier contenantles fichiers compressés (à savoir, path-to-compressed-files).

cd path-to-compressed-files

Exécutez ensuite les commandes suivantes pour décompresser le fichier binaire Noyau AWSGreengrass et les ressources de sécurité (certificats, etc.) dans le fichier:

sudo tar -xzvf greengrass-OS-architecture-1.5.0.tar.gz -C /sudo tar -xzvf GUID-setup.tar.gz -C /greengrass

La première commande crée notamment le répertoire /greengrass dans le dossier racine del'appareil Noyau AWS Greengrass (via l'argument -C /). La deuxième commande copie lescertificats dans le dossier /greengrass/certs et le fichier config.json dans le dossier /greengrass/config (via l'argument -C /greengrass). Pour plus d'informations, consultez Fichierde configuration AWS Greengrass Core (p. 18).

2. Installez le certificat d'authentification racine VeriSign de Symantec sur votre appareil. Ce certificatpermet à votre appareil de communiquer avec AWS IoT à l'aide du protocole de messagerie MQTT surTLS. Assurez-vous que l'appareil Noyau AWS Greengrass est connecté à Internet, puis exécutez lescommandes suivantes (notez que -O est la lettre majuscule O) :

cd /greengrass/certs/sudo wget -O root.ca.pem http://www.symantec.com/content/en/us/enterprise/verisign/roots/VeriSign-Class%203-Public-Primary-Certification-Authority-G5.pem

Exécutez la commande suivante pour confirmer que le fichier root.ca.pem n'est pas vide :

cat root.ca.pem

Si le fichier root.ca.pem est vide, vérifiez l'URL wget et réessayez.3. Utilisez les commandes suivantes pour démarrer AWS Greengrass.

cd /greengrass/ggc/core/sudo ./greengrassd start

Vous devez visualiser une sortie similaire à la suivante (notez le numéro PID) :

52


AWS Greengrass Guide de l'utilisateurModule 3 (Partie 1) : FonctionsLambda sur AWS Greengrass

Note

Pour configurer votre appareil principal de manière à lancer AWS Greengrass au démarragedu système, consultez the section called “Lancement de Greengrass au démarragesystème” (p. 30).

Exécutez ensuite la commande suivante pour confirmer que le logiciel Noyau AWS Greengrass(démon) fonctionne. Remplacez PID-number par votre propre numéro PID :

ps aux | grep PID-number

Vous devriez voir le chemin du démon AWS Greengrass en cours d'exécution, comme dans/greengrass/ggc/packages/1.5.0/bin/daemon. Si vous rencontrez des problèmespour démarrer AWS Greengrass, consultez Résolution des problèmes des applications AWSGreengrass (p. 205).

Module 3 (Partie 1) : Fonctions Lambda sur AWSGreengrass

Ce module vous explique comment configurer une fonction Lambda et la déployer sur votre appareil NoyauAWS Greengrass. Il contient des informations sur les déploiements, les abonnements et la messagerieMQTT sur AWS Greengrass, ainsi que les configurations des fonctions Lambda.

La Partie 1 de ce module vous montre comment déployer une fonction Lambda sur l'appareil NoyauAWS Greengrass qui envoie des messages « Hello World » vers le cloud AWS Greengrass. LaPartie 2 (p. 71) traite les différences entre les fonctions Lambda à la demande et longue durées'exécutant sur le Noyau AWS Greengrass. Avant de commencer, assurez-vous que vous avez terminé leModule 1 (p. 32) et le Module 2 (p. 45), et que vous disposez d'un appareil Noyau AWS Greengrassen cours d'exécution. Notez que le Module 3 (Partie 1) (p. 53) et le Module 3 (Partie 2) (p. 71)doivent prendre environ 30 minutes chacun.

Création et empaquetage d'une fonction LambdaPour qu'une fonction Lambda Python s'exécute sur un Noyau AWS Greengrass, elle doit être packagéeavec des dossiers spécifiques du kit SDK AWS Greengrass Core Python. Dans les sections ci-après, vouseffectuerez les actions suivantes :

53

AWS Greengrass Guide de l'utilisateurCréation et empaquetage d'une fonction Lambda

• Téléchargez le kit SDK AWS Greengrass Core Python sur votre ordinateur (pas sur l'appareil NoyauAWS Greengrass).

• Décompressez le fichier SDK téléchargé.• Obtenez la fonction Lambda Python (appelée greengrassHelloWorld.py) à partir du kit SDK

décompressé.• Créez un package de déploiement de fonction Lambda nommé hello_world_python_lambda.zip

et contenant greengrassHelloWorld.py, ainsi que le dossier greengrasssdk.• Chargez le package hello_world_python_lambda.zip à l'aide de la console Lambda.• Transférez le package vers l'appareil Noyau AWS Greengrass à l'aide de la Console AWS Greengrass.

1. Dans la Console IoT AWS, choisissez Logiciels.

2. Dans Kits SDK, pour Kit SDK AWS Greengrass Core, choisissez Configurer le téléchargement.

54


3. Choisissez Python 2.7 version 1.1.0, puis Télécharger le kit SDK Greengrass Core.

4. Décompressez le kit SDK téléchargé. Pour savoir comment procéder, choisissez l'ongletcorrespondant à votre système d'exploitation.

Windows

Utilisez un outil pour décompresser les fichiers .tar.gz sous Windows tels que 7-Zip, WinZip,ou équivalent. À titre d'exemple, l'outil 7-Zip peut être utilisé pour décompresser greengrass-core-python-sdk-1.1.0.tar.gz comme suit :

1. Après avoir installé 7-Zip, naviguez jusqu'au fichier greengrass-core-python-sdk-1.1.0.tar.gz à l'aide de l'Explorateur de fichiers Windows (touche du logo Windows+ E), cliquez sur le fichier à l'aide du bouton droit de la souris, choisissez 7-Zip, puis Openarchive.

2. Dans la fenêtre 7-Zip qui s'ouvre, double-cliquez sur greegrass-core-python-sdk-1.1.0.tar, aws_greengrass_core_sdk, examples, HelloWorld, puis surgreengrassHelloWorld.zip.

3. Si vous le souhaitez, vous pouvez utiliser la touche Ctrl pour sélectionner le dossiergreengrasssdk et le fichier Lambda greengrassHelloWorld.py. Ensuite, choisissezExtract, sélectionnez l'emplacement d'extraction des fichiers et cliquez sur OK.

macOS

1. À l'aide du Finder, accédez au fichier greengrass-core-python-sdk-1.1.0.tar.gz etdouble-cliquez dessus. Cela crée le dossier aws_greengrass_core_sdk.

2. Développez le dossier aws_greengrass_core_sdk, puis le dossier examples, et enfin ledossier HelloWorld.

55

http://www.7-zip.org/

http://www.winzip.com/


3. Double-cliquez sur le fichier greengrassHelloWorld.zip. Cela crée le dossiergreengrassHelloWorld. Développez-le également.

Système UNIX

1. Ouvrez une fenêtre de terminal et accédez au répertoire contenant le fichier greengrass-core-python-sdk-1.1.0.tar.gz.

2. Exécutez la commande suivante pour décompresser le fichier :

sudo tar -xzf greengrass-core-python-sdk-1.1.0.tar.gz

Le répertoire aws_greengrass_core_sdk est alors créé. Exécutez ensuite les commandessuivantes :

cd /aws_greengrass_core_sdk/examples/HelloWorldsudo unzip greengrassHelloWorld.zip

Vous utiliserez le dossier greengrasssdk et le code de fonction LambdagreengrassHelloWorld.py Python à l'étape suivante.

Notez que la fonction Lambda greengrassHelloWorld.py publie l'un des deux messagespossibles toutes les cinq secondes dans la rubrique hello/world, comme indiqué dans le code ci-après (pour économiser de l'espace, tous les commentaires de code ont été supprimés) :

import greengrasssdkimport platformfrom threading import Timerimport time

client = greengrasssdk.client('iot-data')my_platform = platform.platform()

def greengrass_hello_world_run(): if not my_platform: client.publish(topic='hello/world', payload='Hello world! Sent from Greengrass Core.') else: client.publish(topic='hello/world', payload='Hello world! Sent from Greengrass Core running on platform: {}'.format(my_platform)) Timer(5, greengrass_hello_world_run).start()

greengrass_hello_world_run()

def function_handler(event, context): return

5. Pour créer la fonction Lambda greengrassHelloWorld.py, vous devez empaqueter le fichiergreengrassHelloWorld.py et le dossier greengrasssdk dans un fichier .zip compressé. Ils'agit du package de déploiement de votre fonction Lambda. Pour ce didacticiel, nommez le packagehello_world_python_lambda.zip :

56


Pour les systèmes UNIX (y compris le terminal Mac), cette opération peut être réalisée à l'aide de lacommande suivante :

sudo zip -r hello_world_python_lambda.zip greengrasssdk greengrassHelloWorld.py

Note

En fonction de votre distribution, vous devrez peut-être d'abord installer zip. Par exemple,sudo apt-get install zip (cette commande d'installation peut varier pour votredistribution).

Vous êtes maintenant prêt à créer votre fonction Lambda et à télécharger le package de déploiement.6. Ouvrez la console Lambda et choisissez Create function (Créer une fonction).7. Choisissez Author from scratch.8. Nommez votre fonction Greengrass_HelloWorld et définissez les champs restants comme suit :

• Dans Runtime, sélectionnez Python 2.7.• Dans Role (Rôle), sélectionnez Create new role from template(s) (Créer un rôle à partir de modèles).• Dans Role name (Nom du rôle), tapez un nom unique pour le rôle.

Notez que ce rôle n'est pas utilisé par AWS Greengrass.

Puis, sélectionnez Create function (Créer une fonction).

57


9. Chargez votre package de déploiement de la fonction Lambda, comme suit :

a. Sous l'onglet Configuration, sous Function code (Code de la fonction), définissez les champssuivants :

• Dans Code entry type (Type d'entrée de code), choisissez Upload a .ZIP file (Charger unfichier .ZIP).

• Dans Runtime, sélectionnez Python 2.7.• Dans Handler (Gestionnaire), saisissez greengrassHelloWorld.function_handler.

b. Choisissez Upload (Charger), puis hello_world_python_lambda.zip. La taille de votrefichier hello_world_python_lambda.zip peut varier.

58


c. Choisissez Save.

Tip

Pour voir le code chargé, choisissez Edit code inline (Modifier le code en ligne) à partir dumenu Code entry type (Type d'entrée de code).

10.Publiez la fonction Lambda comme suit :

a. Dans le menu Actions, sélectionnez Publish new version:

b. Pour Version description, saisissez First version, puis choisissez Publication:

11.Créez un alias pour la version de la fonction Lambda, comme suit :

Note

Les groupes Greengrass peuvent référencer une fonction Lambda par alias (recommandé) oupar version. L'utilisation d'un alias facilite la gestion des mises à jour de code, car vous n'avezpas besoin de changer votre tableau d'abonnement ou votre définition de groupe lorsque lecode de fonction est mis à jour. Il suffit de faire pointer l'alias vers la nouvelle version de lafonction.

a. Dans le menu Actions, choisissez Create alias.

59

http://docs.aws.amazon.com/lambda/latest/dg/versioning-aliases.html

AWS Greengrass Guide de l'utilisateurConfiguration de la fonction Lambda pour AWS Greengrass

b. Nommez l'alias GG_HelloWorld, définissez la version sur 1 (qui correspond à la version quevous venez de publier), puis choisissez Create.

Note

AWS Greengrass ne prend pas en charge les alias Lambda pour les versions $LATEST.

Configuration de la fonction Lambda pour AWSGreengrassVous êtes maintenant prêt à configurer votre fonction Lambda pour AWS Greengrass.

1. Dans la Console IoT AWS, sousGreengrass, choisissez Groups (Groupes), puis choisissez le groupeque vous avez créé dans le Module 2 (p. 45).

2. Sur la page de configuration de groupe, choisissez Lambdas.

60


3. Choisissez Ajouter une fonction.

61


4. Choisissez Utiliser une fonction Lambda existante.

5. Recherchez le nom de la fonction Lambda que vous avez créée à l'étape précédente(Greengrass_HelloWorld et non le nom d'alias), sélectionnez-le, puis cliquez sur Suivant :

62


6. Pour la version, choisissez Alias : GG_HelloWorld, puis Terminer. Vous devriez voir la fonctionLambda Greengrass_HelloWorld de votre groupe, utilisant l'alias GG_HelloWorld.

7. Cliquez sur les points de suspension (…) pour la fonction Lambda, puis choisissez Edit Configuration(Modifier la configuration) :

8. Sur la page Configuration Lambda spécifique au groupe, effectuez les modifications suivantes :

• Dans Expiration, définissez le délai sur 25 secondes. La fonction Lambda passe en veille pendant20 secondes avant chaque appel.

• Dans Cycle de vie Lambda, sélectionnez Attribuer une longue durée de vie à cette fonction etl'exécuter indéfiniment.

Une fonction Lambda longue durée commence automatiquement après qu'AWS Greengrass adémarré et continue à s'exécuter dans son propre conteneur (ou sandbox), Cette possibilité contrasteavec une fonction Lambda à la demande qui démarre quand elle est appelée et qui s'arrête lorsqu'il n'ya plus de tâches à exécuter. Pour plus d'informations, consultez the section called “Configuration decycle de vie” (p. 131).

Note

La fonction Lambda dans ce didacticiel accepte les charges utiles d'entrée JSON, mais lesfonctions sont également compatibles avec les charges utiles d'entrée binaires. La prise encharge binaire est particulièrement utile lors de l'interaction avec les données de l'appareil,car à cause les capacités matérielles restreintes des appareils, il est souvent difficile voireimpossible de construire un type de données JSON.

63


9. Choisissez Mise à jour pour enregistrer les modifications que vous avez apportées à la configurationde la fonction Lambda.

10. Une fonction Lambda AWS Greengrass peut s'abonner ou publier des messages (à l'aide du protocoleMQTT) :

• Vers et à partir d'autres appareils (ou device shadows) au sein du Noyau AWS Greengrass. Desinformations sur les device shadows sont fournies dans le Module 5 (p. 96).

• Vers d'autres fonctions Lambda.• Vers le cloud AWS IoT.

Groupe AWS Greengrass contrôle la manière dont ces composants interagissent à l'aide desabonnements qui permettent une sécurité accrue et des interactions prévisibles.

Un abonnement se compose d'une source, d'une cible et d'une rubrique. La source est le créateurdu message. La cible est la destinataire du message. La rubrique vous permet de filtrer les donnéesenvoyées de la source vers la cible. La source ou la cible peut être un Appareil AWS Greengrass, unefonction Lambda, un device shadow ou le cloud AWS IoT. Un abonnement est dirigé dans le sens oùles messages sont acheminés dans une direction spécifique. Pour qu'un Appareil AWS Greengrassenvoie et reçoive des messages vers et depuis une fonction Lambda, vous devez configurer deuxabonnements : un à partir de l'appareil vers la fonction Lambda et un autre à partir de la fonctionLambda vers l'appareil. La fonction Lambda Greengrass_HelloWorld envoie des messagesuniquement vers la rubrique hello/world dans le cloud AWS IoT, comme indiqué dans l'extrait decode greengrassHelloWorld.py suivant :

def greengrass_hello_world_run(): if not my_platform: client.publish(topic='hello/world', payload='Hello world! Sent from Greengrass Core.') else: client.publish(topic='hello/world', payload='Hello world! Sent from Greengrass Core running on platform: {}'.format(my_platform))

# Asynchronously schedule this function to be run again in 5 seconds Timer(5, greengrass_hello_world_run).start()

# Execute the function above:greengrass_hello_world_run()

Comme la fonction Lambda Greengrass_HelloWorld envoie des messages uniquement versla rubrique hello/world dans le cloud AWS IoT, vous avez uniquement besoin de créer unabonnement à partir de la fonction Lambda vers le cloud AWS IoT, comme indiqué ci-après.

11. Sur la page de configuration de groupe, choisissez Abonnements, puis Ajouter votre premierabonnement.

64

http://mqtt.org/

http://mqtt.org/


12. Dans le champ Sélectionnez une source, choisissez Sélectionner. Puis, sur l'onglet Lambdas,choisissez Greengrass_HelloWorld comme source.

13. Pour le champ Sélectionnez une cible, choisissez Sélectionner. Ensuite, sur l'onglet Service,choisissez IoT Cloud, puis cliquez sur Suivant.

65

AWS Greengrass Guide de l'utilisateurDéploiement des configurations cloud sur un appareil Core

14. Dans le champ Filtre de rubrique facultatif, saisissez hello/world, puis cliquez sur Suivant.

15. Enfin, choisissez Finish (Terminer).

Déploiement des configurations cloud sur un appareilAWS Greengrass Core1. Assurez-vous que votre appareil Noyau AWS Greengrass est connecté à Internet (par exemple,

regardez si vous pouvez accéder à une page web).2. Assurez-vous que le démon AWS Greengrass est en cours d'exécution sur votre appareil principal.

Exécutez les commandes suivantes dans votre terminal principal.

a. Pour vérifier si le démon est en cours d'exécution :

ps aux | grep -E 'greengrass.*daemon'

66

AWS Greengrass Guide de l'utilisateurDéploiement des configurations cloud sur un appareil Core

Si la sortie contient une entrée root pour /greengrass/ggc/packages/1.5.0/bin/daemon,le démon est en cours d'exécution.

b. Pour démarrer le démon :


Maintenant, vous êtes prêt à déployer la fonction Lambda et les configurations d'abonnement sur votreappareil Noyau AWS Greengrass.

3. Dans la Console IoT AWS, sur la page de configuration de groupe, dans le menu Actions, choisissezDeploy (Déployer).

4. Sur la page Configuration du mode de détection de votre noyau par les appareils, choisissez Détectionautomatique. 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 estrecommandée, mais AWS Greengrass prend également en charge les points de terminaison spécifiésmanuellement. Vous êtes uniquement invité à indiquer la méthode de découverte lors du déploiementinitial du groupe.

5. Si vous y êtes invité, choisissez Grant permission (Accorder l'autorisation) sur la page Grantpermission to access other services (Autorisation d'accès à d'autres services). Cela crée le rôle deservice Greengrass, ce qui permet à AWS Greengrass d'accéder à d'autres services AWS en votrenom. Ce rôle est obligatoire pour que les déploiements réussissent. Cette opération ne doit êtreeffectuée qu'une seule fois par compte.

Le premier déploiement peut durer quelques minutes. Une fois le déploiement terminé, vous devriez voir lemessage Successfully completed (Terminé avec succès) s'afficher dans la colonne Status (État) de la pageDeployments (Déploiements) :

67

AWS Greengrass Guide de l'utilisateurVérification de l'exécution de lafonction Lambda sur l'appareil

Pour obtenir une aide pour résoudre les problèmes que vous pouvez rencontrer, consultez Résolution desproblèmes des applications AWS Greengrass (p. 205).

Vérification de l'exécution de la fonction Lambda surl'appareilDans le volet de gauche de la Console IoT AWS, choisissez Test.

68


Dans le champ Subscription topic (Rubrique d'abonnement), saisissez hello/world (ne choisissezpas encore Subscribe to topic (S'abonner à la rubrique)). Pour Qualité de service, sélectionnez 0. PourAffichage de la charge utile MQTT, sélectionnez Afficher les charges utiles sous forme de chaînes (plus deprécision).

69


Choisissez ensuite S'abonner à la rubrique.

Si la fonction Lambda est en cours d'exécution sur votre appareil, elle publiera dans la rubrique hello/worlddes messages semblables à ce qui suit :

70

AWS Greengrass Guide de l'utilisateurModule 3 (Partie 2) : FonctionsLambda sur AWS Greengrass

Note

Même si la fonction Lambda s'exécutant sur l'appareil Noyau AWS Greengrass continue d'envoyerdes messages MQTT à la rubrique hello/world dans le cloud AWS IoT, n'arrêtez pas le démonAWS Greengrass, car les modules restants présument qu'il est en cours d'exécution.

Module 3 (Partie 2) : Fonctions Lambda sur AWSGreengrass

Ce module vous explique comment configurer une fonction Lambda et la déployer sur votre appareil NoyauAWS Greengrass. Il contient des informations sur les déploiements, les abonnements et la messagerieMQTT sur AWS Greengrass, ainsi que les configurations des fonctions Lambda.

La Partie 1 (p. 53) de ce module décrivait comment déployer une fonction Lambda sur un appareilNoyau AWS Greengrass qui envoie des messages « Hello World » vers le cloud AWS Greengrass.Cette partie explore les différences entre les fonctions Lambda à la demande et longue durées'exécutant sur le Noyau AWS Greengrass. Avant de commencer, assurez-vous que vous avez terminéle Module 1 (p. 32), le Module 2 (p. 45)et le Module 3 (Partie 1) (p. 53). Le module dureapproximativement 30 minutes.

Création et empaquetage de la fonction Lambda1. Téléchargez le code de la fonction Lambda sur votre ordinateur (pas sur l'appareil principal

Greengrass), comme suit :

a. Dans un navigateur web, ouvrez le fichier greengrassHelloWorldCounter.py sur GitHub.b. Choisissez Raw pour ouvrir la version du fichier non formatée.

c. Utilisez Ctrl + S (ou Commande + S pour le Mac) pour enregistrer une copie du fichiergreengrassHelloWorldCounter.py. Enregistrez le fichier dans un dossier qui contient ledossier greengrasssdk.

Note

Pour les systèmes UNIX, vous pouvez exécuter la commande terminal suivante pourtélécharger le fichier greengrassHelloWorldCounter.py :

sudo wget https://raw.githubusercontent.com/aws-samples/aws-greengrass-samples/master/hello-world-counter-python/greengrassHelloWorldCounter.py

2. Empaquetez le fichier greengrassHelloWorldCounter.py avec le kit SDK dansun fichier .zip, comme décrit dans Module 3 (Partie 1) (p. 53). Nommez le packagehello_world_counter_python_lambda.zip.

71

https://github.com/aws-samples/aws-greengrass-samples/blob/master/hello-world-counter-python/greengrassHelloWorldCounter.py

AWS Greengrass Guide de l'utilisateurCréation et empaquetage de la fonction Lambda

3. Dans la console Lambda, créez une fonction Python 2.7 nomméeGreengrass_HelloWorld_Counter, comme décrit dans le Module 3 (Partie 1) (p. 53). Vouspouvez utiliser le rôle existant.

4. Chargez votre package de déploiement de fonction Lambda comme suit :



• Dans Runtime, sélectionnez Python 2.7.• Dans Handler (Gestionnaire), saisissezgreengrassHelloWorldCounter.function_handler.

b. Choisissez Upload (Charger), puis hello_world_counter_python_lambda.zip.

c. Dans le haut de la page, choisissez Enregistrer.5. Publiez la première version de la fonction, comme suit :

a. Dans le menu Actions, sélectionnez Publish new version. Pour Version description (Description dela version), tapez Première version.

b. Choisissez Publish.6. Créez un alias pour la version de la fonction, comme suit :

a. Dans le menu Actions, choisissez Create alias (Créer un alias) et définissez les valeurs suivantes :

• Dans Name (Nom), saisissez GG_HW_Counter.• Dans Version, choisissez 1.

b. Sélectionnez Create.

72

AWS Greengrass Guide de l'utilisateurConfiguration de fonctions Lambda

longue durée pour AWS Greengrass

Souvenez-vous que les alias créent une seule entité pour votre fonction Lambda, à laquelle lesappareils AWS Greengrass peuvent s'abonner sans avoir à mettre à jour les abonnements avec desnuméros de version Lambda chaque fois que la fonction est modifiée.

Configuration de fonctions Lambda longue durée pourAWS GreengrassVous êtes maintenant prêt à configurer votre fonction Lambda pour AWS Greengrass.

1. Dans la Console IoT AWS, sousGreengrass, choisissez Groups (Groupes), puis choisissez le groupeque vous avez créé dans le Module 2 (p. 45).

2. Sur la page de configuration de groupe, choisissez Lambdas, puis Ajouter une expression lambda.3. Sur la page Ajouter une fonction Lambda au groupe Greengrass, choisissez Utiliser une fonction

Lambda existante.4. Sur la page Utiliser une page Lambda existante, choisissez Greengrass_HelloWorld_Counter, puis

choisissez Suivant.

5. Sur la page Sélectionner une version Lambda, choisissez Alias: GG_HW_Counter, puis sélectionnezTerminer.

6. Sur la page Lambdas, à partir du menu Greengrass_HelloWorld_Counter , choisissez EditConfiguration (Modifier une configuration).

73

AWS Greengrass Guide de l'utilisateurConfiguration de fonctions Lambda

longue durée pour AWS Greengrass

7. Sur la page de configuration, modifiez les propriétés suivantes :

• Dans Timeout (Délai d'expiration), définissez le délai sur 25 secondes. La fonction Lambda passe enveille pendant 20 secondes avant chaque appel.

• Sous Cycle de vie Lambda, sélectionnez Attribuer une longue durée de vie à cette fonction etl'exécuter indéfiniment.

8. Sélectionnez Update.

74

AWS Greengrass Guide de l'utilisateurTest des fonctions Lambda longue durée

Test des fonctions Lambda longue duréeUne fonction Lambda longue durée démarre automatiquement lorsque le Noyau AWS Greengrass démarreet s'exécute dans un seul conteneur (ou sandbox). Les variables ou le prétraitement définis en dehorsdu gestionnaire de fonctions sont conservés pour chaque appel du gestionnaire de fonctions. Plusieursappels du gestionnaire de fonctions sont placés en file d'attente jusqu'à ce que les appels antérieurs aientété exécutés. La fonction Lambda greengrassHelloWorldCounter.py est semblable à la fonctiongreengrassHelloWorld.py, à l'exception qu'il y a une variable, my_counter, laquelle est à l'extérieurde la méthode function_handler(event, context) (les commentaires de code ont été suppriméspar souci de concision) :

import greengrasssdkimport platformimport timeimport json

client = greengrasssdk.client('iot-data')

my_platform = platform.platform()

my_counter = 0

def function_handler(event, context): global my_counter my_counter = my_counter + 1 if not my_platform: client.publish( topic='hello/world/counter', payload=json.dumps({'message': 'Hello world! Sent from Greengrass Core. Invocation Count: {}'.format(my_counter)}) ) else: client.publish( topic='hello/world/counter', payload=json.dumps({'message': 'Hello world! Sent from Greengrass Core running on platform: {}. Invocation Count: {}' .format(my_platform, my_counter)}) ) time.sleep(20) return

1. Sur la page de configuration de groupe, choisissez Abonnements, puis Ajouter unabonnement. Sous Sélectionnez une source, choisissez l'onglet Lambdas, puis choisissezGreengrass_HelloWorld_Counter. Ensuite, sous Sélectionner une cible, choisissez l'onglet Services,choisissez Cloud IoT, puis choisissez Suivant.

75


Pour Filtre de rubrique facultatif, saisissez hello/world/counter. Cliquez sur Suivant, puis surTerminer.

Cet unique abonnement va dans une seule direction : de la fonction LambdaGreengrass_HelloWorld_Counter vers le cloud AWS IoT. Pour déclencher cette fonction Lambdadepuis le cloud, vous avez besoin de créer un abonnement dans le sens inverse.

2. Ajoutez un autre abonnement avec IoT Cloud comme source et Greengrass_HelloWorld_Countercomme cible. Utilisez la rubrique hello/world/counter/trigger:

76


Notez l'extension /trigger ci-dessus : étant donné que vous avez créé deux abonnements, vous nesouhaitez pas qu'ils interfèrent l'un avec l'autre.

3. Assurez-vous que le démon AWS Greengrass est en cours d'exécution comme décrit dansDéploiement des configurations cloud sur un appareil Core (p. 66).

Notez que lorsque le démon est en cours d'exécution, la fonction LambdagreengrassHelloWorld.py précédente continuera d'envoyer des messages à la rubrique hello/world (dans le cloud AWS IoT). Toutefois, cela n'interfère pas avec les messages envoyés à partir dela fonction Lambda greengrassHelloWorldCounter.py vers le cloud AWS IoT, car ils sont dirigésvers une autre rubrique, à savoir hello/world/counter.

4. Sur la page de configuration de groupe, depuis le menu Actions, choisissez Déployer pour déployer laconfiguration de groupe mise à jour vers votre appareil Noyau AWS Greengrass.

Pour obtenir une aide pour résoudre les problèmes que vous pouvez rencontrer, consultez Résolutiondes problèmes des applications AWS Greengrass (p. 205).

5. Une fois que votre déploiement est terminé, dans la Console IoT AWS, choisissez Test. Dans rubriqueabonnement, saisissez hello/world/counter. Pour Qualité de service, sélectionnez 0. PourAffichage de la charge utile MQTT, sélectionnez Afficher les charges utiles sous forme de chaînes,puis choisissez S'abonner à la rubrique.

77


Contrairement à la Partie 1 (p. 53) de ce module, vous devriez ne pas être en mesure deconsulter les messages après vous être abonné à hello/world/counter. La raison en estque le code greengrassHelloWorldCounter.py à publier dans la rubrique hello/world/counter se trouve à l'intérieur de la fonction function_handler(event, context) et quefunction_handler(event, context) est déclenché uniquement quand il reçoit un messageMQTT sur la rubrique hello/world/counter/trigger. Pour vous aider à mieux comprendre cela,examinez les abonnements connexes greengrass_HelloWorld_Counter :

Sur la deuxième ligne, nous constatons que la fonction Lambdagreengrass_HelloWorld_Counter peut envoyer des messages au cloud IoT sur la rubriquehello/world/counter. Sur la troisième ligne, nous constatons que le cloud IoT peut envoyerdes messages à la fonction Lambda greengrass_HelloWorld_Counter lorsque ce message estenvoyé à la rubrique hello/world/counter/trigger (notez que le mot trigger n'a aucunecaractéristique particulière). La fonction Lambda greengrass_HelloWorld_Counter ignore cesmessages envoyés et exécute simplement le code dans function_handler(event, context),qui renvoie un message à la rubrique hello/world/counter dans le cloud AWS IoT (consultez laliste de codes greengrassHelloWorldCounter.py précédente).

78


Ainsi, pour déclencher le gestionnaire function_handler(event, context), publiez un message(vous pouvez utiliser le message par défaut) dans la rubrique hello/world/counter/trigger,comme indiqué plus bas.

Chaque fois qu'un message est publié dans la rubrique hello/world/counter/trigger, lavariable my_counter est incrémentée (voir Invocation Count ci-dessous). Comme le gestionnairede la fonction Lambda inclut un cycle de sommeil de 20 secondes (à savoir time.sleep(20)), ledéclenchement répété du gestionnaire place les réponses en file d'attente depuis le Noyau AWSGreengrass.

79

AWS Greengrass Guide de l'utilisateurTest des fonctions Lambda à la demande

Test des fonctions Lambda à la demandeUne fonction Lambda à la demande est similaire en termes de fonctionnalité à une fonction Lambda ducloud AWS. Plusieurs appels d'une fonction Lambda à la demande peuvent être exécutés en parallèle.Un appel de la fonction Lambda crée un conteneur séparé pour traiter les appels ou réutilise un conteneurexistant si les ressources le permettent. Les variables ou le prétraitement définis en dehors du gestionnairede fonctions ne sont pas conservés quand de nouveaux conteneurs sont créés. Pour plus d'informations,consultez the section called “Configuration de cycle de vie” (p. 131).

1. Sur la page de configuration de groupe, choisissez Lambdas. Pour la fonction LambdaGreengrass_HelloWorld_Counter, choisissez Modifier la configuration.

2. Sous Cycle de vie Lambda, sélectionnez Fonction à la demande.

Choisissez ensuite Mettre à jour.3. Sur la page de configuration de groupe, depuis le menu Actions, choisissez Déployer pour déployer la

configuration de groupe mise à jour vers votre appareil Noyau AWS Greengrass.

80


4. Une fois que votre déploiement est terminé, dans la Console IoT AWS, choisissez Test. Pour rubriqueabonnement, saisissez hello/world/counter. Pour Qualité de service, sélectionnez 0. PourAffichage de la charge utile MQTT, sélectionnez Afficher les charges utiles sous forme de chaînes,puis choisissez S'abonner à la rubrique.

Une fois encore, vous ne serez pas en mesure de consulter les messages après vous être abonné.Déclenchez la fonction sur la rubrique hello/world/counter/trigger en envoyant un message (vouspouvez utiliser le message par défaut), puis cliquez trois fois de suite sur Publier dans la rubrique, enne dépassant pas cinq secondes entre chaque clic.

81


Chaque publication déclenche le gestionnaire de fonctions et crée un conteneur pour chaque appel. Lenombre d'appels n'est pas incrémenté pour chacune des trois fois où vous avez déclenché la fonction,car chaque fonction Lambda à la demande possède son propre conteneur/sandbox.

Attendez environ 30 secondes ou plus, puis choisissez Publier dans la rubrique. Cette fois, vousdevriez voir une incrémentation du nombre d'appels.

82

AWS Greengrass Guide de l'utilisateurModule 4 : Interaction avec les appareils

dans un groupe AWS Greengrass

Cela montre qu'un conteneur, d'abord créé à partir d'un appel antérieur, est en train d'être réutilisé, etque les variables de prétraitement en dehors du gestionnaire de fonctions ont été stockées.

Vous devez maintenant comprendre les deux types de fonctions Lambda qui peuvent s'exécuter surle Noyau AWS Greengrass. Le module suivant, le Module 4 (p. 83), vous montre comment lesappareils peuvent interagir au sein d'un Groupe AWS Greengrass.

Module 4 : Interaction avec les appareils dans ungroupe AWS Greengrass

Ce module vous montre comment les appareils AWS IoT peuvent se connecter et communiquer avec unappareil Noyau AWS Greengrass. Les appareils AWS IoT qui se connectent à un Noyau AWS Greengrassfont partie d'un Groupe AWS Greengrass et peuvent participer au paradigme de programmation AWSGreengrass. Dans ce module, un Appareil AWS Greengrass envoie un message « Hello World » à un autreAppareil AWS Greengrass au sein du groupe Groupe AWS Greengrass :

83

AWS Greengrass Guide de l'utilisateurCréation d'appareils AWS IoT


Avant de commencer, assurez-vous que vous avez terminé le Module 1 (p. 32), le Module 2 (p. 45),le Module 3 (Partie 1) (p. 53) et le Module 3 (Partie 2) (p. 71). Vous n'avez pas besoin d'autrescomposants ou appareils. Le module dure approximativement 30 minutes.

Création d'appareils AWS IoT dans un groupe AWSGreengrass1. Dans la Console IoT AWS, choisissez Greengrass, puis Groupes et sélectionnez votre groupe pour

ouvrir sa page de configuration. Ensuite, choisissez Appareils, puis Ajouter votre premier appareil.

84



Choisissez Créer un appareil :

Inscrivez cet appareil comme HelloWorld_Publisher, puis choisissez Next (Suivant) :

85



Pour 1-Click, choisissez Use Defaults (Utiliser les valeurs par défaut) :

Créez un dossier sur votre ordinateur.

Téléchargez les certificats pour votre appareil dans le dossier, puis décompressez-les (pourdécompresser les fichiers tar.gz sous Windows, consultez l'onglet Windows à l'étape 2 de Créationet empaquetage d'une fonction Lambda (p. 53)).

86



Notez le composant de nom de fichier de type GUID courant pour l'appareil HelloWorld_Publisher(dans cet exemple, 51d2737e90), car il sera nécessaire ultérieurement. Enfin, choisissez Finish(Terminer).

2. En choisissant Ajouter un appareil, répétez l'étape 1 pour ajouter un autre appareil au groupe etnommez-le HelloWorld_Subscriber. Téléchargez également les certificats de votre deuxièmeappareil sur votre ordinateur, en les enregistrant dans le même dossier que le premier ensemble decertificats. Choisissez Finish. Là encore, notez le composant de nom de fichier de type GUID courantpour l'appareil HelloWorld_Subscriber.

Vous devez avoir maintenant deux appareils dans votre Groupe AWS Greengrass :

3. Téléchargez un autre certificat racine AWS IoT depuis Symantec et enregistrez-le sous root-ca-cert.pem dans le dossier que vous venez de créer. Dans le cadre de ce module, ce certificat,ainsi que les certificats et les clés des deux appareils, doivent être dans un même dossier de votreordinateur (pas sur l'appareil Noyau AWS Greengrass).

87


AWS Greengrass Guide de l'utilisateurConfiguration des abonnements

Note

Si vous utilisez un navigateur web sur le Mac et que vous recevez une alerte de type Cecertificat est déjà installé en tant qu'autorité de certification, vous pouvez ouvrir une fenêtre determinal et exécuter les commandes suivantes pour télécharger le certificat dans le dossiercontenant les certificats/clés des appareils HelloWorld_Publisher et HelloWorld_Subscriber :

cd path-to-folder-containing-device-certificatescurl -o ./root-ca-cert.pem http://www.symantec.com/content/en/us/enterprise/verisign/roots/VeriSign-Class%203-Public-Primary-Certification-Authority-G5.pem

Exécutez cat root-ca-cert.pem pour vous assurer que le fichier n'est pas vide. Si c'estle cas, vérifiez l'URL et essayez à nouveau d'exécuter la commande curl.

Configuration des abonnementsDans cette étape, vous permettez à l'appareil HelloWorld_Publisher d'envoyer un message HelloWorld àl'appareil HelloWorld_Subscriber.

1. Sur la page de configuration de groupe, choisissez Abonnements, puis choisissez Ajouterun abonnement. Pour Sélectionnez une source, choisissez Sélectionner, Appareils etHelloWorld_Publisher. De même, pour Sélectionnez une cible, choisissez HelloWorld_Subscriber.Enfin, cliquez sur Suivant :

Pour Filtre de rubrique facultatif, saisissez hello/world/pubsub :

88

AWS Greengrass Guide de l'utilisateurInstallation du kit Kit SDK des

appareils AWS IoT pour Python

Ensuite, cliquez sur Suivant, puis sur Terminer.Note

Vous pouvez supprimer les abonnements des modules précédents. Pour ce faire, choisissezSubscriptions (Abonnements), sélectionnez les points de suspension (...) associés à unabonnement, puis cliquez sur Delete (Supprimer).


3. Sur la page de configuration de groupe, depuis le menu Actions, choisissez Déployer pour déployer laconfiguration de groupe mise à jour vers votre appareil Noyau AWS Greengrass :

Pour confirmer la réussite d'un déploiement, choisissez Deployments (Déploiements) ; un messageSuccessfully completed (Terminé avec succès) doit s'afficher en regard de l'heure à laquelle vous avezlancé le déploiement.


Installation du kit Kit SDK des appareils AWS IoT pourPythonLe Kit SDK des appareils AWS IoT pour Python peut être utilisé par tous les appareils AWS IoT pourcommuniquer avec le cloud AWS IoT et les appareils Noyau AWS Greengrass (à l'aide du langage deprogrammation Python). Notez que le kit SDK nécessite la version 2.7+ de Python 2 ou la version 3.3+ dePython 3. En outre, le kit SDK nécessite la version 1.0.1+ de OpenSSL (TLS version 1.2) compilée avec lefichier exécutable Python.

Pour installer le kit SDK sur votre ordinateur, avec tous les composants nécessaires, choisissez l'ongletapproprié :

Windows

1. Ouvrez une invite de commande de niveau élevé et exécutez la commande suivante :

python --version

Si aucune information de version n'est renvoyée ou si le numéro de version est inférieur à 2.7 pourPython 2 ou à 3.3 pour Python 3, installez Python 2.7+ ou Python 3.3+ en suivant les instructionsindiquées à la page Downloading Python. Pour en savoir plus, consultez la section Utiliser Pythonsur Windows (notez le menu déroulant de numéros de version Python).

2. À l'aide d'un navigateur web, téléchargez le fichier zip Kit SDK des appareils AWS IoT pourPython et enregistrez-le en tant que aws-iot-device-sdk-python-latest.zip (il doit s'agir

89

https://technet.microsoft.com/en-us/library/cc947813(v=ws.10).aspx

https://wiki.python.org/moin/BeginnersGuide/Download

https://docs.python.org/3.6/using/windows.html

https://docs.python.org/3.6/using/windows.html

https://s3.amazonaws.com/aws-iot-device-sdk-python/aws-iot-device-sdk-python-latest.zip



du nom par défaut). Le fichier zip est généralement enregistré dans votre dossier Downloads.Décompressez le fichier aws-iot-device-sdk-python-latest.zip à un emplacementapproprié, comme votre répertoire de base (c-à-d. cd %HOME%). Notez le chemin d'accès audossier aws-iot-device-sdk-python-latest décompressé. À l'étape suivante, ce chemind'accès sera indiqué par path-to-SDK-folder.

3. À partir d'une invite de commande de niveau élevé, exécutez la commande suivante :

cd path-to-SDK-folderpython setup.py install

macOS

1. Ouvrez une fenêtre de terminal et exécutez la commande suivante :

python --version

Si aucune information de version n'est renvoyée ou si le numéro de version est antérieur à2.7 pour Python 2 ou à 3.3 pour Python 3, installez Python 2.7+ ou Python 3.3+ en suivant lesinstructions indiquées à la page Downloading Python. Pour en savoir plus, consultez la sectionUtilisation de Python sur un Macintosh (notez le menu déroulant de numéros de version Python).

2. Dans la fenêtre de terminal, exécutez les commandes suivantes pour déterminer la versionOpenSSL :

python>>> import ssl>>> print ssl.OPENSSL_VERSION

Notez la version OpenSSL.

Note

Utilisez print(ssl.OPENSSL_VERSION) si vous exécutez Python 3.

Pour fermer le shell Python, exécutez la commande suivante :

>>> exit()

Si la version OpenSSL est postérieure à 1.0.1, passez directement à l'étape 3. Sinon, procédezcomme suit :

• Depuis la fenêtre de terminal, exécutez la commande suivante afin de déterminer sil'ordinateur utilise Simple Python Version Management :

which pyenv

Si un chemin d'accès est renvoyé, choisissez l'onglet Using (Utilise) pyenv. Si aucun chemin n'estrenvoyé, choisissez l'onglet Not using (N'utilise pas) pyenv.

Utilise pyenv

1. Consultez la page des versions Python pour Mac OS X (ou similaire) pour déterminer laversion stable de Python la plus récente. Dans ce qui suit, cette valeur est indiquée en tantque latest-Python-version.

90


https://docs.python.org/3/using/mac.html

https://www.python.org/downloads/mac-osx/



2. À partir de la fenêtre de terminal, exécutez les commandes suivantes :

pyenv install latest-Python-versionpyenv global latest-Python-version

Par exemple, si la version la plus récente de Python 2 est 2.7.14, ces commandes sont lessuivantes :

pyenv install 2.7.14pyenv global 2.7.14

3. Fermez la fenêtre de terminal, puis ouvrez-la à nouveau.4. Dans la fenêtre de terminal rouverte, exécutez les commandes suivantes :


La version OpenSSL doit être au minimum 1.0.1. Si elle est antérieure à 1.0.1, c'est que lamise à jour a échoué ; vérifiez la version de Python utilisée dans les commandes pyenvinstall et pyenv global précédentes et réessayez.

5. Pour quitter le shell Python, exécutez la commande suivante :

>>> exit()

N'utilise pas pyenv

1. À partir d'une fenêtre de terminal, exécutez la commande suivante pour déterminer si brewest installé :

which brew

Si aucun chemin d'accès n'est renvoyé, installez brew comme suit :

/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

Note

Suivez les instructions d'installation et sachez que le téléchargement des outils deligne de commande Xcode peut prendre un certain temps.

2. Exécutez les commandes suivantes :

brew updatebrew install opensslbrew install python@2

N'oubliez pas que le Kit SDK des appareils AWS IoT pour Python nécessite la versionOpenSSL 1.0.1 (ou ultérieure) compilée avec le fichier exécutable Python. La commandebrew install python précédente installe un fichier exécutable python2 qui répondà cette exigence. Le fichier exécutable python2 est installé dans le répertoire /usr/local/bin, qui doit faire partie de la variable d'environnement PATH. Pour confirmer cela,exécutez la commande suivante :

91

https://brew.sh/



python2 --version

Si des informations sur la version python2 sont fournies, passez directement à l'étapesuivante. Dans le cas contraire, ajoutez de façon définitive le chemin /usr/local/bin àvotre variable d'environnement PATH en ajoutant la ligne suivante à votre profil shell :

export PATH="/usr/local/bin:$PATH"

Par exemple, si vous utilisez .bash_profile ou si vous ne possédez pas encore de profilshell, exécutez la commande suivante à partir d'une fenêtre de terminal :

echo 'export PATH="/usr/local/bin:$PATH"' >> ~/.bash_profile

Ensuite, définissez la source de votre profil shell et confirmez que les informationsde version sont fournies par python2 --version. Par exemple, si vous utilisez.bash_profile, exécutez les commandes suivantes :

source ~/.bash_profilepython2 --version

Les informations de version python2 doivent être renvoyées.3. Ajoutez la ligne suivante à votre profil shell :

alias python="python2"

Par exemple, si vous utilisez .bash_profile ou si vous ne possédez pas encore de profilshell, exécutez la commande suivante :

echo 'alias python="python2"' >> ~/.bash_profile

4. Ensuite, définissez la source de votre profil shell. Par exemple, si vous utilisez.bash_profile, exécutez la commande suivante :

source ~/.bash_profile

À présent, le fait d'appeler la commande python aura pour effet de lancer le fichierexécutable Python contenant la version OpenSSL requise (c-à-d. python2).

5. Exécutez les commandes suivantes :


La version OpenSSL doit être 1.0.1 ou une version ultérieure.6. Pour quitter le shell Python, exécutez la commande suivante :

>>> exit()

3. Exécutez les commandes suivantes pour installer le Kit SDK des appareils AWS IoT pour Python :

cd ~

92

https://en.wikipedia.org/wiki/Source_(command)

https://en.wikipedia.org/wiki/Source_(command)



git clone https://github.com/aws/aws-iot-device-sdk-python.gitcd aws-iot-device-sdk-pythonpython setup.py install

Système UNIX

1. À partir d'une fenêtre de terminal , exécutez la commande suivante :

python --version

Si aucune information de version n'est renvoyée ou si le numéro de version est antérieur à2.7 pour Python 2 ou à 3.3 pour Python 3, installez Python 2.7+ ou Python 3.3+ en suivant lesinstructions indiquées à la page Downloading Python. Pour en savoir plus, consultez la sectionUsing Python on Unix platforms (notez le menu déroulant de numéros de version Python).

2. Dans la fenêtre de terminal, exécutez les commandes suivantes pour déterminer la versionOpenSSL :


Notez la version OpenSSL.

Pour fermer le shell Python, exécutez la commande suivante :

>>> exit()

Si la version OpenSSL est postérieure à 1.0.1, passez directement à l'étape suivante. Dans le cascontraire, exécutez la ou les commande (s) pour mettre à jour OpenSSL pour votre distribution.Par exemple, sudo yum update openssl, sudo apt-get update, etc.

Confirmez que la version OpenSSL est bien 1.0.1 ou une version ultérieure en exécutant lescommandes suivantes :

python>>> import ssl>>> print ssl.OPENSSL_VERSION>>> exit()

3. Exécutez les commandes suivantes pour installer le Kit SDK des appareils AWS IoT pour Python :

cd ~git clone https://github.com/aws/aws-iot-device-sdk-python.gitcd aws-iot-device-sdk-pythonsudo python setup.py install

Une fois le Kit SDK des appareils AWS IoT pour Python installé, accédez au dossier samples du kit SDK,au dossier greengrass, puis copiez le fichier basicDiscovery.py dans le dossier contenant les fichiersdes certificats d'appareils HelloWorld_Publisher et HelloWorld_Subscriber, comme illustré dans l'exemplesuivant (les composants de noms de fichiers de type GUID diffèrent) :

93


https://docs.python.org/3.6/using/unix.html

https://en.wikipedia.org/wiki/Universally_unique_identifier

AWS Greengrass Guide de l'utilisateurTest des communications

Test des communications1. Assurez-vous que votre ordinateur et l'appareil Noyau AWS Greengrass sont connectés à Internet et

utilisent le même réseau. La procédure suivante peut être utilisée pour le confirmer :

a. Déterminez l'adresse IP du Noyau AWS Greengrass en exécutant la commande suivante :

hostname -I

b. Depuis votre ordinateur, exécutez la commande suivante à l'aide de l'adresse IP du noyau (vouspouvez utiliser Ctrl + C pour interrompre la commande ping) :

ping IP-address

Une sortie similaire à la suivante indique que la communication a abouti entre l'ordinateur etl'appareil Noyau AWS Greengrass (notez la perte de paquets égale à 0 %) :

2. À partir de la Console IoT AWS, choisissez Paramètres et notez la valeur du Point de terminaison :

94


Ci-dessous, la valeur du point de terminaison est indiquée par AWS_IOT_ENDPOINT.3. Choisissez Greengrass, Groupes, puis sélectionnez votre groupe. Choisissez Paramètres,

sélectionnez Gérer manuellement les informations de connexion, puis choisissez Afficher lesinformations de points de terminaison spécifiques pour les noyaux. Choisissez votre noyau, puisConnectivité. Choisissez Modifier et vérifiez que vous ne disposez que d'une seule valeur dans lechamp Point de terminaison, qui doit être l'adresse IP de votre appareil Noyau AWS Greengrass (pourle port 8883). Sélectionnez Update. Cela garantit que le script basicDiscovery.py se connectera àl'adresse IP appropriée de l'appareil Noyau AWS Greengrass.

4. Ouvrez deux fenêtres de ligne de commande sur votre ordinateur (et non sur l'appareilNoyau AWS Greengrass). Une fenêtre de ligne de commande sera utilisée pour l'appareilHelloWorld_Publisher et l'autre pour l'appareil HelloWorld_Subscriber. Chaque fois que le scriptsuivant (basicDiscovery.py) est exécuté pour la première fois, le service de découverte AWSGreengrass se connecte au Noyau AWS Greengrass. Une fois qu'un appareil a découvert le NoyauAWS Greengrass et réussi à s'y connecter, les futurs messages et opérations peuvent s'exécuterlocalement (sans avoir besoin d'une connexion Internet).

Note

Vous pouvez exécuter la commande suivante à partir du dossier contenant le fichierbasicDiscovery.py pour obtenir des informations détaillées sur l'utilisation du script :

python basicDiscovery.py --help

À partir de la fenêtre de l'appareil HelloWorld_Publisher, exécutez les commandes suivantes :

cd path-to-certs-folderpython basicDiscovery.py --endpoint AWS_IOT_ENDPOINT --rootCA root-ca-cert.pem --cert publisher.cert.pem --key publisher.private.key --thingName HelloWorld_Publisher --topic 'hello/world/pubsub' --mode publish --message 'Hello, World! Sent from HelloWorld_Publisher'

Vous devez visualiser des résultats similaires à ce qui suit :

95

https://en.wikipedia.org/wiki/Command-line_interface

AWS Greengrass Guide de l'utilisateurModule 5 : Interaction avec les Device Shadows

Note

Si vous obtenez un message sur les arguments non reconnus, essayez de remplacer lesapostrophes par des guillemets pour le paramètre message.

5. À partir de la fenêtre de l'appareil HelloWorld_Subscriber, exécutez les commandes suivantes :

cd path-to-certs-folderpython basicDiscovery.py --endpoint AWS_IOT_ENDPOINT --rootCA root-ca-cert.pem --cert subscriber.cert.pem --key subscriber.private.key --thingName HelloWorld_Subscriber --topic 'hello/world/pubsub' --mode subscribe

Vous devriez voir la sortie suivante:

Notez que la fermeture de la fenêtre HelloWorld_Publisher empêche l'accumulation de messagessupplémentaires dans la fenêtre HelloWorld_Subscriber.

Pour plus d'informations sur la dernière utilisation de basicDiscovery.py, consultez le fichier READMEdu kit Kit SDK des appareils AWS IoT pour Python.

Module 5 : Interaction avec les Device ShadowsCe module avancé vous montre comment les appareils AWS Greengrass peuvent interagir avec les deviceshadows AWS IoT dans un Groupe AWS Greengrass. Un shadow est un document JSON utilisé pourstocker les informations sur l'état actuel ou souhaité d'un objet. Dans ce module, vous allez découvrir lamanière dont un Appareil AWS Greengrass (GG_Switch) peut modifier l'état d'un autre Appareil AWSGreengrass (GG_TrafficLight), ainsi que la façon dont ces états peuvent être synchronisés avec lecloud AWS Greengrass :

96

https://github.com/aws/aws-iot-device-sdk-python

http://docs.aws.amazon.com/iot/latest/developerguide/iot-device-shadows.html

http://docs.aws.amazon.com/iot/latest/developerguide/iot-device-shadows.html

AWS Greengrass Guide de l'utilisateurConfiguration des appareils et des abonnements

Avant de commencer, assurez-vous que vous avez terminé le Module 1 (p. 32), le Module 2 (p. 45),le Module 3 (Partie 1) (p. 53) et le Module 3 (Partie 2) (p. 71). Vous devez également comprendrecomment connecter les appareils à un Noyau AWS Greengrass (Module 4 (p. 83)). Vous n'avez pasbesoin d'autres composants ou appareils. Ce module dure environ 30 minutes.

Configuration des appareils et des abonnements1. Créez deux appareils dans votre Groupe AWS Greengrass, GG_Switch et GG_TrafficLight.

Utilisez les paramètres de sécurité par défaut.

97


Enregistrez les certificats pour les appareils sur votre ordinateur (notez le composant de nom defichier de type GUID pour les appareils GG_Switch et GG_TrafficLight, car vous en aurez besoinultérieurement). Vous pouvez réutiliser la CA racine précédente de VeriSign ou en télécharger unenouvelle.

Maintenant, chaque shadow peut être synchronisé avec AWS IoT lorsque l'appareil Noyau AWSGreengrass est connecté à Internet. Tout d'abord, vous allez utiliser les shadows locaux sans lessynchroniser avec le cloud. Ultérieurement dans le module, vous activerez la synchronisation. Pardéfaut, la synchronisation du cloud doit être désactivée. Si elle n'est pas désactivée, sous Appareils,cliquez sur les points de suspension (…), puis choisissez Shadow local uniquement.

2. Choisissez Abonnements et créez les abonnements suivants pour votre groupe (pour plusd'informations sur le signe $, consultez Rubriques réservées). Par exemple, pour configurerl'abonnement à la première ligne, choisissez Ajouter un abonnement, pour Sélectionner unesource choisissez Sélectionner, sélectionnez l'onglet Appareils, puis choisissez GG_Switch. PourSélectionnez une cible, choisissez Sélectionner, puis Local Shadow Service, et enfin Suivant. PourFiltre de rubrique facultatif, saisissez (ou copiez/collez) $aws/things/GG_TrafficLight/shadow/update, choisissez Suivant, puis cliquez sur Terminer. En utilisant une procédure similaire, finalisezles abonnements restants :

Source Target Sujet Remarques

GG_Switch Service Shadow local $aws/things/GG_TrafficLight/shadow/update

GG_Switch envoie unedemande de mise àjour pour mettre à jourla rubrique.

Service Shadow local GG_Switch $aws/things/GG_TrafficLight/shadow/update/accepted

GG_Switch doit savoirsi la demande de miseà jour a été acceptéeou rejetée.

Service Shadow local GG_Switch $aws/things/GG_TrafficLight/shadow/update/rejected


GG_TrafficLight Service Shadow local $aws/things/GG_TrafficLight/shadow/update

GG_TrafficLight envoieune mise à jour de sonétat à la rubrique demise à jour.

98

http://docs.aws.amazon.com/iot/latest/developerguide/topics.html#reserved-topics



Service Shadow local GG_TrafficLight $aws/things/GG_TrafficLight/shadow/update/delta

Le service shadowlocal envoie unemise à jour reçue àGG_TrafficLight via larubrique delta.

Service Shadow local GG_TrafficLight $aws/things/GG_TrafficLight/shadow/update/accepted

GG_TrafficLight doitsavoir si la demandede mise à jour deGG_Switch a étéacceptée ou rejetée.

Service Shadow local GG_TrafficLight $aws/things/GG_TrafficLight/shadow/update/rejected


Note

Bien que vous puissiez utiliser des caractères génériques (par exemple, $aws/things/GG_TrafficLight/shadow/#) pour consolider certains abonnements, nous vousdéconseillons cette pratique.

Les chemins de rubrique doivent être écrits exactement comme indiqué dans le tableau. N'incluez pasun / supplémentaire à la fin d'une rubrique. Vous pouvez passer la souris sur un chemin de rubriquepour voir le chemin d'accès complet via une info-bulle contextuelle :

99

AWS Greengrass Guide de l'utilisateurTéléchargement des fichiers requis

Note

Chaque appareil dispose de son propre service shadow. Pour en savoir plus, consultezRubriques Shadow MQTT.




Téléchargement des fichiers requis1. Si vous ne l'avez pas déjà fait, installez le kit Kit SDK des appareils AWS IoT pour Python. Suivez

les instructions du fichier README. Le kit SDK est utilisé par tous les appareils AWS IoT pourcommuniquer avec le cloud AWS IoT et les cœurs AWS Greengrass.

2. À partir du référentiel Exemples AWS Greengrass sur GitHub, téléchargez les fichierslightController.py et trafficLight.py sur votre ordinateur, puis déplacez-les vers le dossiercontenant les certificats d'appareil GG_Switch et GG_TrafficLight :

Le script lightController.py correspond à l'appareil GG_Switch, tandis que le scripttrafficLight.py correspond à l'appareil GG_TrafficLight.

100

http://docs.aws.amazon.com/iot/latest/developerguide/device-shadow-mqtt.html

https://github.com/aws/aws-iot-device-sdk-python

https://github.com/aws-samples/aws-greengrass-samples/tree/master/traffic-light-example-python

AWS Greengrass Guide de l'utilisateurTest des communications (synchronisation

des appareils désactivée)

Test des communications (synchronisation desappareils désactivée)1. Ouvrez deux fenêtres de ligne de commande sur votre ordinateur (et non sur l'appareil Noyau AWS

Greengrass). Une fenêtre de ligne de commande est utilisée pour l'appareil GG_Switch et l'autrepour l'appareil GG_TrafficLight. Les deux scripts, lorsqu'ils sont exécutés pour la première fois,exécuteront le service de découverte AWS Greengrass pour se connecter au Noyau AWS Greengrass(via Internet). Une fois qu'un appareil a découvert le Noyau AWS Greengrass et réussi à s'y connecter,les futures opérations peuvent être exécutées localement. Avant d'exécuter les commandes suivantes,assurez-vous que votre ordinateur et le Noyau AWS Greengrass sont connectés à Internet à l'aide dumême réseau.

Pour la fenêtre de ligne de commande GG_Switch, exécutez la commande suivante :

cd path-to-certs-folderpython lightController.py --endpoint AWS_IOT_ENDPOINT --rootCA root-ca-cert.pem --cert switch.cert.pem --key switch.private.key --thingName GG_TrafficLight --clientId GG_Switch

Pour la fenêtre de ligne de commande GG_TrafficLight, exécutez la commande suivante :

cd path-to-certs-folderpython trafficLight.py --endpoint AWS_IOT_ENDPOINT --rootCA root-ca-cert.pem --cert light.cert.pem --key light.private.key --thingName GG_TrafficLight --clientId GG_TrafficLight

Note

Pour rechercher le point de terminaison à utiliser pour la valeur d'espace réservéAWS_IOT_ENDPOINT, ouvrez la Console IoT AWS et choisissez Settings (Paramètres).

Toutes les 20 secondes, le commutateur met à jour l'état du shadow sur V, J et R, et le feu affiche sonnouvel état, comme illustré ci-après.

Sortie GG_Switch :

Sortie de GG_TrafficLight :

2. Dans la Console IoT AWS, choisissez votre Groupe AWS Greengrass, Appareils, puisGG_TrafficLight :

101



(synchronisation des appareils activée)

Choisissez Shadow. Pour État du shadow, il ne devrait pas y avoir de mises à jour de cette rubriqueshadow après la modification d'état de GG_Switch, car GG_TrafficLight est défini sur SHADOWLOCAL UNIQUEMENT au lieu de SYNCHRONISATION DU SHADOW AVEC LE CLOUD, commeindiqué dans la section suivante.

3. Appuyez sur Ctrl + C dans la fenêtre de ligne de commande GG_Switch (lightController.py).Vous remarquerez que la fenêtre GG_TrafficLight (trafficLight.py) cesse de recevoir desmessages de changement d'état.

Test des communications (synchronisation desappareils activée)1. Dans la Console IoT AWS, choisissez votre Groupe AWS Greengrass, sélectionnez Appareils, cliquez

sur les points de suspension de l'appareil GG_TrafficLight, puis choisissez Synchroniser sur le cloud :

Vous devez recevoir une notification selon laquelle le device shadow a été mis à jour.2. Dans la page Déploiements, déployez la configuration mise à jour sur votre appareil Noyau AWS

Greengrass.3. Répétez l'étape au cours de laquelle vous créez deux fenêtres de ligne de commande (p. 101).4. Dans la Console IoT AWS, choisissez votre Groupe AWS Greengrass, Appareils, GG_TrafficLight, puis

Shadow.

102

AWS Greengrass Guide de l'utilisateurModule 6 : Accès à Services de cloud AWS

Comme vous avez activé la synchronisation du shadow GG_TrafficLight sur AWS IoT, l'état du shadowdans le cloud doit être mis à jour automatiquement chaque fois que GG_Switch envoie une mise à jour.Cette fonctionnalité peut être utilisée pour exposer l'état d'un Appareil AWS Greengrass sur le cloudAWS IoT.

Note

Si nécessaire, vous pouvez résoudre les problèmes en affichant les journaux Noyau AWSGreengrass, notamment router.log :

cd /greengrass/ggc/var/logsudo cat system/router.log | more

Pour plus d'informations, consultez Résolution des problèmes des applications AWSGreengrass (p. 205).

Module 6 : Accès à Services de cloud AWSCe module avancé vous montre comment les cœurs AWS Greengrass peuvent interagir avecd'autres Amazon Web Services dans le cloud. Il repose sur l'exemple de feu rouge fourni dans leModule 5 (p. 96) et utilise une fonction Lambda supplémentaire qui traite les états du shadow ettélécharge un résumé sur la table Amazon DynamoDB du cloud.

103

AWS Greengrass Guide de l'utilisateurConfiguration des rôles IAM

Avant de commencer, assurez-vous d'avoir terminé la procédure décrite du Module 1 (p. 32) auModule 5 (p. 96). Vous n'avez pas besoin d'autres composants ou appareils. Ce module dure environ30 minutes.

Note

Ce module crée et met à jour une table dans DynamoDB (la plupart des opérations sont réduiteset relèvent de l'Niveau gratuit d'AWS). Pour en savoir plus, consultez la documentation detarification DynamoDB.

Configuration des rôles IAM1. Dans la mesure où vous créez une fonction Lambda qui accède à d'autres services AWS, vous avez

besoin de créer un rôle IAM qui a accès à la fois à DynamoDB et à AWS Greengrass. Pour en savoirplus sur IAM, consultez la documentation AWS Identity and Access Management.

Dans la console IAM, choisissez Rôles, puis Créer un rôle :

104

https://aws.amazon.com/dynamodb/pricing/

https://aws.amazon.com/dynamodb/pricing/

https://aws.amazon.com/documentation/iam/


Choisissez Service AWS, puis Greengrass :

105


Choisissez Next: Permissions.

Sur la page Attacher des stratégies d'autorisations, sélectionnez les stratégiessuivantes : AWSGreengrassResourceAccessRolePolicy, AWSGreengrassFullAccess etAmazonDynamoDBFullAccess.

Choisissez ensuite Next: Review. Pour Nom du rôle, saisissez Greengrass_DynamoDB_Role, puischoisissez Créer un rôle.

106


2. Répétez l'étape précédente pour créer le rôle pour le service AWS Lambda (au lieu du service AWSGreengrass). Accordez au rôle les mêmes stratégies (AWSGreengrassResourceAccessRolePolicy,AWSGreengrassFullAccess et AmazonDynamoDBFullAccess). Pour Nom du rôle, saisissezLambda_DynamoDB_Role.

3. Dans la Console IoT AWS, sous Greengrass, choisissez Groupes, puis sélectionnez votre groupeAWS Greengrass. Choisissez Paramètres, puis Ajouter un rôle :

Le rôle IAM que vous venez de créer doit apparaître dans la liste. Si tel n'est pas le cas, recherchez-le,sélectionnez-le, puis choisissez Enregistrer :

107

AWS Greengrass Guide de l'utilisateurCréation et configuration de la fonction Lambda

Création et configuration de la fonction LambdaAu cours de cette étape, vous allez créer une fonction Lambda qui effectue le suivi du nombre de voituresqui passent au feu. Chaque fois que l'état du shadow GG_TrafficLight devient G, la fonction Lambdasimule le passage d'un nombre aléatoire de véhicules (de 1 à 20). Tous les trois changements de feu G,la fonction Lambda envoie les statistiques de base, telles que le minimum et le maximum, à une tableDynamoDB.

1. Sur votre ordinateur, créez un dossier nommé car_aggregator.2. À partir du référentiel GitHub, téléchargez la fonction Lambda carAggregator.py dans le dossier

car_aggregator.3. Installez le package boto3 (kit SDK AWS pour Python) et ses dépendances dans le dossier

car_aggregator en exécutant la commande suivante dans une fenêtre de ligne de commande (pourWindows, utilisez une invite de commande élevée) :

pip install boto3 -t path-to-car_aggregator-folder

Vous obtenez une liste de répertoires similaire à la suivante :

108

https://github.com/aws-samples/aws-greengrass-samples/tree/master/traffic-light-example-python


https://technet.microsoft.com/en-us/library/cc947813(v=ws.10).aspx


Les fonctions Lambda Greengrass utilisent le kit SDK AWS pour accéder à d'autres Amazon WebServices. Pour plus d'informations, consultez Boto 3 - Kit SDK AWS pour Python.

4. Compressez le contenu du dossier car_aggregator en un fichier .zip nommécar_aggregator.zip. Il s'agit du package de déploiement de votre fonction Lambda.

5. Dans la console Lambda, créez une fonction nommée GG_Car_Aggregator et définissez les champssuivants ainsi :

• Dans Runtime, sélectionnez Python 2.7.• Dans Rôle, choisissez Sélectionner un rôle existant.• Dans Rôle existant, choisissez Rôle Lambda_DynamoDB_Role.

Puis, sélectionnez Create function (Créer une fonction).

109

https://github.com/boto/boto3/blob/develop/README.rst


6. Chargez votre package de déploiement de la fonction Lambda, comme suit :



• Dans Runtime, sélectionnez Python 2.7.• Dans Handler (Gestionnaire), saisissez carAggregator.function_handler.

b. Choisissez Upload (Charger), puis car_aggregator.zip.c. Choisissez Save.

110


7. Publiez la version de la fonction Lambda et créez un alias appelé GG_CarAggregator. Pour obtenirdes instructions détaillées, consultez les étapes Publier la fonction Lambda (p. 59) et Créer unalias (p. 59) du Module 3 (Partie 1).

8. Dans la Console IoT AWS, ajoutez la fonction Lambda que vous venez de créer pour votre GroupeAWS Greengrass, comme suit :

a. Sur la page de configuration de groupe, choisissez Lambdas, puis Ajouter une expressionlambda :

b. Choisissez Utiliser une fonction Lambda existante:

c. Choisissez GG_Car_Aggregator, puis choisissez Suivant :

111


d. Choisissez Alias: GG_CarAggregator, puis Terminer :

Note

Vous pouvez supprimer les autres fonctions Lambda de modules antérieurs.9. Modifiez la configuration de la fonction Lambda, comme suit :

a. Cliquez sur les points de suspension (…) associés à la fonction Lambda, puis choisissez Modifierla configuration :

b. Sous Cycle de vie Lambda, sélectionnez Attribuer une longue durée de vie à cette fonction etl'exécuter indéfiniment, puis choisissez Mettre à jour :

112


Configuration des abonnementsDans cette étape, vous créez un abonnement qui permet au shadow GG_TrafficLight d'envoyer les étatsmis à jour à la fonction Lambda GG_Car_Aggregator. Cet abonnement vient en plus des abonnements quevous avez créés dans le Module 5 (p. 96), et qui sont tous nécessaires pour ce module.

1. Sur la page de configuration de groupe, choisissez Abonnements, puis choisissez Ajouter unabonnement.

2. Sur la page Sélectionner la source et la cible, définissez les valeurs suivantes :

• Dans Sélectionner une source, choisissez Services, puis Service shadow local.• Dans Sélectionner une cible, choisissez Lambdas, puis GG_Car_Aggregator.

Choisissez Suivant.

113


3. Dans la page Filtrer les données avec une rubrique, pour Filtre de rubrique facultatif, tapez $aws/things/GG_TrafficLight/shadow/update/documents.

Cliquez sur Next , puis sur Finish.

Note

Sur la page Abonnements, la cible affiche les noms de la version de fonction et l'alias :GG_Car_Aggregator: GG_CarAggregator.

Le tableau suivant affiche la liste complète des abonnements obligatoires pour ce module. Le nouvelabonnement shadow s'affiche sur la dernière ligne du tableau. Vous avez créé les autres abonnementsdans le Module 5 (p. 96).

114



GG_Switch Service Shadow local $aws/things/GG_TrafficLight/shadow/update

GG_Switch envoie unedemande de mise àjour pour mettre à jourla rubrique.

Service Shadow local GG_Switch $aws/things/GG_TrafficLight/shadow/update/accepted


Service Shadow local GG_Switch $aws/things/GG_TrafficLight/shadow/update/rejected


GG_TrafficLight Service Shadow local $aws/things/GG_TrafficLight/shadow/update

GG_TrafficLight envoieune mise à jour de sonétat à la rubrique demise à jour.

Service Shadow local GG_TrafficLight $aws/things/GG_TrafficLight/shadow/update/delta

Le service shadowenvoie une miseà jour reçue àGG_TrafficLight via larubrique delta.

Service Shadow local GG_TrafficLight $aws/things/GG_TrafficLight/shadow/update/accepted


Service Shadow local GG_TrafficLight $aws/things/GG_TrafficLight/shadow/update/rejected


Service Shadow local GG_Car_Aggregator $aws/things/GG_TrafficLight/shadow/update/documents

Le shadowGG_TrafficLight envoieles états mis à jour à lafonction Lambda.

Note

À l'exception du Module 5 (p. 96), vous pouvez supprimer les abonnements des modulesprécédents qui ne sont pas inclus dans le tableau.




115


Test des communications1. Sur votre ordinateur, ouvrez deux fenêtres de ligne de commande. Comme dans le

Module 5 (p. 96), une fenêtre sera pour l'appareil GG_Switch et l'autre pour l'appareilGG_TrafficLight.

Note

Il s'agit des mêmes commandes que celles exécutées dans le Module 5.

Exécutez les commandes suivantes pour l'appareil GG_Switch :

cd path-to-certs-folderpython lightController.py --endpoint AWS_IOT_ENDPOINT --rootCA root-ca-cert.pem --cert switch.cert.pem --key switch.private.key --thingName GG_TrafficLight --clientId GG_Switch

Exécutez les commandes suivantes pour l'appareil GG_TrafficLight :

cd path-to-certs-folderpython trafficLight.py --endpoint AWS_IOT_ENDPOINT --rootCA root-ca-cert.pem --cert light.cert.pem --key light.private.key --thingName GG_TrafficLight --clientId GG_TrafficLight

Toutes les 20 secondes, le commutateur met à jour l'état du shadow sur G, J et R, et le feu affiche sonnouvel état.

2. À chaque troisième feu vert (toutes les 3 minutes), le gestionnaire de fonctions de la fonction Lambdaest déclenché et un nouvel enregistrement DynamoDB est créé. Une fois que lightController.pyet trafficLight.py ont été exécutés pendant trois minutes, accédez à AWS Management Console,puis recherchez et ouvrez la console DynamoDB. Assurez-vous que la région Virginie du Nord (us-east-1) est sélectionnée, puis choisissez Tables et choisissez la table CarStats. Choisissez ensuitel'onglet Items :

Vous devez voir les entrées avec les statistiques élémentaires sur les voitures passées (une entréetoutes les trois minutes). Vous devrez peut-être cliquer sur le bouton d'actualisation (deux flèchescirculaires) pour afficher les mises à jour de la table CarStats :

116



Note

Si nécessaire, vous pouvez résoudre les problèmes en affichant les journaux Noyau AWSGreengrass, notamment router.log :

cd /greengrass/ggc/var/logsudo cat system/router.log | more

Pour plus d'informations, consultez Résolution des problèmes des applications AWSGreengrass (p. 205).

Vous avez atteint la fin de ce didacticiel et vous devriez maintenant comprendre le modèle deprogrammation AWS Greengrass, et ses concepts fondamentaux, y compris les cœurs AWS Greengrass,les groupes, les abonnements et le processus de déploiement des fonctions Lambda s'exécutant à lapériphérie.

Vous pouvez supprimer la table DynamoDB supprimer les fonctions Lambda et arrêter les communicationsentre l'appareil Noyau AWS Greengrass et le cloud AWS IoT. Pour arrêter les communications, ouvrez unefenêtre de terminal sur l'appareil Noyau AWS Greengrass et exécutez l' une des commandes suivantes :

• Pour arrêter l'appareil Noyau AWS Greengrass :

117


sudo halt

• Pour arrêter le démon AWS Greengrass :

cd /greengrass/ggc/core/sudo ./greengrassd stop

118


Mises à jour OTA des principauxlogiciels AWS Greengrass

Cette fonction est disponible pour AWS Greengrass Core v1.3.0 ou version supérieure.

Le logiciel Noyau AWS Greengrass est fourni avec un agent de mise à jour OTA qui est capable d'installerla dernière version du logiciel du noyau ou de l'agent de mise à jour OTA. Vous pouvez lancer une mise àjour en appelant l'API CreateSoftwareUpdateJob ou via la console Greengrass. La mise à jour du logicielGreengrass Core présente les avantages suivants :

• Correction des vulnérabilités de sécurité• Prise en charge des problèmes de stabilité logicielle• Déploiement de nouvelles fonctionnalités ou de fonctionnalités améliorées

Avec une mise à jour OTA, vous pouvez bénéficier de tous ces avantages sans avoir à effectuermanuellement la mise à jour et sans que l'appareil qui exécute le logiciel du noyau ait à être physiquementprésent. L'agent de mise à jour OTA effectue également une restauration en cas d'échec de la mise à jour.L'exécution d'une mise à jour OTA est facultative, mais elle peut vous aider à gérer vos appareils NoyauAWS Greengrass. Recherchez les annonces de nouvelles versions du logiciel du noyau sur le forum desdéveloppeurs Greengrass.

Pour prendre en charge une mise à jour OTA du logiciel Greengrass Core à l'aide de l'agent de mise àjour OTA, l'appareil doté du noyau Greengrass doit :

• disposer d'un stockage local disponible trois fois supérieur à la quantité d'utilisation requise audémarrage du noyau ;

• ne pas avoir activé le démarrage de confiance dans la partition contenant la plate-forme du noyauGreengrass (Le Noyau AWS Greengrass peut être installé et s'exécuter sur une partition dans laquelle ledémarrage de confiance est activé, mais il ne peut pas effectuer de mise à jour OTA.)

• avoir des autorisations en lecture/écriture dans la partition contenant le logiciel de la plate-forme dunoyau Greengrass ;

• disposer d'une connexion au cloud AWS ;• disposer d'un Noyau AWS Greengrass correctement configuré et de certificats appropriés.

Avant de lancer une mise à jour OTA du logiciel Greengrass Core, il est important de noter l'impact qu'elleaura sur les appareils de votre groupe Greengrass, tant sur l'appareil principal que sur les appareils clientsconnectés localement à ce noyau :

• Le noyau sera arrêté pendant la mise à jour.• Toutes les fonctions Lambda s'exécutant sur le noyau seront arrêtées. Si ces fonctions procèdent à des

écritures dans des ressources locales, elles peuvent laisser ces ressources dans un état incorrect si ellesne sont pas fermées correctement.

• Pendant le temps d'arrêt du noyau, toutes ses connexions avec le cloud sont perdues et les messagesqui lui sont envoyés par des appareils clients sont perdus.

• Les caches des informations d'identification sont perdus.• Les files d'attente qui regroupent les travaux en attente des fonctions Lambda sont perdues.• Les fonctions Lambda longue durée perdent leurs informations d'état dynamique et tous les travaux en

attente sont supprimés.

119

AWS Greengrass Guide de l'utilisateurAgent OTA Greengrass

Les informations d'état suivantes sont conservées pendant une mise à jour OTA :

• Instances shadows locales• Journaux Greengrass• Journaux de l'agent OTA

Agent OTA GreengrassL'agent OTA Greengrass est le composant logiciel qui, sur l'appareil, gère les tâches de mise à jourcréées et déployées dans le cloud. Cet agent est distribué dans le même package logiciel que le logicielGreengrass Core. Il est situé dans ./greengrass/ota/ota_agent/ggc-ota et crée ses journaux /var/log/greengrass/ota/ggc_ota.txt.

Vous pouvez démarrer l'agent OTA Greengrass en exécutant le fichier binaire manuellement ou enl'intégrant dans le cadre d'un script init comme un fichier de service systemd. Le fichier binaire doit êtreexécuté en tant que root. Une fois démarré, l'agent OTA Greengrass commence à écouter les tâches demise à jour Greengrass du cloud et les exécute de manière séquentielle. L'agent OTA Greengrass IoTignore tous les autres types de travaux IoT.

Ne démarrez pas plusieurs instances de l'agent OTA, car cela peut entraîner des conflits.

Si votre noyau Greengrass ou l'agent OTA Greengrass est géré par un système init, reportez-vous à lasection relative à l'intégration aux systèmes d'initialisation (p. 122) pour les configurations connexes.

API CreateSoftwareUpdateJob

L'API CreateSoftwareUpdateJob crée une mise à jour logicielle pour un ou plusieurs noyaux. Cette APIpeut être utilisée pour mettre à jour l'agent OTA ainsi que le logiciel Greengrass Core. Elle s'appuie surla fonctionnalité de travaux de l'AWS IoT qui fournit des commandes supplémentaires pour gérer unetâche de mise à jour du logiciel Greengrass Core. Reportez-vous à Tâches pour plus d'informations sur lamanière de gérer une mise à jour Greengrass.

L'exemple suivant montre comment créer une tâche de mise à jour du logiciel Greengrass Core à l'aide del'interface de ligne de commande :

aws greengrass create-software-update-job \ --update-targets-architecture x86_64 \ --update-targets arn:aws:iot:us-east-1:123456789012:thing/myDevice \ --update-targets-operating-system ubuntu \ --software-to-update core \ --s3-url-signer-role arn:aws:iam::123456789012:role/IotS3UrlPresigningRole \ --update-agent-log-level WARN \ --amzn-client-token myClientToken1

La commande create-software-update-job renvoie un objet JSON contenant l'ID et l'ARN de la tâche :

{ "IotJobId": "Greengrass-OTA-c3bd7f36-ee80-4d42-8321-a1da0e5b1303", "IotJobArn": "arn:aws:iot:us-east-1:123456789012:job/Greengrass-OTA-c3bd7f36-ee80-4d42-8321-a1da0e5b1303"}

La commande create-software-update-job est paramétrée comme suit :

--update-targets-architecture

Architecture de l'appareil du noyau. Doit être armv7l, x86_64 ou aarch64.

120

http://docs.aws.amazon.com/iot/latest/developerguide/iot-jobs.html

AWS Greengrass Guide de l'utilisateurAgent OTA Greengrass

--update-targets

Liste des cibles auxquelles la mise à jour OTA doit être appliquée. Cette liste peut contenir l'ARNSdes objets, qui sont des noyaux, et les ARN de groupes d'objets dont les membres sont des noyaux.Reportez-vous à la section relative aux groupes d'objets IoT pour plus d'informations sur la façon deplacer des noyaux dans un groupe d'objets IoT.

--update-targets-operating-system

Système d'exploitation de l'appareil du noyau. Doit être ubuntu, amazon_linux ou raspbian.--software-to-update

Indique si le logiciel du noyau ou le logiciel de l'agent OTA doit être mis à jour. Doit être core ouota_agent.

--s3-url-signer-role

Rôle IAM qui est utilisé pour pré-signer l'URL S3 qui établit des liens vers la mise à jour du logicielGreengrass. Vous devez fournir un rôle qui est attaché à la stratégie appropriée. Voici un exemple dedocument de stratégie avec les autorisations minimales requises :

{ "Version": "2012-10-17", "Statement": [ { "Sid": "AllowsIotToAccessGreengrassOTAUpdateArtifacts", "Effect": "Allow", "Action": [ "s3:GetObject" ], "Resource": [ "arn:aws:s3:::eu-central-1-greengrass-updates/*", "arn:aws:s3:::us-east-1-greengrass-updates/*", "arn:aws:s3:::ap-northeast-1-greengrass-updates/*", "arn:aws:s3:::us-west-2-greengrass-updates/*", "arn:aws:s3:::ap-southeast-2-greengrass-updates/*" ] } ]}

Voici un exemple de document de stratégie Présumez le rôle avec les entités de confiance minimalesrequises :

{ "Version": "2012-10-17", "Statement": [ { "Action": "sts:AssumeRole", "Principal": { "Service": "iot.amazonaws.com" }, "Effect": "Allow", "Sid": "AllowIotToAssumeRole" } ]}

--amzn-client-token

[Facultatif] Jeton client utilisé pour effectuer des requêtes idempotent. Fournissez un jeton unique pourempêcher la création de mises à jour en double à la suite de tentatives internes.

121

http://docs.aws.amazon.com/iot/latest/developerguide/thing-groups.html

AWS Greengrass Guide de l'utilisateurIntégration à des systèmes d'initialisation

--update-agent-log-level

[Facultatif] Niveau de consignation des instructions de journalisation générées par l'agent OTA. Doitêtre NONE, TRACE, DEBUG, VERBOSE, INFO, WARN, ERROR ou FATAL. La valeur par défaut est ERROR.

Voici un exemple de stratégie IAM avec les autorisations minimales requises pour appeler l'API :

{ "Version": "2012-10-17", "Statement": [ { "Sid": "AllowCreateSoftwareUpdateJob", "Action": [ "greengrass:CreateSoftwareUpdateJob" ], "Effect": "Allow", "Resource": "*" }, { "Effect": "Allow", "Action": [ "iam:PassRole" ], "Resource": "arn:aws:s3:us-east-1:123456789012:role/IotS3UrlPresigningRole" }, { "Effect": "Allow", "Action": [ "iot:CreateJob" ], "Resource": "*" } ]}

Note

Dans la mesure où Greengrass est uniquement pris en charge sur un sous-ensembledes combinaisons possibles architecture/système d'exploitation avec cette commande,CreateSoftwareUpdateJob rejettera des requêtes excepté pour les plateformes prises encharge suivantes :

• ubuntu/x86_64• ubuntu/aarch64• amazon_linux/x86_64• raspbian/armv7l

Intégration à des systèmes d'initialisationPendant une mise à jour OTA, les fichiers binaires, dont certains d'entre eux peuvent être exécutés, sontmis à jour et redémarrés. Cela peut entraîner des conflits si un système d'initialisation surveille l'état dulogiciel Noyau AWS Greengrass ou l'agent OTA Greengrass pendant la mise à jour. Pour vous aiderà intégrer le mécanisme de mise à jour OTA avec vos stratégies de surveillance, Greengrass permetd'exécuter des scripts shell définis par l'utilisateur avant et après une mise à jour. Pour ordonner àl'agent OTA d'exécuter ces scripts, vous devez inclure l'indicateur managedRespawn = true dans lefichier ./greengrass/config/config.json. Exemples :

122

AWS Greengrass Guide de l'utilisateurMise à jour automatique OTA

avec commande Respawn gérée

{

"coreThing": { … }, "runtime": { … }, "managedRespawn": true

}

Lorsque l'indicateur managedRespawn est défini, les scripts doivent être installés dans le répertoire fautede quoi la mise à jour par l'agent OTA échoue. L'arborescence doit se présenter à ce qui suit :

<greengrass_root>|-- certs|-- config| |-- config.json|-- ggc|-- usr/scripts| |-- ggc_pre_update.sh| |-- ggc_post_update.sh| |-- ota_pre_update.sh| |-- ota_post_update.sh|-- ota

Mise à jour automatique OTA avec commandeRespawn géréeLorsque l'agent OTA se prépare à effectuer une mise à jour automatique, si l'indicateur managedRespawnest défini sur true, l'agent recherche le script ota_pre_update.sh dans le répertoire ./greengrass/usr/scripts et l'exécute.

Une fois que l'agent OTA a terminé la mise à jour, il tente d'exécuter le script ota_post_update.sh àpartir du répertoire ./greengrass/usr/scripts.

Mise à jour de AWS Greengrass Core aveccommande Respawn géréeLorsque l'agent OTA se prépare à effectuer une mise à jour automatique de Noyau AWS Greengrass, sil'indicateur managedRespawn est défini sur true, l'agent recherche le script ggc_pre_update.sh dansle répertoire ./greengrass/usr/scripts et l'exécute.

Une fois que l'agent OTA a terminé la mise à jour, il tente d'exécuter le script ggc_post_update.sh àpartir du répertoire ./greengrass/usr/scripts.

Remarque:

• Les scripts définis par l'utilisateur dans ./greengrass/usr/scripts doivent être détenus par root etêtre exécutables par root uniquement.

• Si managedRespawn est défini sur true, les scripts doivent exister et renvoyer un code de retourRéussi.

• Si managedRespawn est défini sur false, les scripts ne sont pas exécutés, même s'ils sont présentssur l'appareil.

123

AWS Greengrass Guide de l'utilisateurMise à jour automatique de l'agent OTA

• Il est impératif qu'un appareil ciblé par une mise à jour n'exécute pas deux agents OTA pour le mêmeobjet IoT AWS. Sinon, les deux agents OTA traiteraient les mêmes tâches, ce qui entraînerait desconflits.

Mise à jour automatique de l'agent OTAPour effectuer une mise à jour automatique de l'agent OTA, procédez comme suit :

1. Vérifiez que le Noyau AWS Greengrass est correctement dimensionné avec des entrées de fichierconfig.json valides et les certificats nécessaires.

2. Si l'agent OTA est géré par un système d'initialisation, vérifiez que managedRespawn = true dufichier config.json, et les scripts ota_pre_update.sh et ota_post_update.sh, sont présentsdans le répertoire ./greengrass/usr/scripts.

3. Lancez l'agent ggc-ota en exécutant ./greengrass/ota/ota_agent/ggc-ota.4. Créez une tâche de mise à jour automatique OTA dans le cloud avec l'API CreateSoftwareUpdateJob

(aws greengrass create-software-update-job), en veillant à ce que le paramètre --software-to-update soit défini sur ota_agent.

5. L'agent OTA va effectuer une mise à jour automatique.

Mise à jour du logiciel Greengrass CorePour effectuer une mise à jour du logiciel Noyau AWS Greengrass, procédez comme suit :

1. Vérifiez que le Noyau AWS Greengrass est correctement dimensionné avec des entrées de fichierconfig.json valides et les certificats nécessaires.

2. Si le logiciel Noyau AWS Greengrass est géré par un système d'initialisation, vérifiez quemanagedRespawn = true du fichier config.json, et les scripts ggc_pre_update.sh etggc_post_update.sh, sont présents dans le répertoire ./greengrass/usr/scripts.

3. Lancez l'agent ggc-ota en exécutant ./greengrass/ota/ota_agent/ggc-ota.4. Créez une tâche de mise à jour automatique OTA dans le cloud avec l'API CreateSoftwareUpdateJob

(aws greengrass create-software-update-job), en veillant à ce que le paramètre --software-to-update soit défini sur core.

5. L'agent OTA effectue alors la mise à jour du logiciel Noyau AWS Greengrass.

124


Réinitialiser les déploiementsCette fonction est disponible pour AWS Greengrass Core v1.1.0 ou version supérieure.

Vous pouvez restaurer les déploiements d'un groupe pour :

• Supprimer le groupe (par exemple, lorsque le noyau du groupe a été réimagé)• Déplacer le noyau du groupe vers un autre groupe.• Restaurer l'état antérieur du groupe, celui d'avant tous les déploiements.• Supprimer la configuration de déploiement de l'appareil principal.• Supprimer des données sensibles de l'appareil principal ou du cloud.• Déployer une nouvelle configuration sur un noyau sans avoir à remplacer le noyau par un autre dans le

groupe actuel.

Note

La fonctionnalité Réinitialiser les déploiements n'est pas disponible dans la version v1.0.0 dulogiciel AWS Greengrass Core. Notez également qu'il n'est pas possible de supprimer un groupequi a été déployé à l'aide de la v1.0.0.

La commande ResetDeployments nettoie toutes les informations de déploiement qui sont stockéesdans le cloud pour un groupe donné. Elle demande ensuite à l'appareil principal du groupe de nettoyertoutes les informations liées au déploiement (fonctions Lambda, journaux utilisateur, base de données etcertificat de serveur shadow, mais pas le fichier config.json défini par l'utilisateur ni les certificats principauxGreengrass). Vous ne pouvez pas lancer une réinitialisation des déploiements pour un groupe si ce derniera un déploiement avec l'état Pending ou Building.

aws greengrass reset-deployments --group-id <GroupId> [--force]

Arguments destinés à la commande reset-deployments de l'interface de ligne de commande :

--group-id

ID du groupe--force

[Facultatif] Utilisez ce paramètre si l'appareil principal du groupe a été perdu, volé ou détruit. Si cetteoption est activée, le processus de déploiement de la réinitialisation signale la réussite une fois quetoutes les informations de déploiement dans le cloud ont été nettoyées, sans attendre la réponsed'un appareil principal. Toutefois, si l'appareil principal est ou devient actif, il effectue également lesopérations de nettoyage.

La sortie de la commande reset-deployments de l'interface de ligne de commande ressemble à ce quisuit :

{ "DeploymentId": "4db95ef8-9309-4774-95a4-eea580b6ceef", "DeploymentArn": "arn:aws:greengrass:us-west-2:106511594199:/greengrass/groups/b744ed45-a7df-4227-860a-8d4492caa412/deployments/4db95ef8-9309-4774-95a4-eea580b6ceef"}

125


Vous pouvez vérifier le statut du déploiement de la réinitialisation avec la commande get-deployment-status de l'interface de ligne de commande :

aws greengrass get-deployment-status --deployment-id DeploymentId --group-id GroupId

Arguments destinés à la commande get-deployment-status de l'interface de ligne decommande :

--deployment-id

ID de déploiement--group-id

ID du groupe

La sortie de la commande get-deployment-status de l'interface de ligne de commande ressemble àce qui suit :

{ "DeploymentStatus": "Success", "UpdatedAt": "2017-04-04T00:00:00.000Z"}

DeploymentStatus est défini sur Building lorsque le déploiement de la réinitialisation est en coursde préparation. Lorsque le déploiement de la réinitialisation est prêt, mais que le Noyau AWS Greengrassn'a pas sélectionné le nouveau déploiement de la réinitialisation, la valeur DeploymentStatus estInProgress.

126


Exécution de fonctions Lambda surAWS Greengrass Core

AWS Greengrass fournit un environnement d'exécution Lambda de conteneur pour le code définipar l'utilisateur. Les fonctions Lambda déployées sur un Noyau AWS Greengrass s'exécutent dansl'environnement d'exécution Lambda local du noyau. Les fonctions Lambda locales peuvent êtredéclenchées par des événements locaux, des messages depuis le cloud, et d'autres sources, ce quiapporte la fonctionnalité de calcul local aux appareils connectés. Par exemple, vous pouvez utiliser lesfonctions pour filtrer des données d'appareil avant de les transmettre vers le cloud.

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

Kits SDK pour les fonctionsAWS fournit deux kits SDK qui sont utilisés par les fonctions .


Active les fonctions Lambda locales pour interagir avec les services locaux sur le Noyau AWSGreengrass. Ce kit SDK est requis par toutes les fonctions . Des versions de kit SDK sont disponiblespour les plateformes et langages de programmation courants.

Le tableau suivant répertorie chaque plateforme ou langage pris en charge, ainsi que les versionscompatibles du logiciel Noyau AWS Greengrass.

Langage ou plateforme Version de GGC

Python 2.7

Java 8

Node.js 6.10

C, C++

• Téléchargez le kit de développement logiciel (SDK) AWS Greengrass Core pour Python, Java ouNode.js à partir de la page Software (Logiciel) de la Console IoT AWS.

• Téléchargez le depuis GitHub. Ce kit SDK est utilisé par ??? (p. 131).Kit SDK AWS

Active les fonctions Lambda locales pour envoyer des appels directs aux services AWS, tels queAmazon S3, DynamoDB, AWS IoT et AWS Greengrass. Pour utiliser le kit SDK AWS dans unefonction , vous devez l'inclure dans votre package de déploiement. Lorsque vous utilisez le kit SDKAWS Greengrass Core et le kit SDK AWS dans le même package, assurez-vous que vos fonctions

127

AWS Greengrass Guide de l'utilisateurMigration des fonctions Lambda basées sur le cloud

Lambda utilisent les espaces de noms corrects. Les fonctions ne peuvent pas communiquer avec lesservices de cloud lorsque le noyau est hors ligne.• Téléchargez le kit SDK AWS depuis le Centre de ressources du démarrage.

Pour plus d'informations sur la création d'un package de déploiement, consultez the section called“Création et empaquetage d'une fonction Lambda” (p. 53) dans le didacticiel Mise en route ou dansCréation d'un package de déploiement du manuel AWS Lambda Developer Guide.

Migration des fonctions Lambda basées sur le cloudLe kit SDK AWS Greengrass Core suit le modèle de programmation du kit SDK AWS, ce qui facilite leportage des fonctions Lambda développées pour le cloud vers des fonctions Lambda qui s'exécutent sur unNoyau AWS Greengrass.

Par exemple, la fonction Lambda Python suivante utilise le kit SDK AWS pour Python pour publier unmessage dans la rubrique /some/topic dans le cloud :


Pour porter la fonction pour un Noyau AWS Greengrass, dans l'instruction import et l'initialisationclient, remplacez le nom de module boto3 par greengrasssdk, comme illustré dans l'exemplesuivant :

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

Note

Le kit SDK AWS Greengrass Core prend en charge uniquement l'envoi des messages MQTT avecQoS = 0.

Cela vous permet de tester vos fonctions Lambda dans le cloud et de les migrer ensuite vers AWSGreengrass avec un minimum d'efforts. Les ne s'exécutent pas dans le cloud ; vous ne pouvez donc pasutiliser le kit SDK AWS pour les tester dans le cloud avant le déploiement.

Référence de fonctions Lambda par alias ou versionLes alias Les groupes Greengrass peuvent référencer une fonction Lambda par alias (recommandé) oupar version. L'utilisation d'un alias facilite la gestion des mises à jour de code, car vous n'avez pas besoinde changer votre tableau d'abonnement ou votre définition de groupe lorsque le code de fonction est misà jour. Il suffit de faire pointer l'alias vers la nouvelle version de la fonction. se résolvent en numéros de

128

https://aws.amazon.com/getting-started/tools-sdks/

http://docs.aws.amazon.com/lambda/latest/dg/deployment-package-v2.html

AWS Greengrass Guide de l'utilisateurConfiguration spécifique au groupe

version pendant le déploiement du 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.

Les versions $LATEST AWS Greengrass ne prend pas en charge les alias Lambda pour les versions$LATEST. ne sont pas forcément des versions de fonction publiée immuables, et peuvent être modifiées àtout moment, ce qui est contraire au principe AWS Greengrass d'immuabilité de version.

Une pratique courante pour maintenir vos fonctions à jour avec les modifications de code consiste àutiliser un alias nommé PRODUCTION dans votre groupe et vos abonnements Greengrass. Lorsque vouspromouvez de nouvelles versions de votre fonction Lambda en production, pointez l'alias vers la versionstable la plus récente, puis redéployez le groupe. Vous pouvez également utiliser cette méthode pourrestaurer une version précédente.

Configuration spécifique au groupe pour desfonctions

AWS Greengrass permet une gestion basée sur le cloud des fonctions . Même si le code et lesdépendances d'une fonction sont gérés à l'aide d'AWS Lambda, AWS Greengrass prend en charge lesparamètres de configuration spécifiques au groupe suivants :

Limite de mémoire

L'allocation de mémoire pour la fonction. La valeur par défaut est 16 Mo.Expiration

La durée avant laquelle la fonction ou la demande est mise hors service. Le durée par défaut est3 secondes.

Cycle de vie

Un cycle de vie de fonction Lambda peut être à la demande ou à longue durée de vie. La valeur pardéfaut est à la demande.

Une fonction Lambda à la demande démarre dans un conteneur nouveau ou réutilisé lorsqu'elle estappelée. Les demandes envoyées à la fonction peuvent être traitées par n'importe quel conteneurdisponible. Une fonction Lambda longue durée (ou épinglée) commence automatiquement aprèsqu'AWS Greengrass a démarré et continue à s'exécuter dans son propre conteneur (ou sandbox),Toutes les demandes envoyées à la fonction sont traitées par le même conteneur. Pour plusd'informations, consultez the section called “Configuration de cycle de vie” (p. 131).

Accès en lecture au répertoire /sys

Indique si la fonction peut accéder au dossier /sys de l'hôte. Utilisez cela lorsque la fonction doit lire lesinformations sur les appareils depuis le répertoire /sys. La valeur par défaut est false.

Type de données de charge utile d'entrée

Le type d'encodage attendu de charge utile d'entrée pour la fonction, JSON ou binaire. Les??? (p. 131) prennent en charge uniquement le type d'encodage binaire (non JSON).

Note

L'acception des données d'entrée binaires peut être utile pour les fonctions qui interagissentavec les données de l'appareil ; en effet, à cause des capacités matérielles restreintes desappareils, il est souvent difficile, voire impossible, pour eux de construire un type de donnéesJSON. La prise en charge du type d'encodage binaire est disponible à partir du logiciel AWSGreengrass Core v1.5.0 et du kit SDK AWS Greengrass Core v1.1.0.

129

AWS Greengrass Guide de l'utilisateurFlux de communication

Variables d'environnement

Paires clé-valeur qui peuvent transférer dynamiquement des paramètres au code de fonction etaux bibliothèques. Les variables d'environnement locales fonctionnent de la même manière que lesvariables d'environnement de fonction AWS Lambda, mais sont disponibles dans l'environnementprincipal.

Stratégies d'accès aux ressources

Liste de 10 ressources locales (p. 134) et ressources d'apprentissage automatique (p. 159) (aumaximum) auxquelles la fonction Lambda est autorisée à accéder, avec l'autorisation read-only ouread-write correspondante. Dans la console, ces ressources affiliées sont répertoriées sur la pageResources (Ressources) de la fonction.

Flux de communication pour les fonctionsLes fonctions peuvent interagir avec d'autres membres des services locaux Groupe AWS Greengrass et lesservices de cloud (y compris les services AWS).

Messages MQTTLes fonctions peuvent échanger des messages MQTT avec les entités suivantes :

• Les périphériques du groupe.• Les fonctions Lambda du groupe.• AWS IoT.• Le service Device Shadow local.

Ce flux de communication utilise un schéma publication-souscription contrôlé par abonnements. Unabonnement définit une source de message, une cible de message et un filtre de rubrique. Les messagespubliés sur une cible de fonction Lambda sont transmis au gestionnaire enregistré de la fonction. Lesabonnements permettent une sécurité accrue et des interactions prévisibles. Pour plus d'informations,consultez the section called “Flux des messages Greengrass” (p. 197).

Note

Les fonctions peuvent échanger des messages avec des appareils, d'autres fonctions, et desshadows locales lorsque le noyau est hors ligne, mais les messages vers AWS IoT sont mis enfile d'attente. Pour plus d'informations, consultez the section called “File d'attente de messagesMQTT” (p. 27).

Autres flux de communication• Pour interagir avec les ressources locales et les modèles d'apprentissage automatique sur un appareil

principal, les fonctions utilisent des interfaces de système d'exploitation spécifiques à chaque plateforme.Par exemple, vous pouvez utiliser la méthode open dans le module os pour les fonctions Python 2.7.Pour qu'une fonction ait l'autorisation d'accéder à une ressource, elle doit être affiliée à la ressourceet disposer de l'autorisation read-only ou read-write. Pour plus d'informations, y compris sur ladisponibilité des versions Noyau AWS Greengrass consultez Accès aux ressources locales avec lesfonctions Lambda (p. 134) et Exécuter l'inférence de Machine Learning (p. 159).

• Les fonctions peuvent utiliser le kit SDK AWS pour communiquer avec les services AWS. Pour plusd'informations, consultez Kit SDK AWS (p. 127).

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

130

http://docs.aws.amazon.com/lambda/latest/dg/env_variables.html

https://docs.python.org/2/library/os.html

AWS Greengrass Guide de l'utilisateurConfiguration de cycle de vie

Note

Les fonctions ne peuvent pas communiquer avec AWS ou d'autres services de cloud lorsque lenoyau est hors ligne.

Configuration de cycle de vie pour les fonctionsLe cycle de vie de la fonction détermine le moment où une fonction démarre et la façon dont elle créeet utilise des conteneurs. Le cycle de vie détermine également comment les variables et la logique deprétraitement se trouvant à l'extérieur du gestionnaire de fonctions sont conservées.

AWS 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, saufsi un conteneur existant peut être réutilisé. Les données qui sont envoyées à la fonction peuvent êtreextraites 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 pasconservées quand de nouveaux conteneurs sont créés.

• Les fonctions à longue durée de vie (ou épinglées) démarrent automatiquement lorsque le NoyauAWS Greengrass démarre et sont exécutées dans un conteneur unique. Toutes les données qui sontenvoyé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 sontconservées pour chaque appel du gestionnaire.

Les fonctions Lambda à longue durée de vie sont utiles lorsque vous avez besoin de commencer àtravailler sans aucune entrée initiale. Par exemple, une fonction à longue durée de vie peut être chargéeet démarrer le traitement d'un modèle d'apprentissage automatique pour le moment où elle 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 auxappels de leur gestionnaire. Si vous souhaitez exécuter indéfiniment du code d'exécution, vousdevez démarrer celui-ci à l'extérieur du gestionnaire. Assurez-vous qu'il n'y a pas de code deblocage à l'extérieur du gestionnaire qui peut empêcher la fonction de terminer son initialisation.

Pour plus d'informations sur la réutilisation des conteneurs, consultez Présentation de la réutilisation desconteneurs dans AWS Lambda sur le blog AWS Compute.

Exécutables LambdaUn est un type de fonction que vous pouvez utiliser pour exécuter du code binaire dans l'environnementprincipal. Il vous permet d'exécuter des fonctions propres à l'appareil de manière native, et de bénéficier dela plus petite couverture de code compilé. Les peuvent être appelés par des événements, appeler d'autresfonctions et accéder aux ressources locales.

131

https://aws.amazon.com/blogs/compute/container-reuse-in-lambda/

https://aws.amazon.com/blogs/compute/container-reuse-in-lambda/

AWS Greengrass Guide de l'utilisateurCréation d'un exécutable Lambda

Les prennent en charge uniquement le type d'encodage binaire (non JSON), mais vous pouvez les gérerdans votre groupe Greengrass et les déployer comme les autres fonctions . Cependant, le processus decréation des est différent de la création des fonctions Lambda Python, Java et Node.js :

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

• Vous chargez le code de fonction dans AWS Lambda en tant qu'exécutable compilé incluant le https://github.com/aws/aws-greengrass-core-sdk-c.

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

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

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

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

L'extrait suivant est la méthode main 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 d'implémentation, consultez.

Création d'un exécutable LambdaUne fois que vous avez compilé votre code avec le kit SDK, utilisez l'API AWS Lambda pour créer unefonction Lambda et charger votre exécutable compilé.

Note

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

L'exemple suivant utilise la commande CLI create-function pour créer un . 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 pour tous les .

132

https://github.com/aws/aws-greengrass-core-sdk-c

https://github.com/aws/aws-greengrass-core-sdk-c

https://github.com/aws/aws-greengrass-core-sdk-c/blob/master/aws-greengrass-core-sdk-c-example/simple_handler.c

http://docs.aws.amazon.com/cli/latest/reference/lambda/create-function.html

AWS Greengrass Guide de l'utilisateurCréation d'un exécutable Lambda

Note

Pour role, vous pouvez spécifier l'ARN de n'importe quel rôle d'exécution Lambda. AWSGreengrass n'utilise pas ce rôle, mais le paramètre est obligatoire pour créer la fonction. Pour plusd'informations sur les rôles d'exécution Lambda, consultez Modèle d'autorisations AWS Lambdadans le manuel AWS Lambda Developer Guide.

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 vousrecommandons de référencer les fonctions Lambda par alias lorsque vous les ajoutez à un groupeGreengrass.

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

Note

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

Ensuite, ajoutez l' à un groupe Greengrass, configurez-le de sorte qu'il accepte des données d'entréebinaires dans les paramètres spécifiques à son groupe et déployez le groupe. Vous pouvez effectuer cetteopération dans la Console AWS Greengrass ou à l'aide de l'API AWS Greengrass.

133

http://docs.aws.amazon.com/lambda/latest/dg/intro-permission-model.html

http://docs.aws.amazon.com/cli/latest/reference/lambda/publish-version.html

http://docs.aws.amazon.com/cli/latest/reference/lambda/create-alias.html

AWS Greengrass Guide de l'utilisateurTypes de ressource pris en charge

Accès aux ressources locales avecles fonctions Lambda


Les développeurs qui utilisent AWS Greengrass peuvent créer des fonctions AWS Lambda dans le cloudet les déployer vers les appareils principaux pour une exécution locale. Sur les appareils principauxGreengrass exécutant Linux, ces fonctions Lambda déployées localement peuvent accéder auxressources locales qui sont physiquement présentes sur l'appareil principal Greengrass. Par exemple, pourcommuniquer avec des appareils connectés via Modbus ou CANbus, vous pouvez activer votre fonctionLambda pour qu'elle accède au port série de l'appareil principal. Pour configurer un accès sécurisé auxressources locales, vous devez garantir la sécurité de votre matériel physique et du système d'exploitationde votre appareil principal Greengrass.

Pour commencer à accéder aux ressources locales, consultez les didacticiels suivants :

• Configuration de l'accès aux ressources locales à l'aide de l'interface de ligne de commandeAWS (p. 136)

• Configuration de l'accès aux ressources locales à l'aide d'AWS Management Console (p. 141)

Types de ressource pris en chargeVous pouvez accéder à deux types de ressources locales : les ressources de volumes et les ressourcesd'appareils.

Ressources de volume

Fichiers ou répertoires sur le système de fichiers racine (sauf sous /sys, /dev ou /var). parmilesquelles :• Dossiers ou fichiers utilisés pour lire ou écrire des informations dans des fonctions Lambda

Greengrass (par exemple, /usr/lib/python2.x/site-packages/local).• Dossiers ou fichiers sous le système de fichiers /proc de l'hôte (par exemple, /proc/net ou /proc/stat). Pris en charge dans v uniquement. Pour des prérequis supplémentaires, consultez thesection called “Ressources de volume sous le répertoire /proc” (p. 135).

Tip

Pour configurer les répertoires /var, /var/run et /var/lib en tant que ressources devolume, montez d'abord le répertoire dans un autre dossier, puis configurez le dossier en tantque ressource de volume.

Ressources de l'appareil

Fichiers sous /dev. Seuls les périphériques de caractères ou les périphériques de stockage en modebloc sous /dev sont autorisés pour les ressources de périphérique. parmi lesquelles :• Ports série utilisés pour communiquer avec les appareils connectés via des ports série (par exemple,/dev/ttyS0, /dev/ttyS1).

134


• USB utilisé pour connecter des périphériques USB (par exemple, /dev/ttyUSB0 ou /dev/bus/usb).

• GPIO utilisés pour les capteurs et les actionneurs via GPIO (par exemple, /dev/gpiomem).• GPU utilisés pour accélérer l'apprentissage automatique à l'aide de GPU embarqués (par exemple,/dev/nvidia0).

• Caméras utilisées pour capturer les images et les vidéos (par exemple, /dev/video0).

Note

/dev/shm est une exception. Il peut être configuré en tant que ressource de volumeuniquement. Les ressources sous /dev/shm doivent recevoir l'autorisation rw.

AWS Greengrass prend également en charge les types de ressources utilisés pour exécuter l'inférence deMachine Learning. Pour de plus amples informations, veuillez consulter Exécuter l'inférence de MachineLearning (p. 159).

PrérequisLes exigences suivantes s'appliquent à la configuration d'un accès sécurisé aux ressources locales :

• Vous devez utiliser le logiciel AWS Greengrass Core v1.3.0 or greater. Pour créer des ressources pour lerépertoire /proc de l'hôte, vous devez utiliser v.

• La ressource locale (y compris tous les pilotes et bibliothèques requis) doit être correctement installéesur l'appareil principal Greengrass et constamment disponible pendant l'utilisation.

• L'opération souhaitée de la ressource et l'accès à la ressource ne doivent pas nécessiter de privilègesracine.

• Seules les autorisations read ou read and write sont disponibles. Les fonctions Lambda ne peuventpas effectuer d'opérations privilégiées sur les ressources.

• Vous devez fournir le chemin d'accès complet de la ressource locale sur le système d'exploitation del'appareil Greengrass principal.

• Un ID ou un nom de ressource doit comporter 128 caractères au maximum et utiliser le modèle [a-zA-Z0-9:_-]+.

Ressources de volume sous le répertoire /procLes considérations suivantes s'appliquent aux ressources de volume se trouvant sous le répertoire/proc del'hôte.

• Vous devez utiliser le logiciel AWS Greengrass Core v.• Vous pouvez autoriser un accès en lecture seule pour les fonctions Lambda, mais pas d'accès en

lecture-écriture. Ce niveau d'accès est géré par AWS Greengrass.• Vous pouvez également avoir besoin d'accorder des autorisations de groupe de système d'exploitation

pour activer l'accès en lecture dans le système de fichiers. Par exemple, supposons que votre répertoireou fichier source ait une autorisation 660, ce qui signifie que seul le propriétaire ou l'utilisateur du groupedispose de l'accès en lecture (et en écriture). Dans ce cas, vous devez ajouter les autorisations dupropriétaire du groupe de système d'exploitation à la ressource. Pour plus d'informations, consultez thesection called “Autorisation d'accès fichier pour le propriétaire du groupe” (p. 136).

• L'environnement hôte et l'espace de noms Lambda contiennent tous les deux un répertoire /proc. Parconséquent, veillez à éviter les conflits de nom lorsque vous spécifiez le chemin de destination. Parexemple, si /proc est le chemin d'accès source, vous pouvez spécifier /host-proc comme chemin dedestination (ou tout autre nom de chemin différent de « /proc »).

135

AWS Greengrass Guide de l'utilisateurAutorisation d'accès fichier pour le propriétaire du groupe

Autorisation d'accès fichier pour le propriétaire dugroupe

Le processus d'une fonction Lambda AWS Greengrass s'exécute normalement comme ggc_user etggc_group. Cependant, vous pouvez accorder au processus d'une fonction Lambda des autorisationssupplémentaires d'accès aux fichiers dans la définition de ressources locales, comme suit :

• Pour ajouter les autorisations du groupe Linux qui possède la ressource, utilisez le paramètreGroupOwnerSetting#AutoAddGroupOwner ou l'option de console Ajouter automatiquement lesautorisations de groupe de système d'exploitation du groupe Linux qui possède la ressource.

• Pour ajouter les autorisations d'un autre groupe Linux, utilisez le paramètreGroupOwnerSetting#GroupOwner ou l'option de console Spécifier un autre groupe desystème d'exploitation pour ajouter l'autorisation. La valeur GroupOwner est ignorée siGroupOwnerSetting#AutoAddGroupOwner a la valeur true.

Un processus de fonction Lambda AWS Greengrass hérite de toutes les autorisations du système defichiers de ggc_user, ggc_group et du groupe Linux (s'il a été ajouté). Pour que la fonction Lambdaaccède à une ressource, le processus de fonction Lambda doit disposer des autorisations requises sur laressource. Vous pouvez utiliser la commande chmod(1) pour modifier l'autorisation de la ressource, sinécessaire.

Voir aussi• Limites AWS Greengrass dans Références générales AWS

Configuration de l'accès aux ressources locales àl'aide de l'interface de ligne de commande AWS


Pour utiliser une ressource locale, vous devez ajouter une définition de ressource à la définition de groupedéployée sur votre appareil principal Greengrass. La définition de groupe doit également contenir unedéfinition de fonction Lambda dans laquelle vous accordez les autorisations d'accès à vos fonctionsLambda pour les ressources locales. Pour en savoir plus, notamment les exigences et contraintes,consultez Accès aux ressources locales avec les fonctions Lambda (p. 134).

Ce didacticiel décrit le processus de création d'une ressource locale et de configuration de l'accès à l'aidede l'interface de ligne de commande (CLI) AWS. Pour suivre les étapes de ce didacticiel, vous devez avoirdéjà créé un groupe Greengrass comme décrit dans Démarrez avec AWS Greengrass (p. 31).

Pour obtenir un didacticiel qui utilise AWS Management Console, consultez Configuration de l'accès auxressources locales à l'aide d'AWS Management Console (p. 141).

Création de ressources localesTout d'abord, utilisez la commande CreateResourceDefinition pour créer une définition de ressourcequi spécifie les ressources auxquelles vous voulez accéder. Dans cet exemple, nous créons deuxressources, TestDirectory et TestCamera :

aws greengrass create-resource-definition --cli-input-json '{ "Name": "MyLocalVolumeResource",

136

http://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html#limits_greengrass

http://docs.aws.amazon.com/greengrass/latest/apireference/createresourcedefinition-post.html

AWS Greengrass Guide de l'utilisateurCréation de ressources locales

"InitialVersion": { "Resources": [ { "Id": "data-volume", "Name": "TestDirectory", "ResourceDataContainer": { "LocalVolumeResourceData": { "SourcePath": "/src/LRAtest", "DestinationPath": "/dest/LRAtest", "GroupOwnerSetting": { "AutoAddGroupOwner": true, "GroupOwner": "" } } } }, { "Id": "data-device", "Name": "TestCamera", "ResourceDataContainer": { "LocalDeviceResourceData": { "SourcePath": "/dev/video0", "GroupOwnerSetting": { "AutoAddGroupOwner": true, "GroupOwner": "" } } } } ] }}'

Ressources : liste des objets Resource du groupe Greengrass. Un groupe Greengrass peut avoir jusqu'à50 ressources.

Resource#Id : identifiant unique de la ressource. L'ID est utilisé pour se référer à une ressource dans laconfiguration de la fonction Lambda. Longueur maximale de 128 caractères. Modèle : [a-zA-Z0-9:_-]+.

Resource#Name : nom de la ressource. Le nom de la ressource s'affiche dans la console Greengrass.Longueur maximale de 128 caractères. Modèle : [a-zA-Z0-9:_-]+.

LocalVolumeResourceData#SourcePath : chemin absolu local de la ressource de volume sur l'appareilGreengrass principal. Le chemin source d'un type de ressource de volume ne peut pas commencer par /sys.

LocalDeviceResourceData#SourcePath : chemin absolu local de la ressource d'appareil. Le chemin sourced'une ressource d'appareil ne peut faire référence qu'à un appareil caractère ou un appareil bloc sous /dev.

LocalVolumeResourceData#DestinationPath : chemin absolu de la ressource de volume à l'intérieur del'environnement Lambda.

GroupOwnerSetting : permet de configurer des privilèges de groupe supplémentaires pour le processusLambda. Ce champ est facultatif. Pour plus d'informations, consultez Autorisation d'accès fichier pour lepropriétaire du groupe (p. 136).

GroupOwnerSetting#AutoAddGroupOwner : si la valeur est true, Greengrass ajoute automatiquement legroupe du système d'exploitation Linux spécifié propriétaire de la ressource aux privilèges du processusLambda. Ainsi, le processus Lambda a les autorisations d'accès aux fichiers du groupe Linux ajouté.

GroupOwnerSetting#GroupOwner : spécifie le nom du groupe du système d'exploitation Linux dont lesprivilèges sont ajoutés au processus Lambda. Ce champ est facultatif.

137

AWS Greengrass Guide de l'utilisateurCréation de la fonction Greengrass

Un ARN de version de définition de ressource est renvoyé par CreateResourceDefinition. L'ARN doitêtre utilisé lors de la mise à jour d'une définition de groupe. Exemples :

{ "LatestVersionArn": "arn:aws:greengrass:us-west-2:012345678901:/greengrass/definition/resources/ab14d0b5-116e-4951-a322-9cde24a30373/versions/a4d9b882-d025-4760-9cfe-9d4fada5390d", "Name": "MyLocalVolumeResource", "LastUpdatedTimestamp": "2017-11-15T01:18:42.153Z", "LatestVersion": "a4d9b882-d025-4760-9cfe-9d4fada5390d", "CreationTimestamp": "2017-11-15T01:18:42.153Z", "Id": "ab14d0b5-116e-4951-a322-9cde24a30373", "Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/resources/ab14d0b5-116e-4951-a322-9cde24a30373"}

Création de la fonction GreengrassUne fois les ressources créées, utilisez la commande CreateFunctionDefinition pour créer lafonction Greengrass et lui accorder l'accès à la ressource :

aws greengrass create-function-definition --cli-input-json '{ "Name": "MyFunctionDefinition", "InitialVersion": { "Functions": [ { "Id": "greengrassLraTest", "FunctionArn": "arn:aws:lambda:us-west-2:012345678901:function:lraTest:1", "FunctionConfiguration": { "Pinned": false, "MemorySize": 16384, "Timeout": 30, "Environment": { "ResourceAccessPolicies": [ { "ResourceId": "data-volume", "Permission": "rw" }, { "ResourceId": "data-device", "Permission": "ro" } ], "AccessSysfs": true } } } ] }}'

ResourceAccessPolicies : contient les resourceId et permission qui accordent l'accès Lambda à laressource. Une fonction Lambda peut avoir 10 ressources au plus.

ResourceAccessPolicy#Permission : indique les autorisations dont le processus Lambda dispose sur laressource. Les options disponibles sont rw (lecture/écriture) ou ro (lecture seule).

AccessSysfs : si la valeur est true, le processus Lambda peut avoir accès en lecture au dossier /sys surl'appareil Greengrass principal. Celui-ci est utilisé dans les cas où la fonction Lambda Greengrass Lambdadoit lire les informations sur les appareils depuis /sys.

138


http://docs.aws.amazon.com/greengrass/latest/apireference/createfunctiondefinition-post.html

AWS Greengrass Guide de l'utilisateurAjout de la fonction Lambda au groupe

Là encore, CreateFunctionDefinition renvoie un ARN de version de définition de fonction. L'ARNdoit être utilisé dans votre version de définition de groupe.

{ "LatestVersionArn": "arn:aws:greengrass:us-west-2:012345678901:/greengrass/definition/functions/3c9b1685-634f-4592-8dfd-7ae1183c28ad/versions/37f0d50e-ef50-4faf-b125-ade8ed12336e", "Name": "MyFunctionDefinition", "LastUpdatedTimestamp": "2017-11-22T02:28:02.325Z", "LatestVersion": "37f0d50e-ef50-4faf-b125-ade8ed12336e", "CreationTimestamp": "2017-11-22T02:28:02.325Z", "Id": "3c9b1685-634f-4592-8dfd-7ae1183c28ad", "Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/functions/3c9b1685-634f-4592-8dfd-7ae1183c28ad"}

Ajout de la fonction Lambda au groupeEnfin, utilisez CreateGroupVersion pour ajouter la fonction au groupe. Exemples :

aws greengrass create-group-version --group-id "b36a3aeb-3243-47ff-9fa4-7e8d98cd3cf5" \--resource-definition-version-arn "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/resources/db6bf40b-29d3-4c4e-9574-21ab7d74316c/versions/31d0010f-e19a-4c4c-8098-68b79906fb87" \--core-definition-version-arn "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/cores/adbf3475-f6f3-48e1-84d6-502f02729067/versions/297c419a-9deb-46dd-8ccc-341fc670138b" \--function-definition-version-arn "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/functions/d1123830-da38-4c4c-a4b7-e92eec7b6d3e/versions/a2e90400-caae-4ffd-b23a-db1892a33c78" \--subscription-definition-version-arn "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/subscriptions/7a8ef3d8-1de3-426c-9554-5b55a32fbcb6/versions/470c858c-7eb3-4abd-9d48-230236bfbf6a"

Une nouvelle version de groupe est retournée :

{ "Arn": "arn:aws:greengrass:us-west-2:012345678901:/greengrass/groups/b36a3aeb-3243-47ff-9fa4-7e8d98cd3cf5/versions/291917fb-ec54-4895-823e-27b52da25481", "Version": "291917fb-ec54-4895-823e-27b52da25481", "CreationTimestamp": "2017-11-22T01:47:22.487Z", "Id": "b36a3aeb-3243-47ff-9fa4-7e8d98cd3cf5"}

Votre groupe Greengrass contient à présent la fonction Lambda lraTest ayant accès à deux ressources :TestDirectory et TestCamera.

Cet exemple de fonction Lambda, lraTest.py, écrite en Python, écrit sur la ressource de volume locale :

# lraTest.py# Demonstrates a simple use case of local resource access.# This Lambda function writes a file "test" to a volume mounted inside# the Lambda environment under "/dest/LRAtest". Then it reads the file and # publishes the content to the AWS IoT "LRA/test" topic.

import sysimport greengrasssdkimport platformimport osimport logging

139

http://docs.aws.amazon.com/greengrass/latest/apireference/createfunctiondefinition-post.html

http://docs.aws.amazon.com/greengrass/latest/apireference/creategroupversion-post.html

AWS Greengrass Guide de l'utilisateurDépannage

# Create a Greengrass Core SDK client.client = greengrasssdk.client('iot-data')volumePath = '/dest/LRAtest'

def function_handler(event, context): client.publish(topic='LRA/test', payload='Sent from AWS Greengrass Core.') try: volumeInfo = os.stat(volumePath) client.publish(topic='LRA/test', payload=str(volumeInfo)) with open(volumePath + '/test', 'a') as output: output.write('Successfully write to a file.\n') with open(volumePath + '/test', 'r') as myfile: data = myfile.read() client.publish(topic='LRA/test', payload=data) except Exception as e: logging.error("Experiencing error :{}".format(e)) return

Ces commandes sont fournies par l'API Greengrass pour créer et gérer des définitions de ressource et desversions de définitions de ressources :

• CreateResourceDefinition• CreateResourceDefinitionVersion• DeleteResourceDefinition• GetResourceDefinition• GetResourceDefinitionVersion• ListResourceDefinitions• ListResourceDefinitionVersions• UpdateResourceDefinition

Dépannage• Q : Pourquoi le déploiement de mon groupe Greengrass échoue-t-il avec une erreur similaire à :

group config is invalid: ggc_user or [ggc_group root tty] don't have ro permission on the file: /dev/tty0

R : Cette erreur indique que le processus Lambda n'a pas l'autorisation d'accéder à la ressourcespécifiée. La solution est de modifier l'autorisation de fichier de la ressource afin que Lambda puisse yaccéder. (Consultez Autorisation d'accès fichier pour le propriétaire du groupe (p. 136) pour plus dedétails).

• Q : Quand je configure /var/run comme ressource de volume, pourquoi la fonction Lambda ne réussit-elle pas à démarrer avec un message d'erreur dans le runtime.log :

[ERROR]-container_process.go:39,Runtime execution error: unable to start lambda container. container_linux.go:259: starting container process caused "process_linux.go:345: container init caused \"rootfs_linux.go:62: mounting \\\"/var/run\\\" to rootfs \\\"/greengrass/ggc/packages/1.3.0/rootfs_sys\\\" at \\\"/greengrass/ggc/packages/1.3.0/rootfs_sys/run\\\" caused \\\"invalid argument\\\"\""

R : Noyau AWS Greengrass ne prend pas en charge actuellement la configuration de /var, /var/runet /var/lib comme ressources de volume. Une solution de contournement consiste à monter d'abord

140


http://docs.aws.amazon.com/greengrass/latest/apireference/createresourcedefinitionversion-post.html

http://docs.aws.amazon.com/greengrass/latest/apireference/deleteresourcedefinition-delete.html

http://docs.aws.amazon.com/greengrass/latest/apireference/getresourcedefinition-get.html

http://docs.aws.amazon.com/greengrass/latest/apireference/getresourcedefinitionversion-get.html

http://docs.aws.amazon.com/greengrass/latest/apireference/listresourcedefinitions-get.html

http://docs.aws.amazon.com/greengrass/latest/apireference/listresourcedefinitionversions-get.html

http://docs.aws.amazon.com/greengrass/latest/apireference/updateresourcedefinition-put.html

AWS Greengrass Guide de l'utilisateurUtilisation de la console

/var, /var/run ou /var/lib dans un autre dossier, puis à configurer le dossier comme ressource devolume.

• Q : Quand je configure /dev/shm comme ressource de volume avec l'autorisation en lecture seule,pourquoi la fonction Lambda ne réussit-elle pas à démarrer avec un message d'erreur dans leruntime.log :

[ERROR]-container_process.go:39,Runtime execution error: unable to start lambda container. container_linux.go:259: starting container process caused "process_linux.go:345: container init caused \"rootfs_linux.go:62: mounting \\\"/dev/shm\\\" to rootfs \\\"/greengrass/ggc/packages/1.3.0/rootfs_sys\\\" at \\\"/greengrass/ggc/packages/1.3.0/rootfs_sys/dev/shm\\\" caused \\\"operation not permitted\\\"\""”

R : /dev/shm ne peut être configuré qu'en lecture/écriture. Modifiez l'autorisation de la ressource en rwpour résoudre le problème.

Configuration de l'accès aux ressources locales àl'aide d'AWS Management Console


Vous pouvez configurer des fonctions Lambda pour accéder de façon sécurisée aux ressources locales surl'appareil Greengrass principal hôte. Les ressources locales font référence aux bus et périphériques qui setrouvent physiquement sur l'hôte, ou aux volumes du système de fichiers sur le système d'exploitation hôte.Pour en savoir plus, notamment les exigences et contraintes, consultez Accès aux ressources locales avecles fonctions Lambda (p. 134).

Ce didacticiel décrit comment utiliser AWS Management Console pour configurer l'accès aux ressourceslocales qui sont présentes sur un appareil Noyau AWS Greengrass. Il contient les étapes détailléessuivantes :

1. Création du package de déploiement d'une fonction Lambda (p. 142)2. Création et publication d'une fonction Lambda (p. 144)3. Ajout de la fonction Lambda au groupe (p. 148)4. Ajout d'une ressource locale au groupe (p. 151)5. Ajout d'abonnements au groupe Greengrass (p. 152)6. Déploiement du groupe (p. 154)

Pour obtenir un didacticiel qui utilise l'interface de ligne de commande (CLI) AWS, consultez Configurationde l'accès aux ressources locales à l'aide de l'interface de ligne de commande AWS (p. 136).

PrérequisPour suivre ce didacticiel, vous devez disposer des éléments suivants :

• Un groupe Greengrass et un service principal Greengrass (v1.3.0 or greater). Pour savoir comment créerun groupe ou un service principal Greengrass, consultez Démarrez avec AWS Greengrass (p. 31).

• Les répertoires suivants créés sur l'appareil Greengrass principal :• /src/LRAtest• /dest/LRAtest

141

AWS Greengrass Guide de l'utilisateurCréation du package de déploiement d'une fonction Lambda

Le propriétaire du groupe de ces répertoires doit disposer d'un accès en lecture et en écriture auxrépertoires. Par exemple, pour accorder l'accès, vous pouvez utiliser la commande suivante :

sudo chmod 0775 /src/LRAtest

Étape 1 : Création du package de déploiement d'unefonction LambdaAu cours de cette étape, vous créez le package de déploiement d'une fonction Lambda, qui est un fichierZIP contenant le code et les dépendances de la fonction. Vous téléchargez également le kit SDK d'AWSGreengrass Core à inclure dans le package en tant que dépendance.

1. Sur votre ordinateur, copiez le script Python suivant dans un fichier local nommé lraTest.py. Il s'agitde la logique d'application pour la fonction Lambda.

# lraTest.py# Demonstrates a simple use case of local resource access.# This Lambda function writes a file "test" to a volume mounted inside# the Lambda environment under "/dest/LRAtest". Then it reads the file and # publishes the content to the AWS IoT "LRA/test" topic.

import sysimport greengrasssdkimport platformimport osimport logging

# Create a Greengrass Core SDK client.client = greengrasssdk.client('iot-data')volumePath = '/dest/LRAtest'

def function_handler(event, context): client.publish(topic='LRA/test', payload='Sent from AWS Greengrass Core.') try: volumeInfo = os.stat(volumePath) client.publish(topic='LRA/test', payload=str(volumeInfo)) with open(volumePath + '/test', 'a') as output: output.write('Successfully write to a file.\n') with open(volumePath + '/test', 'r') as myfile: data = myfile.read() client.publish(topic='LRA/test', payload=data) except Exception as e: logging.error("Experiencing error :{}".format(e)) return

2. Téléchargez le kit SDK d'AWS Greengrass Core Python 2.7 version 1.1.0, comme suit :

a. Dans Console IoT AWS, dans le volet de gauche, choisissez Logiciels.

142

https://console.aws.amazon.com//iotv2/home

AWS Greengrass Guide de l'utilisateurCréation du package de déploiement d'une fonction Lambda

b. Dans Kits SDK, pour Kit SDK AWS Greengrass Core, choisissez Configurer le téléchargement.

c. Choisissez Python 2.7 version 1.1.0, puis Télécharger le kit SDK Greengrass Core.

143

AWS Greengrass Guide de l'utilisateurCréation et publication d'une fonction Lambda

3. Décompressez le fichier greengrass-core-python-sdk-1.1.0.tar.gz.

Note

Consultez cette étape (p. 53) dans la section Démarrez pour découvrir comment procéder enfonction des différentes plates-formes. Par exemple, vous pouvez utiliser la commande tarsuivante :

tar -xzf greengrass-core-python-sdk-1.1.0.tar.gz

4. Ouvrez le dossier aws_greengrass_core_sdk/sdk extrait et décompressez le fichierpython_sdk_1_1_0.zip.

5. Compressez les éléments suivants dans un fichier nommé lraTestLambda.zip.

• lraTest.py. Logique d'application.• greengrasssdk. Bibliothèque requise pour toutes les fonctions Lambda Python.• Greengrass AWS SW License (IoT additiona) vr6.txt. Contrat de licence du logiciel Greengrass Core

requis.

Le fichier lraTestLambda.zip est le package de déploiement de votre fonction Lambda. Vous êtesmaintenant prêt à créer une fonction Lambda et à télécharger le package de déploiement.

Étape 2 : Création et publication d'une fonctionLambdaAu cours de cette étape, vous utilisez la console AWS Lambda pour créer une fonction Lambda, et pour laconfigurer afin qu'elle utilise votre package de déploiement. Vous publiez ensuite une version de fonction etcréez un alias.

Créez d'abord la fonction Lambda.

1. Dans AWS Management Console, choisissez Services et ouvrez la console AWS Lambda.

144


2. Sélectionnez Create function.3. Choisissez Créer à partir de zéro.4. Dans la section Author from scratch, utilisez les valeurs suivantes :

Propriété Value

Nom TestLRA

Runtime Python 2.7

Rôle Créer un rôle à partir de modèles

Nom de rôle

(Ce rôle n'est pas utilisé par AWS Greengrass.)

Greengrass_role_does_not_matter

5. Dans le bas de la page, choisissez Create function.

145


Téléchargez maintenant le package de déploiement de votre fonction Lambda et enregistrez legestionnaire.

1. Sur l'onglet Configuration de la fonction TestLRA, dans Function code, utilisez les valeurs suivantes :

Propriété Value

Type d'entrée de code Charger un fichier ZIP

Runtime Python 2.7

Gestionnaire lraTest.function_handler

2. Choisissez Upload.

146


3. Choisissez votre package de déploiement lraTestLambda.zip.4. Dans le haut de la page, choisissez Enregistrer.

Tip

Vous pouvez voir votre code dans la section Function code (Code de la fonction) enchoisissant Edit code inline (Modifier le code en ligne) dans le menu Code entry type (Typed'entrée de code).

Publiez ensuite la première version de votre fonction Lambda. Puis, créez un alias pour la version.

Note

Les groupes Greengrass peuvent référencer une fonction Lambda par alias (recommandé) ou parversion. L'utilisation d'un alias facilite la gestion des mises à jour de code, car vous n'avez pasbesoin de changer votre tableau d'abonnement ou votre définition de groupe lorsque le code defonction est mis à jour. Il suffit de faire pointer l'alias vers la nouvelle version de la fonction.

1. Dans le menu Actions, sélectionnez Publish new version.

2. Pour Version description, saisissez First version, puis choisissez Publication.3. Sur la page de configuration TestLRA: 1, dans le menu Actions, choisissez Create alias.

4. Sur la page Create a new alias, utilisez les valeurs suivantes :

147



Propriété Value

Nom test

Version 1

Note

AWS Greengrass ne prend pas en charge les alias Lambda pour les versions $LATEST.5. Sélectionnez Create.

Vous pouvez désormais ajouter la fonction Lambda à votre groupe Greengrass.

Étape 3 : Ajout de la fonction Lambda au groupeGreengrassAu cours de cette étape, vous ajoutez la fonction TestLRA à votre groupe et configurez le cycle de vie de lafonction.

Ajoutez d'abord la fonction Lambda à votre groupe Greengrass.

1. Dans Console IoT AWS, choisissez Greengrass, puis Groupes.

148


2. Choisissez le groupe Greengrass auquel vous souhaitez ajouter la fonction Lambda.3. Sur la page de configuration de groupe, choisissez Lambdas, puis Ajouter une expression lambda.

4. Sur la page Ajouter une fonction Lambda au groupe Greengrass, choisissez Utiliser une fonctionLambda existante.

149


5. Sur la page Utiliser une fonction Lambda existante, choisissez TestLRA, puis Suivant.6. Sur la page Sélectionner une version Lambda, choisissez Alias:test, puis Terminer.

Configurez ensuite le cycle de vie de la fonction Lambda.

1. Sur la page Lambdas, choisissez la fonction Lambda TestLRA.

2. Sur la page de configuration TestLRA, choisissez Modifier.3. Sur la page Configuration Lambda spécifique au groupe, utilisez les valeurs suivantes :

Propriété Value

Expiration 30 secondes

Cycle de vie Lambda Attribuer une longue durée de vie à cette fonctionet l'exécuter indéfiniment

Pour plus d'informations, consultez the section called “Configuration de cycle de vie” (p. 131).

4. Au bas de la page, sélectionnez Mettre à jour.

150

AWS Greengrass Guide de l'utilisateurAjout d'une ressource locale au groupe

Étape 4 : ajout d'une ressource locale au groupeGreengrassAu cours de cette étape, vous ajoutez une ressource de volume locale à un groupe Greengrass etaccordez à la fonction un accès en lecture et en écriture à la ressource. Une ressource locale se situe auniveau du groupe, ce qui la rend accessible par toutes les fonctions Lambda du groupe.

1. Sur la page de configuration de groupe, choisissez Ressources.

2. Sur l'onglet Local Resources (Ressources locales), choisissez Add local resource (Ajouter uneressource locale).

3. Sur la page Créer une ressource locale, utilisez les valeurs suivantes :

Propriété Value

Nom de la ressource testDirectory

Type de ressource Volume

Chemin source

(Ce chemin doit exister sur le systèmed'exploitation hôte.)

/src/LRAtest

Chemin de destination

(Ce chemin doit exister sur le systèmed'exploitation hôte.)

/dest/LRAtest

Autorisation d'accès fichier pour le propriétairedu groupe

Ajouter automatiquement les autorisations degroupe de système d'exploitation du groupeLinux qui possède la ressource

Le chemin source est le chemin absolu local de la ressource sur le système de fichiers de l'appareilprincipal. Ce chemin ne peut pas commencer par /sys.

151

AWS Greengrass Guide de l'utilisateurAjout d'abonnements au groupe Greengrass

Le chemin de destination est le chemin absolu de la ressource dans l'espace de noms Lambda.

L'option Autorisation d'accès fichier pour le propriétaire du groupe vous permet d'accorder desautorisations supplémentaires d'accès aux fichiers au processus Lambda. Pour plus d'informations,consultez Autorisation d'accès fichier pour le propriétaire du groupe (p. 136).

4. Sous Affiliations de fonction Lambda, choisissez Sélectionner.5. Choisissez TestLRA, choisissez Accès en lecture et en écriture, puis Effectué.

6. Au bas de la page, sélectionnez Save. La page Resources contient la nouvelle ressource testDirectory.

Étape 5 : Ajout d'abonnements au groupe GreengrassAu cours de cette étape, vous ajoutez deux abonnements au groupe Greengrass. Ces abonnementspermettent une communication bidirectionnelle entre la fonction Lambda et AWS IoT.

Créez d'abord un abonnement pour la fonction Lambda afin d'envoyer des messages à AWS Greengrass.


152

AWS Greengrass Guide de l'utilisateurAjout d'abonnements au groupe Greengrass

2. Sur la page Sélectionnez la source et la cible, configurez la source et la cible comme suit :

a. Dans Sélectionnez une source, choisissez Lambdas, puis TestLRA.b. Dans Sélectionnez une cible, choisissez Services, puis IoT Cloud.c. Choisissez Suivant.

3. Sur la page Filtrez vos données avec une rubrique, dans Filtre de rubrique facultatif, saisissez LRA/test, puis choisissez Suivant.

4. Choisissez Finish. La page Abonnements affiche le nouvel abonnement.

Configurez ensuite un abonnement qui appelle la fonction depuis AWS IoT.

153

AWS Greengrass Guide de l'utilisateurDéploiement du groupe

1. Sur la page Abonnements, choisissez Ajouter un abonnement.2. Sur la page Sélectionnez la source et la cible, configurez la source et la cible comme suit :

a. Dans Sélectionnez une source, choisissez Services, puis IoT Cloud.b. Dans Sélectionnez une cible, choisissez Lambdas, puis TestLRA.c. Choisissez Suivant.

3. Sur la page Filtrez vos données avec une rubrique, dans Filtre de rubrique facultatif, saisissezinvoke/LRAFunction, puis choisissez Suivant.

4. Choisissez Finish. La page Abonnements affiche les deux abonnements.

Étape 6 : Déploiement du groupe AWS GreengrassAu cours de cette étape, vous déployez la version actuelle de la définition de groupe.

1. Assurez-vous que l'appareil Noyau AWS Greengrass est en cours d'exécution. Dans la fenêtre determinal de votre Raspberry Pi, exécutez les commandes suivantes, si nécessaire.




154


Note

La version du chemin d'accès dépend de la version du logiciel AWS Greengrass Coreinstallée sur votre appareil principal.



2. Sur la page de configuration du groupe, choisissez Déploiements puis, dans le menu Actions,choisissez Déployer.

3. Sur la page Configuration du mode de détection de votre noyau par les appareils, choisissez Détectionautomatique.

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, maisAWS Greengrass prend é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é, accordez l'autorisation de créer le rôle de service AWS Greengrassen votre nom, ce qui permet à AWS Greengrass d'accéder à d'autres services AWS. Cetteopération ne doit être effectuée qu'une seule fois par compte.

La page Déploiements indique l'horodatage, l'ID de version et l'état du déploiement. Une fois terminé,le déploiement doit afficher l'état Successfully completed.


155

AWS Greengrass Guide de l'utilisateurTest de l'accès aux ressources locales

Test de l'accès aux ressources localesÀ présent, vous pouvez vérifier si l'accès aux ressources locales est correctement configuré. Pour effectuerle test, abonnez-vous à la rubrique LRA/test et publiez-la dans la rubrique invoke/LRAFunction. Le testréussit si la fonction Lambda envoie la charge utile attendue à AWS IoT.

1. Sur la page d'accueil de la Console IoT AWS, dans le volet de gauche, choisissez Test.

2. Dans la section Abonnements, utilisez les valeurs suivantes :

Propriété Value

rubrique abonnement LRA/test

Affichage de la charge utile MQTT Affichage des charges utiles sous forme dechaînes

3. Choisissez S'abonner à la rubrique. Votre fonction Lambda publie dans la rubrique LRA/test.

156


4. Dans la section Publication, saisissez invoke/LRAFunction, puis choisissez Publier dans larubrique pour appeler votre fonction Lambda. Le test réussit si la page affiche les trois charges utilesde messages de la fonction.

157


Vous pouvez consulter le fichier test créé par Lambda dans le répertoire /src/LRAtest sur l'appareilGreengrass principal. Même si la fonction Lambda écrit dans un fichier du répertoire /dest/LRAtest, cefichier est uniquement visible dans l'espace de noms Lambda ; il n'apparaît dans aucun espace de nomsLinux normal. Toute modification du chemin de destination est néanmoins prise en compte dans le cheminsource sur le système de fichiers.

Pour obtenir une aide pour résoudre les problèmes que vous pouvez rencontrer, consultez Résolution desproblèmes des applications AWS Greengrass (p. 205).

158

AWS Greengrass Guide de l'utilisateurFonctionnement de l'inférence de

Machine Learning AWS Greengrass

Exécuter l'inférence de MachineLearning

Cette fonction est disponible pour AWS Greengrass Core v1.5.0 uniquement.

AWS Greengrass vous permet d'exécuter l'inférence de Machine Learning en périphérie sur des donnéesgénérées localement à l'aide de modèles formés dans le cloud. Vous bénéficiez ainsi d'une faible latenceet de coûts d'inférence locale réduits, tout en profitant des avantages de la puissance du cloud computingpour les modèles de formation et les traitements complexes.

Pour commencer à exécuter l'inférence locale, consultez the section called “Configuration de l'inférenceMachine Learning” (p. 164).

Fonctionnement de l'inférence de Machine LearningAWS Greengrass

Vous pouvez former vos modèles d'inférence n'importe où, les déployer localement en tant que ressourcesde Machine Learning dans un groupe Greengrass, puis y accéder à partir des fonctions LambdaGreengrass. Vous pouvez par exemple créer et former des modèles d'apprentissage profond dans AmazonSageMaker et les déployer dans votre appareil Greengrass principal. Vos fonctions Lambda peuventensuite utiliser les modèles locaux pour exécuter l'inférence sur des appareils connectés et renvoyer denouvelles données de formation vers le cloud.

Le schéma suivant illustre le flux de travail de l'inférence de Machine Learning AWS Greengrass.

L'inférence de Machine Learning AWS Greengrass simplifie chaque étape du flux de travail de MachineLearning, y compris :

159

https://console.aws.amazon.com/sagemaker

https://console.aws.amazon.com/sagemaker

AWS Greengrass Guide de l'utilisateurRessources de Machine Learning

• La création et le déploiement de prototypes d'infrastructure de Machine Learning.• L'accès aux modèles formés dans le cloud et leur déploiement dans les appareils Greengrass principaux.• La création d'applications d'inférence pouvant accéder à des accélérateurs matériels (tels que des GPU

et des FPGA) en tant que ressources locales (p. 134).

Ressources de Machine LearningLes ressources de Machine Learning représentent des modèles d'inférence formés dans le cloudet déployés dans un Noyau AWS Greengrass. Pour déployer des ressources de Machine Learning,commencez par ajouter les ressources à un groupe Greengrass, puis définissez la méthode d'accès desfonctions Lambda à ces ressources. Pendant le déploiement de groupe, AWS Greengrass récupère lespackages de modèles source dans le cloud et les extrait dans les répertoires à l'intérieur de l'espace denoms d'exécution Lambda. Les fonctions Lambda Greengrass utilisent ensuite les modèles déployéslocalement pour exécuter l'inférence.

Pour mettre à jour un modèle déployé localement, commencez par mettre à jour le modèle source (dansle cloud) qui correspond à la ressource de Machine Learning, puis déployez le groupe. Pendant ledéploiement, AWS Greengrass vérifie si la source a fait l'objet de modifications. Si des modifications sontdétectées, AWS Greengrass met à jour le modèle local.

Sources de modèles prises en chargeAWS Greengrass prend en charge les sources de modèles Amazon SageMaker et Amazon S3 pour lesressources de Machine Learning.

Les exigences suivantes s'appliquent aux sources de modèles :

• Les compartiments S3 qui stockent vos sources de modèles Amazon SageMaker et Amazon S3 nedoivent pas être chiffrés à l'aide de SSE-C. Pour les compartiments qui utilisent le chiffrement côtéserveur, l'inférence de Machine Learning AWS Greengrass prend actuellement en charge les options dechiffrement SSE-S3 ou SSE-KMS uniquement. Pour plus d'informations sur les options de chiffrementcôté serveur, consultez la section Protection des données à l'aide du chiffrement côté serveur du Amazon Simple Storage Service Manuel du développeur.

• Les noms des compartiments S3 qui stockent vos sources de modèles Amazon SageMaker et AmazonS3 ne doivent pas contenir de points (« . »). Pour plus d'informations, consultez la règle d'utilisation descompartiments d'hébergement virtuel avec SSL dans la section Règles relatives à l'attribution des nomsde compartiments du Amazon Simple Storage Service Manuel du développeur.

• La prise en charge des services au niveau des régions est disponible comme suit :• Les sources de modèles Amazon SageMaker sont prises en charge uniquement dans les régions

prenant en charge AWS Greengrass et Amazon SageMaker.• Les sources de modèles Amazon S3 sont prises en charge uniquement dans les régions prenant en

charge AWS Greengrass et Amazon S3.• AWS Greengrass doit disposer de l'autorisation read pour la source de modèle, comme décrit dans les

sections suivantes.

Amazon SageMaker

AWS Greengrass prend en charge les modèles enregistrés comme tâches de formation AmazonSageMaker.

Si vous avez configuré votre environnement Amazon SageMaker en créant un compartimentdont le nom contient sagemaker, alors AWS Greengrass dispose des autorisationsrequises pour accéder à vos tâches de formation Amazon SageMaker. La stratégie

160

http://docs.aws.amazon.com/AmazonS3/latest/dev/serv-side-encryption.html

http://docs.aws.amazon.com/AmazonS3/latest/dev/BucketRestrictions.html#bucketnamingrules

http://docs.aws.amazon.com/AmazonS3/latest/dev/BucketRestrictions.html#bucketnamingrules


http://docs.aws.amazon.com/general/latest/gr/rande.html#sagemaker_region


http://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region

http://docs.aws.amazon.com/sagemaker/latest/dg/gs-config-permissions.html

AWS Greengrass Guide de l'utilisateurSources de modèles prises en charge

AWSGreengrassResourceAccessRolePolicy gérée permet d'accéder aux compartiments dont le nomcontient la chaîne sagemaker. Cette stratégie est attachée au rôle de service Greengrass.

Dans le cas contraire, vous devez accorder à AWS Greengrass l'autorisation read pour lecompartiment dans lequel votre tâche de formation est stockée. Pour ce faire, intégrez la stratégieen ligne suivante dans le rôle de service Greengrass. Vous pouvez répertorier plusieurs ARN decompartiment.

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "s3:GetObject" ], "Resource": [ "arn:aws:s3:::my-bucket-name" ] } ]}

Note

Amazon SageMaker est un service de Machine Learning entièrement géré qui vous permetde créer et de former des modèles à l'aide d'algorithmes intégrés ou personnalisés. Pourplus d'informations, consultez la section Qu'est-ce que Amazon SageMaker du Manuel dudéveloppeur Amazon SageMaker.

Amazon S3

AWS Greengrass prend en charge les modèles stockés dans Amazon S3 au format tar.gz ou .zip.

Pour permettre à AWS Greengrass d'accéder aux modèles stockés dans des compartiments AmazonS3, vous devez accorder à AWS Greengrass l'autorisation read pour lui permettre d'accéder auxcompartiments en effectuant l'une des actions suivantes :• Stockez votre modèle dans un compartiment dont le nom contient greengrass.

La stratégie AWSGreengrassResourceAccessRolePolicy gérée permet d'accéder auxcompartiments dont le nom contient la chaîne greengrass. Cette stratégie est attachée au rôle deservice Greengrass.

• Intégrez une stratégie en ligne dans le rôle de service Greengrass.

Si le nom de votre compartiment ne contient pas greengrass, ajoutez la stratégie en ligne suivanteau rôle de service. Vous pouvez répertorier plusieurs ARN de compartiment.

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "s3:GetObject" ], "Resource": [ "arn:aws:s3:::my-bucket-name" ] }

161

http://docs.aws.amazon.com/sagemaker/latest/dg/whatis.html


]}

Pour plus d'informations, consultez la section Intégration des stratégies en ligne du IAM Guide del'utilisateur.

PrérequisLes exigences suivantes s'appliquent pour la création et l'utilisation des ressources de Machine Learning :

• Vous devez utiliser le logiciel AWS Greengrass Core v1.5.0.• L'accès au répertoire de destination local dans lequel la ressource est stockée ne nécessite pas de

privilèges racine.• Les fonctions Lambda ne peuvent pas effectuer d'opérations privilégiées sur la ressource. Seules les

autorisations read ou read and write sont disponibles.• Vous devez fournir le chemin d'accès complet de la ressource sur le système d'exploitation de l'appareil

principal.• Un ID ou un nom de ressource doit comporter 128 caractères au maximum et utiliser le modèle [a-zA-Z0-9:_-]+.

Bibliothèques précompilées pour les infrastructuresde Machine Learning

Pour vous aider à commencer rapidement à tester l'inférence de Machine Learning (ML), AWS Greengrassfournit des bibliothèques précompilées pour les infrastructures de Machine Learning suivantes.

• Apache MXNet (licence Apache 2.0)• TensorFlow (licence Apache 2.0)• Chainer (licence MIT)

Les bibliothèques MXNet et TensorFlow précompilées peuvent être installées sur les plateformes NVIDIAJetson TX2, Intel Atom et Raspberry Pi. Les bibliothèques sont disponibles sur la page Logiciel de laConsole IoT AWS. Vous pouvez les installer directement sur votre appareil principal ou les intégrer aulogiciel de votre groupe Greengrass.

Assurez-vous de lire les informations de compatibilités et les limitations suivantes.

Gestion des versions MXNetApache MXNet ne garantit actuellement pas une compatibilité ascendante. Par conséquent, les modèlesque vous formez à l'aide de versions ultérieures de l'infrastructure peuvent ne pas fonctionner correctementdans des versions antérieures de l'infrastructure. Pour éviter les conflits entre les étapes de formationet d'utilisation des modèles, et pour garantir une expérience uniforme de bout en bout, utilisez la mêmeversion d'infrastructure MXNet à chaque étape.

Note

Nous vous recommandons d'utiliser MXNet v0.11 pour l'inférence de Machine Learning AWSGreengrass. Pour configurer Amazon SageMaker afin de former des modèles à l'aide de laversion recommandée, consultez Comment configurer Amazon SageMaker pour utiliser MXNetv0.11 (p. 163).

162

http://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html#embed-inline-policy-console

https://aws.amazon.com/mxnet/

https://aws.amazon.com/tensorflow/

AWS Greengrass Guide de l'utilisateurLimitations d'utilisation des modèles

TensorFlow sur Raspberry Pi

Limitations d'utilisation des modèles TensorFlow surRaspberry PiTensorFlow ne prend officiellement en charge que l'installation sur des ordinateurs portables 64 bits ou dessystèmes d'exploitation de bureau. Par conséquent, les bibliothèques TensorFlow précompilées fourniespar AWS Greengrass pour les plateformes ARM 32 bits (comme Raspberry Pi) possèdent des limitesinhérentes et sont destinées à des fins d'expérimentation uniquement.

Les recommandations suivantes visent à améliorer les résultats d'inférence et sont basées sur lestests réalisés avec les bibliothèques précompilées ARM 32 bits sur la plateforme Raspberry Pi. Cesrecommandations sont destinées aux utilisateurs avancés pour référence uniquement, sans garantied'aucune sorte.

• Les modèles formés à l'aide du format Checkpoint doivent être « bloqués » dans le format tampondu protocole avant d'être utilisés. Pour obtenir un exemple, consultez la bibliothèque du modèle declassification d'images TensorFlow-Slim.

• N'utilisez pas les bibliothèques TF-Estimator et TF-Slim dans le code de formation ou d'inférence. À laplace, utilisez le modèle de chargement de fichier .pb indiqué dans l'exemple suivant.

graph = tf.Graph() graph_def = tf.GraphDef()graph_def.ParseFromString(pb_file.read()) with graph.as_default(): tf.import_graph_def(graph_def)

Note

Pour plus d'informations sur les plateformes prises en charge pour TensorFlow, consultez lasection Installation de TensorFlow dans la documentation TensorFlow.

Comment configurer Amazon SageMaker pourutiliser MXNet v0.11

Cette section décrit comment configurer Amazon SageMaker pour former des modèles à l'aide de MXNetv0.11. Il s'agit de la version recommandée pour l'inférence de Machine Learning AWS Greengrass.

1. Créez un compartiment Amazon S3 en suivant la procédure Créer un compartiment du Guide del'utilisateur de la console Amazon Simple Storage Service.

Assurez-vous d'inclure sagemaker dans le nom (par exemple, sagemaker-datetime).2. Créez une instance de bloc-notes Amazon SageMaker en suivant la procédure Créer une instance de

bloc-notes Amazon SageMaker du Manuel du développeur Amazon SageMaker.3. Lorsque l'état de l'instance de bloc-notes indique InService (En service), choisissez l'action Open

(Ouvrir) pour votre instance de bloc-notes.4. Choisissez New (Nouveau), puis conda_mxnet_p27 dans la liste des noyaux Jupyter. Cette opération

permet d'ouvrir un environnement MXNet pour Python 2.7.5. Remplacez le champ par défaut sagemaker.mxnet.MXNet.train_image dans le code par une image de

conteneur MXNet v0.11, comme suit :

a. Dans le code suivant, remplacez la valeur d'espace réservé container-image par l'image deconteneur MXNet v0.11 que vous souhaitez utiliser :

163

https://www.tensorflow.org/get_started/checkpoints

https://github.com/tensorflow/models/tree/master/research/slim

https://github.com/tensorflow/models/tree/master/research/slim

https://www.tensorflow.org/install/#installing_from_sources

http://docs.aws.amazon.com/AmazonS3/latest/user-guide/create-bucket.html

http://docs.aws.amazon.com/sagemaker/latest/dg/gs-setup-working-env.html

http://docs.aws.amazon.com/sagemaker/latest/dg/gs-setup-working-env.html

AWS Greengrass Guide de l'utilisateurConfiguration de l'inférence Machine Learning

• Pour MXNet v0.11 sur Python2.7 avec une UC, spécifiez sagemaker-mxnet-py2-cpu.• Pour MXNet v0.11 sur Python2.7 avec un GPU, spécifiez sagemaker-mxnet-py2-gpu.• Pour MXNet v0.11 sur Python3.6 avec une UC, spécifiez sagemaker-mxnet-py3-cpu.• Pour MXNet v0.11 sur Python3.6 avec un GPU, spécifiez sagemaker-mxnet-py3-gpu.

region = sagemaker_session.boto_session.region_namemnist_estimator.train_image = lambda:'780728360657.dkr.ecr.{}.amazonaws.com/container-image:1.0'.format(region)

b. Inser le code avant l'appel de sagemaker.mxnet.MXNet.fit, qui envoie une demandeCreateTrainingJob à Amazon SageMaker à l'aide de l'image de conteneur MXNet v0.11.Cette opération remplace l'image v0.12 par défaut par l'image v0.11.

L'exemple suivant montre un exemple d'extrait de code de formation MXNet avec le nouveau codeen surbrillance.

Vous pouvez maintenant poursuivre la formation du modèle comme décrit dans la documentation AmazonSageMaker.

Configuration de l'inférence Machine Learning àl'aide d'AWS Management Console

Cette fonction est disponible pour AWS Greengrass Core v1.5.0 uniquement.

Vous pouvez exécuter l'inférence Machine Learning (ML) localement sur un appareil Greengrass principalà l'aide des données provenant d'appareils connectés. Pour en savoir plus, notamment sur les exigences etcontraintes, consultez la page Exécuter l'inférence de Machine Learning (p. 159).

164


Ce didacticiel explique comment utiliser AWS Management Console pour configurer un groupe Greengrassafin d'exécuter une application d'inférence Lambda qui reconnaît localement les images d'une caméra,sans avoir à envoyer des données dans le cloud. L'application d'inférence accède au module caméra surun Raspberry Pi et exécute l'inférence à l'aide du modèle open source SqueezeNet.

Le didacticiel contient les étapes détaillées suivantes :

1. Configuration du Raspberry Pi (p. 165)2. Installation de l'infrastructure MXNet (p. 166)3. Création d'un package de modèle (p. 168)4. Création et publication d'une fonction Lambda (p. 168)5. Ajout de la fonction Lambda au groupe (p. 173)6. Ajout de ressources au groupe (p. 175)7. Ajout d'un abonnement au groupe (p. 178)8. Déploiement du groupe (p. 180)

PrérequisPour suivre ce didacticiel, vous devez disposer des éléments suivants :

• Raspberry Pi 3 Modèle B.• Module caméra V2 du Raspberry Pi - 8 mégapixels, 1080p. Pour savoir comment configurer la caméra,

consultez la section Connexion de la caméra dans la documentation du Raspberry Pi.• Un groupe Greengrass et un service principal Greengrass. Pour savoir comment créer un groupe ou un

service principal Greengrass, consultez Démarrez avec AWS Greengrass (p. 31). La section Démarrezcomprend également les étapes pour l'installation du logiciel AWS Greengrass Core sur un Raspberry Pi.

Note

Ce didacticiel utilise un Raspberry Pi, mais AWS Greengrass prend en charge d'autres plates-formes, telles qu'Intel Atom et NVIDIA Jetson TX2 (p. 185).

Étape 1 : configuration du Raspberry PiAu cours de cette étape, vous mettez à jour le système d'exploitation Rasbian, installez le logiciel dumodule caméra et les dépendances Python, puis activez l'interface de la caméra. Dans la fenêtre determinal de votre Raspberry Pi, exécutez les commandes suivantes :

1. Mettez à jour Raspbian Jessie.

sudo apt-get updatesudo apt-get dist-upgrade

2. Installez l'interface Picamera pour le module caméra, ainsi que les autres bibliothèques Pythonrequises pour ce didacticiel.

sudo apt-get install -y python-dev python-setuptools python-pip python-picamera

3. Redémarrez l'appareil Raspberry Pi.

sudo reboot

4. Ouvrez l'outil de configuration du Raspberry Pi.

165

https://github.com/DeepScale/SqueezeNet

https://www.raspberrypi.org/products/raspberry-pi-3-model-b/#buy-now-modal

https://www.amazon.com/Raspberry-Pi-Camera-Module-Megapixel/dp/B01ER2SKFS

https://www.raspberrypi.org/documentation/usage/camera/

AWS Greengrass Guide de l'utilisateurInstallation de l'infrastructure MXNet

sudo raspi-config

5. Utilisez les touches flèches pour ouvrir les Options d'interface et activer l'interface de la caméra. Sivous y êtes invité, autorisez le redémarrage de l'appareil.

6. Utilisez la commande suivante pour tester la configuration de la caméra.

raspistill -v -o test.jpg

Elle ouvre une fenêtre d'aperçu sur le Raspberry Pi, enregistre une image nommée test.jpg dansvotre répertoire /home/pi et affiche des informations sur la caméra dans la fenêtre de terminal duRaspberry Pi.

Étape 2 : installation de l'infrastructure MXNetAu cours de cette étape, vous téléchargez les bibliothèques Apache MXNet précompilées et vous lesinstallez sur votre Raspberry Pi.

Note

Ce didacticiel utilise les bibliothèques pour l'infrastructure d'apprentissage automatique MXNet,mais les bibliothèques pour TensorFlow sont également disponibles. Pour en savoir plus,notamment sur les limites, consultez la section the section called “Bibliothèques précompiléespour les infrastructures de Machine Learning” (p. 162).

1. Ouvrez la console Console IoT AWS sur votre ordinateur.2. Dans le volet de gauche, choisissez Logiciels.

166

https://console.aws.amazon.com/iotv2

AWS Greengrass Guide de l'utilisateurInstallation de l'infrastructure MXNet

3. Dans la section Bibliothèques d'apprentissage machine, pour Bibliothèques précompilées MXNet/TensorFlow, choisissez Configurer le téléchargement.

4. Sur la page Machine learning libraries (Bibliothèques d'apprentissage machine), sous Softwareconfigurations (Configurations logicielles), pour MXNet Raspberry Pi version 0.11.0, choisissezDownload (Télécharger).

Note

"En téléchargeant ce logiciel, vous acceptez la licence Apache 2.0.5. Transférez le fichier ggc-mxnet-v0.11.0-python-raspi.tar.gz téléchargé depuis votre

ordinateur vers votre Raspberry Pi.

Note

Consultez cette étape (p. 50) dans la section Démarrez pour découvrir comment procéder enfonction des différentes plates-formes. Par exemple, vous pouvez utiliser la commande scpsuivante :

scp ggc-mxnet-v0.11.0-python-raspi.tar.gz pi@IP-address:/home/pi

6. Sur votre terminal Raspberry Pi, décompressez le fichier transféré.

tar -xzf ggc-mxnet-v0.11.0-python-raspi.tar.gz

7. Installez l'infrastructure MDXNet

167

https://www.apache.org/licenses/LICENSE-2.0

AWS Greengrass Guide de l'utilisateurCréation d'un package de modèle

./mxnet_installer.sh

Note

Vous pouvez passer à l'the section called “Création d'un package de modèle” (p. 168)pendant l'installation de l'infrastructure mais vous devez attendre que l'installation soitterminée avant de passer à l'the section called “Création et publication d'une fonctionLambda” (p. 168).Si vous le souhaitez, vous pouvez exécuter des tests unitaires pour vérifier l'installation.Pour ce faire, ajoutez l'option -u à la commande précédente. En cas de réussite, chaquetest consigne une ligne dans le terminal qui se termine par ok. Si tous les tests sont réussis,l'instruction de journalisation finale contient la mention OK. Notez que l'exécution des testsunitaires augmente le temps d'installation.

Le script crée également un package de déploiement de la fonction Lambda nommégreengrassObjectClassification.zip. Ce package contient le code et les dépendances dela fonction, y compris le module mxnet Python que les fonctions Greengrass Lambda doivent utiliseravec les modèles MXNet. Vous chargerez ce package de déploiement plus tard.

8. Une fois l'installation terminée, transférez greengrassObjectClassification.zip sur votreordinateur. En fonction de votre environnement, vous pouvez utiliser la commande scp ou un utilitairetel que WinSCP.

Étape 3 : création d'un package de modèle MXNetAu cours de cette étape, vous téléchargez des fichiers pour un exemple de modèle MXNet préformé, puisvous les enregistrez en tant que fichier .zip. AWS Greengrass peut utiliser les modèles à partir d'AmazonS3, à condition qu'ils utilisent le format tar.gz ou .zip.

1. Téléchargez les fichiers suivants sur votre ordinateur :

• squeezenet_v1.1-0000.params. Un fichier de paramètres qui décrit les pondérations de laconnectivité.

• squeezenet_v1.1-symbol.json. Un fichier de symboles qui décrit la structure de réseau neuronal.• synset.txt. Un fichier synset qui mappe les ID de classe reconnus par des noms de classe lisibles

par l'utilisateur.

Note

Tous les packages de modèle MXNet utilisent ces trois types de fichiers, mais le contenu despackages de modèle TensorFlow varient.

2. Compressez les trois fichiers, et nommez le fichier compressé squeezenet.zip. Vous chargerez cepackage de modèle dans Amazon S3 à l'the section called “Ajout de ressources au groupe” (p. 175).

Étape 4 : création et publication d'une fonctionLambdaAu cours de cette étape, vous créez une fonction Lambda et vous la configurez afin qu'elle utilise lepackage de déploiement créé à l'Étape 2 : installation de l'infrastructure MXNet (p. 166). Vous publiezensuite une version de fonction et créez un alias.

168

https://winscp.net/eng/download.php

http://data.dmlc.ml/mxnet/models/imagenet/squeezenet/squeezenet_v1.1-0000.params

http://data.dmlc.ml/mxnet/models/imagenet/squeezenet/squeezenet_v1.1-symbol.json

http://data.dmlc.ml/mxnet/models/imagenet/synset.txt


Le package de déploiement de la fonction Lambda se nommegreengrassObjectClassification.zip. Il contient une application d'inférence qui exécute les tâchesles plus couramment utilisées, telles que le chargement des modèles, l'importation d'Apache MXNet ou lamise en œuvre d'actions d'après des prédictions. L'application comporte les composants clés suivants :

• Logique d'application :• load_model.py. Charge les modèles MXNet.• greengrassObjectClassification.py. Effectue des prédictions sur les images qui sont diffusées en

continu à partir de la caméra.• Dépendances:

• greengrasssdk. Bibliothèque requise pour toutes les fonctions Lambda Python.• mxnet. Bibliothèque requise pour les fonctions Lambda Python qui exécutent l'inférence locale à l'aide

de MXNet.• Licence:

• license. Comprend le contrat de licence du logiciel Greengrass Core requis.

Note

Vous pouvez réutiliser ces dépendances et la licence lorsque vous créez de nouvelles fonctionsLambda d'inférence MXNet.

Créez d'abord la fonction Lambda.

1. Dans la Console IoT AWS, dans le volet gauche, choisissez Greengrass, puis choisissez Groupes.

2. Choisissez le groupe Greengrass auquel vous souhaitez ajouter la fonction Lambda.

169


3. Sur la page de configuration de groupe, choisissez Lambdas, puis Ajouter une expression lambda.

4. Sur la page Ajouter une fonction Lambda au groupe Greengrass, choisissez Créer nouvelle fonctionLambda. Vous accédez alors à la console AWS Lambda.

5. Choisissez Author from scratch.6. Dans la section Author from scratch, utilisez les valeurs suivantes :

Propriété Value

Nom greengrassObjectClassification

Runtime Python 2.7

Rôle Créer un rôle à partir de modèles

Nom de rôle

(Ce rôle n'est pas utilisé par AWS Greengrass.)

Greengrass_role_does_not_matter

7. Dans le bas de la page, choisissez Create function.

170


Téléchargez maintenant le package de déploiement de votre fonction Lambda et enregistrez legestionnaire.

1. Dans l'onglet Configuration pour la fonction greengrassObjectClassification, utilisez les valeurssuivantes pour le Code de fonction :

Propriété Value

Type d'entrée de code Charger un fichier ZIP

Runtime Python 2.7

Gestionnaire greengrassObjectClassification.function_handler

2. Choisissez Upload.

171


3. Choisissez votre package de déploiement greengrassObjectClassification.zip.4. Dans le haut de la page, choisissez Enregistrer.

Publiez ensuite la première version de votre fonction Lambda. Puis, créez un alias pour la version.

Note

Les groupes Greengrass peuvent référencer une fonction Lambda par alias (recommandé) ou parversion. L'utilisation d'un alias facilite la gestion des mises à jour de code, car vous n'avez pasbesoin de changer votre tableau d'abonnement ou votre définition de groupe lorsque le code defonction est mis à jour. Il suffit de faire pointer l'alias vers la nouvelle version de la fonction.

1. Dans le menu Actions, sélectionnez Publish new version.

2. Pour Version description, saisissez First version, puis choisissez Publication.3. Sur la page de configuration greengrassObjectClassification: 1, dans le menu Actions, choisissez

Create alias.

4. Sur la page Create a new alias, utilisez les valeurs suivantes :

Propriété Value

Nom mlTest

Version 1

Note

AWS Greengrass ne prend pas en charge les alias Lambda pour les versions $LATEST.5. Sélectionnez Create.

172



Ajoutez maintenant la fonction Lambda à votre groupe Greengrass.

Étape 5 : Ajout de la fonction Lambda au groupeGreengrassAu cours de cette étape, vous ajoutez la fonction Lambda au groupe, puis configurez son cycle de vie.

Ajoutez d'abord la fonction Lambda à votre groupe Greengrass.

1. Dans la Console IoT AWS, ouvrez la page de configuration du groupe.2. Choisissez Lambdas, puis Ajouter une fonction.

3. Sur la page Ajouter une fonction Lambda au groupe Greengrass, choisissez Utiliser une fonctionLambda existante.

173


4. Sur la page Utiliser une fonction Lambda existante, choisissez greengrassObjectClassification, puisSuivant.

5. Sur la page Sélectionner une version Lambda, choisissez Alias:mlTest, puis Terminer.

Configurez ensuite le cycle de vie de la fonction Lambda.

1. Sur la page Lambdas, choisissez la fonction Lambda greengrassObjectClassification.

2. Sur la page de configuration greengrassObjectClassification, choisissez Modifier.3. Sur la page Configuration Lambda spécifique au groupe, utilisez les valeurs suivantes :

Propriété Value

Limite de mémoire 96 Mo

Expiration 10 secondes

Cycle de vie Lambda Attribuer une longue durée de vie à cette fonctionet l'exécuter indéfiniment

Accès en lecture au répertoire /sys Activer

Pour plus d'informations, consultez the section called “Configuration de cycle de vie” (p. 131).

174

AWS Greengrass Guide de l'utilisateurAjout de ressources au groupe

4. Au bas de la page, sélectionnez Mettre à jour.

Étape 6 : ajout de ressources au groupe GreengrassAu cours de cette étape, vous créez des ressources pour le module caméra et le modèle d'inférence ML.Vous allez également associer les ressources à la fonction Lambda, ce qui permet à la fonction d'accéderaux ressources sur l'appareil principal.

Tout d'abord, créez deux ressources d'appareil local pour la caméra : un pour la mémoire partagée etl'autre pour l'interface de l'appareil. Pour plus d'informations sur l'accès aux ressources locales, consultezla page Accès aux ressources locales avec les fonctions Lambda (p. 134).

1. Sur la page de configuration de groupe, choisissez Ressources.

2. Sur l'onglet Local Resources (Ressources locales), choisissez Add local resource (Ajouter uneressource locale).

175


3. Sur la page Créer une ressource locale, utilisez les valeurs suivantes :

Propriété Value

Nom de la ressource videoCoreSharedMemory

Type de ressource Dispositif

Chemin de l'appareil /dev/vcsm



Le Chemin de l'appareil est le chemin absolu local de la ressource d'appareil. Ce chemin ne peut faireréférence qu'à un appareil caractère ou un périphérique de stockage en mode bloc sous /dev.

L'option Autorisation d'accès fichier pour le propriétaire du groupe vous permet d'accorder desautorisations supplémentaires d'accès aux fichiers au processus Lambda. Pour plus d'informations,consultez Autorisation d'accès fichier pour le propriétaire du groupe (p. 136).

4. Sous Affiliations de fonction Lambda, choisissez Sélectionner.5. Choisissez greengrassObjectClassification, choisissez Accès en lecture et en écriture, puis Effectué.

Ensuite, vous ajoutez une ressource d'appareil local pour l'interface de la caméra.6. Au bas de la page, choisissez Ajouter une autre ressource.7. Sur la page Créer une ressource locale, utilisez les valeurs suivantes :

176


Propriété Value

Nom de la ressource videoCoreInterface

Type de ressource Dispositif

Chemin de l'appareil /dev/vchiq



8. Sous Affiliations de fonction Lambda, choisissez Sélectionner.9. Choisissez greengrassObjectClassification, choisissez Accès en lecture et en écriture, puis Effectué.10. Au bas de la page, sélectionnez Save.

Ajoutez à présent le modèle d'inférence en tant que ressource d'apprentissage automatique. Cette étapeinclut le chargement du package de modèle squeezenet.zip dans Amazon S3.

1. Sur l'onglet Machine Learning, choisissez Ajouter une ressource d'apprentissage automatique.2. Sur la page Créer une ressource de Machine Learning, comme Nom de ressource, tapez

squeezenet_model.3. Pour Source de modèle, choisissez Rechercher ou charger un modèle dans S3.4. Sous Modèle de S3, choisissez Sélectionner, puis choisissez Créer un compartiment S3.

177

AWS Greengrass Guide de l'utilisateurAjout d'un abonnement au groupe

5. Pour Nom du compartiment, saisissez un nom contenant la chaîne greengrass (par exemple,greengrass-datetime), puis choisissez Créer.

Note

N'utilisez pas de point (".") dans le nom du compartiment.6. Choisissez Charger un modèle, puis choisissez le package squeezenet.zip que vous avez créé

dans the section called “Création d'un package de modèle” (p. 168).7. Pour Chemin local, tapez /greengrass-machine-learning/mxnet/squeezenet.

Il s'agit de la destination pour le modèle local dans l'espace de noms d'exécution Lambda. Lorsquevous déployez le groupe, AWS Greengrass permet de récupérer le package de modèle source, puisd'extraire le contenu dans le répertoire spécifié. La fonction Lambda utilisé comme exemple dans cedidacticiel est déjà configurée pour utiliser ce chemin (dans la variable model_path).

8. Sous Affiliations de fonction Lambda, choisissez Sélectionner.9. Choisissez greengrassObjectClassification, choisissez Accès en lecture seule, puis Effectué.10. Au bas de la page, sélectionnez Save.

Utilisation des modèles formés Amazon SageMakerCe didacticiel utilise un modèle qui est stocké dans Amazon S3, mais vous pouvez aussi utiliser lesmodèles Amazon SageMaker très facilement. La console Greengrass possède une intégration AmazonSageMaker. Vous n'avez donc pas besoin de charger manuellement ces modèles dans Amazon S3. Pourconnaître les exigences et limitations relatives à l'utilisation de modèles Amazon SageMaker, consultez lasection the section called “Sources de modèles prises en charge” (p. 160).

Pour utiliser un modèle Amazon SageMaker :

• Pour la Source de modèle, choisissez Utiliser un modèle SageMaker existant, puis choisissez le nom dela tâche de formation du modèle.

• Pour le Chemin local, saisissez le chemin d'accès au répertoire dans lequel votre fonction Lambdarecherche le modèle.

Étape 7 : ajout d'un abonnement au groupeGreengrassDans cette étape, vous ajoutez un abonnement au groupe. Cet abonnement permet à la fonction Lambdad'envoyer les résultats des prédictions à AWS IoT en publiant dans une rubrique MQTT.

178

AWS Greengrass Guide de l'utilisateurAjout d'un abonnement au groupe


2. Sur la page Sélectionnez la source et la cible, configurez la source et la cible comme suit :

a. Dans Sélectionnez une source, choisissez Lambdas, puis greengrassObjectClassification.b. Dans la section Sélectionnez une cible, choisissez Services, puis IoT Cloud.c. Choisissez Suivant.

3. Sur la page Filtrez vos données avec une rubrique, dans le champ Filtre de rubrique facultatif,saisissez hello/world, puis choisissez Suivant.

4. Choisissez Finish.

179


Étape 8 : déploiement du groupe GreengrassAu cours de cette étape, vous déployez la version actuelle de la définition de groupe sur l'appareilGreengrass principal. La définition contient la fonction Lambda, les ressources et les configurationsd'abonnement que vous avez ajoutées.

1. Assurez-vous que l'appareil Noyau AWS Greengrass est en cours d'exécution. Dans la fenêtre determinal de votre Raspberry Pi, exécutez les commandes suivantes, si nécessaire.




Note

La version du chemin d'accès dépend de la version du logiciel AWS Greengrass Coreinstallée sur votre appareil principal.



2. Sur la page de configuration du groupe, choisissez Déploiements puis, dans le menu Actions,choisissez Déployer.

3. Sur la page Configuration du mode de détection de votre noyau par les appareils, choisissez Détectionautomatique.

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, maisAWS Greengrass prend é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.

180

AWS Greengrass Guide de l'utilisateurVérification de l'application

Note

Si vous y êtes invité, accordez l'autorisation de créer le rôle de service AWS Greengrassen votre nom, ce qui permet à AWS Greengrass d'accéder à d'autres services AWS. Cetteopération ne doit être effectuée qu'une seule fois par compte.

La page Déploiements indique l'horodatage, l'ID de version et l'état du déploiement. Une fois terminé,le déploiement doit afficher l'état Successfully completed.


Vérification de l'application d'inférenceÀ présent, vous pouvez vérifier si le déploiement est correctement configuré. Pour procéder au test,abonnez-vous à la rubrique hello/world et visualisez les résultats des prédictions publiés par la fonctionLambda.

Note

Si un écran est attaché au Raspberry Pi, le flux de la caméra est diffusé en direct dans une fenêtred'aperçu.

1. Sur la page Console IoT AWS, sélectionnez Test.

181


2. Pour Abonnements, utilisez les valeurs suivantes :

Propriété Value

rubrique abonnement hello/world

Affichage de la charge utile MQTT Affichage des charges utiles sous forme dechaînes

3. Choisissez S'abonner à la rubrique.

Si le test est réussi, les messages issus de la fonction Lambda apparaissent au bas de la page.Chaque message contient les cinq premiers résultats des prédictions de l'image, en utilisant le formatsuivant : probabilité, ID de classe prédite et nom de classe correspondante.

182


Dépannage de l'inférence ML AWS GreengrassSi le test n'est pas réussi, vous pouvez essayer les étapes de dépannage suivantes. Dans la fenêtre determinal de votre Raspberry Pi, exécutez les commandes suivantes.

Vérifiez les journaux d'erreur

1. Basculez vers l'utilisateur racine.

sudo su

2. Accédez au répertoire /log.

cd /greengrass/ggc/var/log

3. Vérifiez runtime.log ou python_runtime.log.

Pour plus d'informations, consultez the section called “Résolution des problèmes avec lesjournaux” (p. 208).

Erreur de « décompression » dans le fichier runtime.log

Si runtime.log contient une erreur similaire à ce qui suit, assurez-vous que votre package de modèlesource tar.gz possède un répertoire parent.

Greengrass deployment error: unable to download the artifact model-arn: Error while processing. Error while unpacking the file from /tmp/greengrass/artifacts/model-arn/path to /greengrass/ggc/deployment/path/model-arn,error: open /greengrass/ggc/deployment/path/model-arn/squeezenet/squeezenet_v1.1-0000.params: no such file or directory

Si votre package n'a pas de répertoire parent qui contient les fichiers de modèle, essayez de réorganiser lemodèle à l'aide de la commande suivante :

tar -zcvf model.tar.gz ./model

183


Exemples :

#$ tar -zcvf test.tar.gz ./test./test./test/some.file./test/some.file2./test/some.file3

Note

N'incluez pas les caractères de fin /* dans cette commande.

Vérifiez que la fonction Lambda a été déployée avec succès

1. Affichez le contenu de la fonction Lambda déployée dans le répertoire/lambda. Remplacez les valeursd'espace réservé avant d'exécuter la commande.

cd /greengrass/ggc/deployment/lambda/arn:aws:lambda:region:account:function:function-name:function-versionls -la

2. Vérifiez que le répertoire contient le même contenu que le package de déploiementgreengrassObjectClassification.zip que vous avez chargé à l'Étape 4 : création et publication d'unefonction Lambda (p. 168).

Assurez-vous également que les fichiers et les dépendances .py se trouvent dans la racine durépertoire.

Vérifiez que le modèle d'inférence a été déployé avec succès

1. Trouvez le numéro d'identification de processus (PID) du processus d'exécution Lambda :

ps aux | grep lambda-function-name

Dans la sortie, le PID s'affiche dans la deuxième colonne de la ligne pour le processus d'exécutionLambda.

2. Saisissez l'espace de noms d'exécution Lambda. Veillez à remplacer la valeur d'espace réservé pidavant d'exécuter la commande.

Note

Ce répertoire et son contenu se trouvent dans l'espace de noms d'exécution Lambda ; parconséquent, ils ne sont pas visibles dans un espace de noms Linux classique.

sudo nsenter -t pid -m /bin/bash

3. Affichez le contenu du répertoire local que vous avez spécifié comme ressource de ML.

cd /greengrass-machine-learning/mxnet/squeezenet/ls -ls

Vous devriez voir les fichiers suivants :

184

AWS Greengrass Guide de l'utilisateurÉtapes suivantes

32 -rw-r--r-- 1 ggc_user ggc_group 31675 Nov 18 15:19 synset.txt32 -rw-r--r-- 1 ggc_user ggc_group 28707 Nov 18 15:19 squeezenet_v1.1-symbol.json4832 -rw-r--r-- 1 ggc_user ggc_group 4945062 Nov 18 15:19 squeezenet_v1.1-0000.params

Étapes suivantesEnsuite, explorez les autres applications d'inférence. AWS Greengrass propose d'autres fonctions Lambdaque vous pouvez utiliser pour tester l'inférence locale. Vous pouvez trouver les packages d'exemple dansle dossier des bibliothèques précompilées que vous avez téléchargé à l'the section called “Installation del'infrastructure MXNet” (p. 166).

Configuration d'un NVIDIA Jetson TX2Pour exécuter ce didacticiel sur le GPU d'un NVIDIA Jetson TX2, vous devez ajouter d'autres ressourcesd'appareil local et configurer l'accès pour la fonction Lambda.

Note

Votre Jetson doit être configuré avant de pouvoir installer le logiciel AWS Greengrass Core. Pourplus d'informations, consultez Configuration de NVIDIA Jetson TX2 pour AWS Greengrass (p. 42).

1. Ajoutez les ressources d'appareil local suivantes. Suivez la procédure décrite à l'étape Ajout deressources au groupe (p. 175).

Pour chaque ressource :

• Pour Type de ressource, choisissez Appareil.• Pour Autorisation d'accès fichier pour le propriétaire du groupe, choisissez Ajouter automatiquement

les autorisations de groupe de système d'exploitation du groupe Linux qui possède la ressource.• Pour Affiliations de fonction Lambda, accorder un Accès en lecture et en écriture à votre fonction

Lambda.

Nom Chemin de l'appareil

nvhost-ctrl /dev/nvhost-ctrl

nvhost-gpu /dev/nvhost-gpu

nvhost-ctrl-gpu /dev/nvhost-ctrl-gpu

nvhost-dbg-gpu /dev/nvhost-dbg-gpu

nvhost-prof-gpu /dev/nvhost-prof-gpu

nvmap /dev/nvmap

2. Modifiez la configuration de la fonction Lambda pour augmenter la Limite de mémoire à 1000 Mo.Suivez la procédure décrite à l'étape Ajout de la fonction Lambda au groupe (p. 173).

185

AWS Greengrass Guide de l'utilisateurRequête

API RESTful de découverte deGreengrass

Tous les appareils qui communiquent avec un Noyau AWS Greengrass doivent être membres d'un groupeGreengrass. Chaque groupe doit avoir un Noyau AWS Greengrass. L'API de découverte permet auxappareils de récupérer les informations requises pour se connecter à un Noyau AWS Greengrass setrouvant dans le même groupe Greengrass qu'eux. Lorsqu'un appareil est mis en ligne pour la premièrefois, il peut se connecter au service cloud AWS Greengrass et utiliser l'API de découverte pour trouver lesinformations suivantes :

• Le groupe auquel il appartient• L'adresse IP et le port du Noyau AWS Greengrass dans le groupe• Le certificat d'une autorité de certification racine du groupe, qui peut être utilisé pour authentifier l'appareil

Noyau AWS Greengrass

Pour utiliser cette API, envoyez des demandes HTTP à l'URI suivante :

https://greengrass.iot.aws-region.amazonaws.com/greengrass/discover/thing/thing-name

Utilisez le port 8443 pour la connexion. Pour obtenir la liste des régions et points de terminaison pris encharge pour l'API de découverte AWS Greengrass, consultez Régions et points de terminaison AWS dansle document Références générales AWS. Cette API est réservée aux plans de données. Les points determinaison pour la gestion de groupe et les opérations AWS IoT sont différents des points de terminaisonde l'API de découverte.

RequêteLa demande contient les en-têtes HTTP standard et est envoyée au point de terminaison de découverteGreengrass :

HTTP GET https://greengrass.iot.aws-region.amazonaws.com/greengrass/discover/thing/thing-name

RéponseRéponse

En cas de réussite, la réponse comprend les en-têtes HTTP standard, plus le code et le corps suivants :

HTTP 200BODY: response document

Pour de plus amples informations, consultez Exemple de documents de réponse à unedécouverte (p. 187).

186


AWS Greengrass Guide de l'utilisateurAutorisation

AutorisationLa récupération des informations de connectivité nécessite une stratégie qui permet au mandataire deréaliser l'action greengrass:Discover. L'authentification mutuelle TLS avec un certificat client estla seule forme d'authentification acceptée. Voici un exemple de stratégie qui autorise un mandataire àeffectuer cette action :

{ "Version": "2012-10-17", "Statement": [{ "Effect": "Allow", "Action": "greengrass:Discover", "Resource": ["arn:aws:iot:aws-region:aws-account:thing/thing-name"] }]}

Exemple de documents de réponse à unedécouverte

Le document suivant montre la réponse envoyée à un appareil qui appartient à un groupe possédant unNoyau AWS Greengrass, un point de terminaison et une CA de groupe :

{ "GGGroups": [ { "GGGroupId": "gg-group-01-id", "Cores": [ { "thingArn": "core-01-thing-arn", "Connectivity": [ { "id": "core-01-connection-id", "hostAddress": "core-01-address", "portNumber": core-01-port, "metadata": "core-01-description" } ] } ], "CAs": [ "-----BEGIN CERTIFICATE-----cert-contents-----END CERTIFICATE-----" ] } ]}

Le document suivant montre la réponse envoyée à un appareil qui appartient à deux groupes possédant unNoyau AWS Greengrass, plusieurs points de terminaison et plusieurs CA de groupe :

{ "GGGroups": [ { "GGGroupId": "gg-group-01-id", "Cores": [ { "thingArn": "core-01-thing-arn",

187

AWS Greengrass Guide de l'utilisateurExemple de documents de réponse à une découverte

"Connectivity": [ { "id": "core-01-connection-id", "hostAddress": "core-01-address", "portNumber": core-01-port, "metadata": "core-01-connection-1-description" }, { "id": "core-01-connection-id-2", "hostAddress": "core-01-address-2", "portNumber": core-01-port-2, "metadata": "core-01-connection-2-description" } ] } ], "CAs": [ "-----BEGIN CERTIFICATE-----cert-contents-----END CERTIFICATE-----", "-----BEGIN CERTIFICATE-----cert-contents-----END CERTIFICATE-----", "-----BEGIN CERTIFICATE-----cert-contents-----END CERTIFICATE-----" ] }, { "GGGroupId": "gg-group-02-id", "Cores": [ { "thingArn":"core-02-thing-arn", "Connectivity" : [ { "id": "core-02-connection-id", "hostAddress": "core-02-address", "portNumber": core-02-port, "metadata": "core-02-connection-1-description" } ], "CAs": [ "-----BEGIN CERTIFICATE-----cert-contents-----END CERTIFICATE-----", "-----BEGIN CERTIFICATE-----cert-contents-----END CERTIFICATE-----", "-----BEGIN CERTIFICATE-----cert-contents-----END CERTIFICATE-----" ] } ] }}

Note

Un groupe AWS Greengrass doit définir exactement un Noyau AWS Greengrass. Les réponsesdu service cloud AWS Greengrass qui contiennent une liste de cœurs AWS Greengrass necontiennent qu'un seul Noyau AWS Greengrass.

188

AWS Greengrass Guide de l'utilisateurPrésentation de l'architecture

Utiliser Greengrass OPC-UA pourcommuniquer avec des équipementsindustriels

Greengrass prend en charge la norme OPC-UA, qui définit l'échange d'informations dans unenvironnement industrialisé. Cette norme vous permet d'intégrer et de traiter les messages deséquipements industriels, et de les envoyer à des appareils de votre groupe Greengrass ou vers le cloud enfonction des règles que vous définissez.

L'implémentation Greengrass de la norme OPC-UA prend en charge l'authentification basée sur lescertificats. Elle repose sur une implémentation open source et est entièrement personnalisable. Vouspouvez également appliquer votre propre implémentation de cette norme, ainsi que mettre en œuvre votrepropre prise en charge pour d'autres protocoles de messageries personnalisés, hérités et propriétaires.

Cette section explique les procédures suivantes :

• Se connecter à un serveur OPC‑UA existant• Surveiller un nœud OPC-UA au sein de ce serveur• Être rappelé en cas de modification de la valeur du nœud surveillé

Présentation de l'architectureGreengrass implémente OPC-UA sous la forme d'une fonction Lambda dans NodeJS. Dans la mesureoù les fonctions Lambda exécutées sur les noyaux Greengrass ont accès aux ressources réseau, vouspouvez créer des fonctions Lambda qui feront office de proxy entre les informations de vos serveurs OPC-UA, via TCP, et les autres fonctions ou services de votre groupe Greengrass.

Vous pouvez configurer Greengrass pour disposer d'une connexion longue durée avec votre ou vosserveurs OPC-UA, et utiliser des abonnements OPC-UA pour que la fonction Lambda OPCUA_Adapter

189

AWS Greengrass Guide de l'utilisateurConfigurer un serveur OPC-UA de test

surveille les modifications apportées aux nœuds prédéfinis. Toute modification de ces nœuds déclenche unévénement Publier sur le serveur OPC-UA, qui sera transmis à votre fonction Lambda et republié dans desnoms de rubriques prédéfinis.

La structure des rubriques est la suivante :

Configurer un serveur OPC-UA de testUtilisez les commandes suivantes pour configurer un serveur OPC-UA de test. Si vous souhaitez utiliser àla place un serveur OPC-UA existant, vous pouvez ignorer cette étape.

git clone git://github.com/node-opcua/node-opcua.gitcd node-opcuagit checkout v0.0.64npm installnode bin/simple_server

Le serveur génère la sortie suivante :

[ec2-user@<your_instance_id> node-opcua]$ node bin/simple_server server PID : 28585

registering server to :opc.tcp://<your_instance_id>4840/UADiscoveryerr Cannot find module 'usage'skipping installation of cpu_usage and memory_usage nodes server on port : 26543 endpointUrl : opc.tcp://<your_instance_id>us-west-2.compute.internal:26543 serverInfo : applicationUri : urn:54f7890cca4c49a1:NodeOPCUA-Server productUri : NodeOPCUA-Server applicationName : locale=en text=NodeOPCUA applicationType : SERVER gatewayServerUri : null discoveryProfileUri : null discoveryUrls : productName : NODEOPCUA-SERVER buildInfo : productUri : NodeOPCUA-Server manufacturerName : Node-OPCUA : MIT Licence ( see http://node-opcua.github.io/) productName : NODEOPCUA-SERVER softwareVersion : 0.0.65 buildNumber : 1234 buildDate : Thu Aug 03 2017 00:13:50 GMT+0000 (UTC)

server now waiting for connections. CTRL+C to stop

190

AWS Greengrass Guide de l'utilisateurVérifier que le groupe Greengrass est prêt

Vérifier que le groupe Greengrass est prêt• Créez un groupe Greengrass (pour plus d'informations, voir Configuration d'AWS Greengrass sur AWS

IoT (p. 45)).• Configurez un noyau Greengrass sur l'une des plates-formes prises en charge (Raspberry-pi, par

exemple (p. 32)).• Configurez (p. 13) votre noyau Greengrass pour qu'il puisse exécuter les fonctions Lambda nodejs6.x.

Utiliser Greengrass OPC-UA pour interagir avec unserveur OPC-UA

1. Préparez votre fonction Lambda.

Obtenez le code de fonction Lambda d'un adaptateur OPC-UA auprès de GitHub :

git clone https://github.com/aws-samples/aws-greengrass-samples.gitcd aws-greengrass-samples/greengrass-opcua-adapter-nodejsnpm install

Remarque : cette fonction Lambda utilise la bibliothèque node-opcua (v0.0.64), qui tente de régénérerles fichiers de modèle lors de l'exécution. Cela ne fonctionne pas en cas d'exécution sous la formed'une fonction Lambda sur Greengrass, car ces fonctions démarrent par un système de fichiers enlecture seule. Par conséquent, les codes qui tentent de générer un autre code ne fonctionnent pas.L'étape suivante corrige ce problème.

2. Modifiez la ligne 109 du fichier node_modules/node-opcua/lib/misc/factories.js commesuit :

var generated_source_is_outdated = (!generated_source_exists);

Exécutez cette commande pour appliquer le changement :

sed -i '109s/.*/ var generated_source_is_outdated = (!generated_source_exists);/' node_modules/node-opcua/lib/misc/factories.js

3. Configurer le serveur et les nœuds surveillés

Modifiez la variable configSet dans le fichier index.js de la fonction Lambda OPC-UA pour yindiquer l'adresse IP et le port du serveur auquel vous voulez vous connecter, ainsi que les ID denœud que vous souhaitez surveiller. Par défaut, il est fourni avec l'exemple de configuration suivant :

const configSet = { server: { name: 'server', url: 'opc.tcp://localhost:26543', }, subscriptions: [ { name: 'MyPumpSpeed', nodeId: 'ns=1;s=PumpSpeed', }, ],

191

AWS Greengrass Guide de l'utilisateurUtiliser Greengrass OPC-UA pourinteragir avec un serveur OPC-UA

};

Dans cet exemple, nous nous connectons à un serveur OPC-UA s'exécutant sur le même hôteque notre noyau Greengrass, sur le port 26543, et surveillant un nœud associé à un ID OPC-UA'ns=1;s=PumpSpeed'.

4. Configurer le mode d'authentification

La bibliothèque OPC-UA utilisée dans cet exemple prend en charge trois modes d'authentification survotre serveur OPC-UA. La méthode la plus sécurisée est une authentification basée sur un certificat,mais la bibliothèque vous permet également de spécifier un nom d'utilisateur/mot de passe ou aucuneauthentification.

Voici comment définir une authentification basée sur un certificat :

• Intégrez votre certificat et la clé privée à votre fonction Lambda, par exemple dans un répertoirenommé certs/.

• Modifiez la variable clientOptions pour qu'elle contienne les options certificateFile,privateKeyFile, securityModes et securityPolicies :

const clientOptions = { keepSessionAlive: true, certificateFile: /lambda/certs/<certificate_name>.pem.crt, privateKeyFile: /lambda/certs/<private_key_name>.pem.key, securityModes: MessageSecurityMode.SIGN, securityPolicies: SecurityPolicy.BASIC256, connectionStrategy: { maxRetry: 1000000, initialDelay: 2000, maxDelay: 10 * 1000, }, };

5. Charger une fonction Lambda

Créez une fonction Lambda Greengrass. Vous pouvez trouver plus d'informations sur la procédurecorrespondante dans Configuration de la fonction Lambda pour AWS Greengrass (p. 60). En résumé,créez une archive de code de fonction Lambda en procédant comme suit :

# Download the nodejs greengrass sdk from # https://console.aws.amazon.com/iotv2/home?region=us-east-1#/software/greengrass/sdk.

# Install Greengrass SDK in the node_modules directorytar -zxvf aws-greengrass-core-sdk-js-*.tar.gz -C /tmp/unzip /tmp/aws_greengrass_core_sdk_js/sdk/aws-greengrass-core-sdk.zip -d node_modules

# Archive the whole directory as a zip filezip -r opcuaLambda.zip * -x \*.git\*

# Create an AWS Lambda with the created zipaws lambda create-function --function-name <Function_Name> --runtime 'nodejs6.10' --role <Your_Role> --handler 'index.handler' --zip-file opcuaLambda.zip

Ajoutez cette fonction Lambda à votre groupe Greengrass. Là encore, vous trouverez plus de détailsdans Configuration de la fonction Lambda pour AWS Greengrass (p. 60).

6. Configurer et déployer la fonction Lambda dans un groupe Greengrass

192

https://github.com/node-opcua/node-opcua

AWS Greengrass Guide de l'utilisateurVérifier que la fonction Lambda reçoit des

publications OPC-UA et les publie sur Greengrass

Après la création de votre fonction Lambda AWS, ajoutez-la à votre groupe Greengrass. Suivez lesinstructions indiquées dans la même section que précédemment.

• Veillez à spécifier la fonction Lambda comme étant de longue durée.• Affectez-lui au moins 64 Mo de mémoire.

Vous pouvez désormais créer un déploiement avec votre dernière configuration. Pour plus de détails,consultez Déploiement des configurations cloud sur un appareil AWS Greengrass Core (p. 66).

Vérifier que la fonction Lambda reçoit despublications OPC-UA et les publie sur Greengrass

Comme décrit dans la section Architecture (p. 189), votre fonction Lambda doit commencer à recevoirdes messages de votre serveur OPC-UA. Si vous utilisez votre propre serveur OPC-UA personnalisé,veillez à déclencher une modification dans l'ID du nœud OPC-UA que vous avez spécifié, de manière àvoir la modification reçue par votre fonction Lambda. Si vous utilisez l'exemple de serveur ci-dessus, lenœud PumpSpeed est configuré pour simuler une série de mises à jour consécutives. De cette façon, votrefonction Lambda devrait recevoir plusieurs messages par seconde.

Vous pouvez voir les messages reçus par votre fonction Lambda de deux manières :

• Regardez les journaux de la fonction Lambda

Vous pouvez consulter les journaux de votre fonction Lambda en exécutant la commande suivante :

sudo cat ggc/var/log/user/us-west-2/your_account_id/your_function_name.log

Ces journaux ressemblent à ceci :

[2017-11-14T16:33:09.05Z][INFO]-started subscription : 305964

[2017-11-14T16:33:09.05Z][INFO]-monitoring node id = ns=1;s=PumpSpeed

[2017-11-14T16:33:09.099Z][INFO]-monitoredItem initialized

[2017-11-15T23:49:34.752Z][INFO]-Publishing message on topic "/opcua/server/node/MyPumpSpeed" with Payload "{"id":"ns=1;s=PumpSpeed","value":{"dataType":"Double","arrayType":"Scalar","value":237.5250759433095}}"

• Configurez Greengrass pour transférer les messages de votre fonction Lambda à l'IoT Cloud.

Suivez les étapes décrites dans Vérification de l'exécution de la fonction Lambda sur l'appareil (p. 68)pour recevoir des messages sur la Console IoT AWS.

Remarque:

• Assurez-vous qu'un abonnement a été défini entre votre fonction Lambda et l'IoT Cloud. Vous trouverezplus de détails dans Configuration de la fonction Lambda pour AWS Greengrass (p. 60).

• Comme les messages sont transmis au cloud, veillez à résilier le serveur exemple configuréprécédemment ou à arrêter le noyau Greengrass pour que seul un nombre limité de messages soientpubliés sur l'IoT cloud et donc facturés !

193

AWS Greengrass Guide de l'utilisateurÉtapes suivantes

Étapes suivantesAvec Greengrass, vous pouvez utiliser cette même architecture pour créer votre propre implémentationd'OPC-UA, et implémenter votre propre prise en charge des protocoles de messagerie personnalisés,hérités et propriétaires. Puisque les fonctions Lambda fonctionnant sur des noyaux Greengrass ontaccès aux ressources réseau, vous pouvez les utiliser pour implémenter la prise en charge de n'importequel protocole fonctionnant sur TCP-IP. De plus, vous pouvez profiter de l'accès aux ressources localesGreengrass pour implémenter la prise en charge des protocoles ayant à accéder aux adaptateurs et pilotesmatériels.

194


Sécurité AWS GreengrassAWS Greengrass utilise des certificats X.509, des abonnements gérés, des stratégies AWS IoT, desstratégies et des rôles IAM pour protéger vos applications Greengrass. Les appareils Noyau AWSGreengrass nécessitent un objet AWS IoT, un certificat d'appareil et une stratégie AWS IoT pourcommuniquer avec le service cloud Greengrass.

Cela permet aux appareils Noyau AWS Greengrass de se connecter en toute sécurité aux servicescloud AWS IoT. Cela permet également au service cloud Greengrass de déployer des informations deconfiguration, des fonctions Lambda et des abonnements gérés sur les appareils Noyau AWS Greengrass.

Les appareils AWS IoT nécessitent un objet AWS IoT, un certificat d'appareil et une stratégie AWS IoTpour se connecter au service Greengrass. Les appareils AWS IoT peuvent utiliser le service de découverteGreengrass pour localiser un appareil Noyau AWS Greengrass et s'y connecter. Les appareils AWS IoTutilisent le même certificat d'appareil que celui qui est appliqué pour la connexion à la passerelle AWSIoT et aux appareils Noyau AWS Greengrass. Le schéma suivant montre les composants du modèle desécurité AWS Greengrass :

A - Rôle de service Greengrass

Rôle IAM créé par un client qui permet à AWS Greengrass d'accéder aux ressources Lambda et AWSIoT.

B - Certificat de l'appareil noyau

Certificat X.509 utilisé pour authentifier un Noyau AWS Greengrass.C - Certificat d'appareil

Certificat X.509 utilisé pour authentifier un appareil AWS IoT.

195

AWS Greengrass Guide de l'utilisateurConfiguration de la sécurité Greengrass

D - Rôle de groupe

Rôle endossé par AWS Greengrass lors d'un appel dans le cloud depuis une fonction Lambda sur unNoyau AWS Greengrass.

E - CA de groupe

Certificat d'une autorité de certification racine utilisé par les appareils AWS Greengrass pour validerle certificat présenté par un appareil Noyau AWS Greengrass au cours d'une authentification mutuelleTLS.

Configuration de la sécurité GreengrassPour configurer la sécurité de votre application Greengrass :

1. Créez un objet AWS IoT pour votre appareil Noyau AWS Greengrass.2. Générez une paire de clés et un certificat d'appareil pour votre appareil Noyau AWS Greengrass.3. Créez et attachez une stratégie AWS IoT au certificat d'appareil. Le certificat et la stratégie permettent

à l'appareil Noyau AWS Greengrass d'accéder à AWS IoT et aux services cloud Greengrass.4. Créez un rôle de service Greengrass. Ce rôle IAM accorde à AWS Greengrass l'accès à vos

ressources Greengrass et AWS IoT. Il vous suffit de créer un rôle de service une seule fois pourchaque compte AWS.

5. (Facultatif) Créez un rôle de groupe Greengrass. Ce rôle permet aux fonctions Lambda s'exécutant surun Noyau AWS Greengrass d'appeler d'autres services AWS (dans le cloud). Vous devez procéder dela sorte pour chaque groupe Greengrass créé.

6. Créez un objet AWS IoT pour chaque appareil qui se connectera à votre Noyau AWS Greengrass.7. Créez des certificats d'appareil, des paires de clés et des stratégies AWS IoT pour chaque appareil qui

se connectera à votre Noyau AWS Greengrass.

Note

Vous pouvez également utiliser des objets AWS IoT et des certificats existants.

Flux de connexion des appareilsCette section décrit la manière dont les appareils se connectent au service cloud AWS Greengrass et auxappareils Noyau AWS Greengrass.

• Un appareil Noyau AWS Greengrass utilise un certificat d'appareil, une clé privée et le certificat CA AWSIoT racine pour se connecter au service cloud Greengrass.

• L'appareil Noyau AWS Greengrass télécharge les informations d'adhésion au groupe auprès du serviceGreengrass.

• Lorsqu'un déploiement est effectué sur l'appareil Noyau AWS Greengrass, le gestionnaire de certificatsde l'appareil gère les certificats pour l'appareil Noyau AWS Greengrass.

• Un appareil AWS IoT utilise un certificat d'appareil, une clé privée et le certificat CA AWS IoT racinepour se connecter au service cloud Greengrass. Une fois la connexion établie, l'appareil AWS IoT utilisele service de découverte de Greengrass pour rechercher l'adresse IP de ses appareils Noyau AWSGreengrass. L'appareil peut également télécharger le certificat CA racine du groupe pour authentifierl'appareil noyau Greengrass.

• Un appareil AWS IoT tente de se connecter au Noyau AWS Greengrass en transmettant son certificatd'appareil et son ID client. Si l'ID client correspond au nom d'objet de l'appareil et que le certificat estvalide, la connexion est établie. Dans le cas contraire, la connexion est arrêtée.

196

AWS Greengrass Guide de l'utilisateurFlux des messages Greengrass

Flux des messages GreengrassUn tableau d'abonnement est utilisé pour définir la façon dont les messages sont échangés au sein d'ungroupe Greengrass (entre les appareils Noyau AWS Greengrass, les appareils AWS IoT et les fonctionsLambda). Chaque entrée du tableau spécifie la source, la destination et la rubrique MQTT dans laquelleles messages sont envoyés/reçus. Les messages ne peuvent être échangés que si une entrée du tableaud'abonnement spécifie la source (expéditeur du message), la cible (destinataire du message) et la rubriqueMQTT. Les entrées du tableau d'abonnement spécifient le transfert des messages dans une seuledirection, de la source vers la cible. Pour un transfert bidirectionnel des messages, créez deux entréesdans le tableau, une pour chaque direction.

Rotation du certificat du serveur noyau MQTTPar défaut, le certificat du serveur noyau MQTT expire après 7 jours. Vous pouvez définir le délaid'expiration sur une valeur comprise entre 7 et 30 jours. Une fois le certificat arrivé à expiration, toutes lestentatives effectuées pour sa validation échouent. L'appareil doit être en mesure de détecter cet échec etde mettre fin à la connexion. Les connexions existantes ne sont pas interrompues. Lorsque le certificatexpire, l'appareil Noyau AWS Greengrass tente de se connecter au service cloud Greengrass pour obtenirun nouveau certificat. Si la connexion réussit, l'appareil Noyau AWS Greengrass télécharge un nouveaucertificat de serveur noyau MQTT et redémarre le service MQTT local. A ce stade, tous les appareils AWSIoT connectés au noyau sont déconnectés.

A défaut de connexion Internet au moment où le Noyau AWS Greengrass tente d'obtenir un nouveaucertificat pour le serveur noyau MQTT, les appareils AWS IoT sont dans l'impossibilité de se connecter auNoyau AWS Greengrass jusqu'à ce que la connexion avec le service cloud Greengrass soit restaurée etqu'un nouveau certificat puisse être téléchargé.

Lorsque les appareils AWS IoT sont déconnectés d'un noyau, ils doivent patienter un instant, puis essayerde se reconnecter à l'appareil Noyau AWS Greengrass.

Suites de chiffrement AWS GreengrassAWS Greengrass utilise le modèle de sécurité de transport AWS IoT pour chiffrer la communication avecle cloud à l'aide des suites de chiffrement TLS. De plus, les données AWS Greengrass sont chiffréesau repos (dans le cloud). Pour plus d'informations sur la sécurité de transport AWS IoT et les suites dechiffrement prises en charge, consultez Sécurité du transport dans le Manuel du développeur AWS IoT.

Contrairement au cloud AWS IoT, Noyau AWS Greengrass prend en charge les suites de chiffrement TLSde réseau local suivantes :

Version de TLS Cipher

TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA


TLS_RSA_WITH_AES_128_CBC_SHA

TLSv1.0


TLS_ECDHE_RSA_WITH_AES_128_CBC_SHATLSv1.1


197

https://en.wikipedia.org/wiki/Cipher_suite

https://en.wikipedia.org/wiki/Transport_Layer_Security

http://docs.aws.amazon.com/iot/latest/developerguide/iot-security-identity.html#transport-security

AWS Greengrass Guide de l'utilisateurSuites de chiffrement AWS Greengrass

Version de TLS Cipher





TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384


TLS_RSA_WITH_AES_128_GCM_SHA256


TLSv1.2

TLS_RSA_WITH_AES_256_GCM_SHA384

198

AWS Greengrass Guide de l'utilisateurCloudWatch Logs

Surveillance avec les journaux AWSGreengrass

AWS Greengrass se compose du service cloud et du logiciel Noyau AWS Greengrass. Le logiciel principalpeut écrire les journaux dans CloudWatch et dans le système de fichiers local de votre appareil principal.La journalisation est configurée au niveau du groupe.

Toutes les entrées de journal AWS Greengrass comportent un horodatage, un niveau de journalisation,ainsi que des informations sur l'événement.

CloudWatch LogsSi vous configurez la journalisation CloudWatch, vous pouvez consulter les journaux sur la page Logs(Journaux) de la console Amazon CloudWatch. Les groupes de journaux pour les journaux AWSGreengrass utilisent les conventions de dénomination suivantes :

/aws/greengrass/GreengrassSystem/greengrass-system-component-name/aws/greengrass/Lambda/aws-region/account-id/lambda-function-name

Sous chaque groupe de journaux, les flux de journaux sont visibles. Ils présentent la structure suivante :

date/account-id/greengrass-group-id/name-of-core-that-generated-log

Soyez conscient des points suivants lors de l'utilisation de CloudWatch Logs :

•Pour activer la journalisation sur CloudWatch Logs, les actions suivantes doivent être autorisées dans lerôle de groupe AWS Greengrass :• logs:PutLogEvents• logs:CreateLogGroup• logs:CreateLogStream• logs:DescribeLogStreams

• Les journaux sont envoyés à CloudWatch Logs avec un nombre limité de tentatives pour les cas où il n'yaurait pas de connectivité Internet. Une fois le nombre de tentatives atteint, l'événement est supprimé.

• Transaction, mémoire et d'autres limitations s'appliquent. Pour plus d'informations, consultez the sectioncalled “Limites de journalisation” (p. 203).

Journaux du système de fichiersSi vous configurez la journalisation du système de fichier, les fichiers journaux sont stockés sous /greengrass-root/ggc/var/log sur l'appareil principal, avec l'arborescence de haut niveau suivante :

greengrass-root/ggc/var/log - crash.log - system

199

AWS Greengrass Guide de l'utilisateurConfiguration de journalisation par défaut

- log files for each Greengrass system component - user - log files generated by each user-defined Lambda function

Note

Par défaut, greengrass_root est le répertoire /greengrass. Si un répertoire enécriture (p. 24) est configuré, les journaux se trouvent dans ce répertoire.

Soyez conscient des points suivants lors de l'utilisation des journaux du système de fichiers :

• La lecture des journaux AWS Greengrass sur le système de fichiers requiert des privilèges racine.• AWS Greengrass prend en charge la rotation basée sur la taille et le nettoyage automatique lorsque le

volume de données de journalisation est proche de la limite configurée.• Le fichier crash.log est disponible dans les journaux du système de fichiers uniquement. Ce journal

n'est pas écrit dans CloudWatch Logs.• Des limitations d'utilisation du disque s'appliquent. Pour plus d'informations, consultez the section called

“Limites de journalisation” (p. 203).

Note

Les journaux du logiciel AWS Greengrass Core v1.0.0 sont stockés dans le répertoire racine degreengrass-root/var/log.

Configuration de journalisation par défautSi les paramètres de journalisation ne sont pas configurés explicitement, AWS Greengrass utilise laconfiguration de journalisation par défaut suivante après le déploiement du premier groupe.

Composants système AWS Greengrass• Type - FileSystem• Composant - GreengrassSystem• Level - INFO• Espace - 128 KB

Fonctions Lambda définies par l'utilisateur• Type - FileSystem• Composant - Lambda• Level - INFO• Espace - 128 KB

Note

Avant le premier déploiement, seuls les composants système écrivent des journaux dans lesystème de fichiers, car aucune fonction Lambda définie par l'utilisateur n'est déployée.

Configurer la journalisation pour AWS GreengrassVous pouvez utiliser la Console IoT AWS ou les API AWS Greengrass (p. 201) pour configurer lajournalisation AWS Greengrass.

200

AWS Greengrass Guide de l'utilisateurConfigurer la journalisation (console)

Note

Pour autoriser AWS Greengrass à écrire des journaux dans CloudWatch Logs, votre groupe rôledoit autoriser les actions CloudWatch Logs requises (p. 199).

Configurer la journalisation (console)Vous pouvez configurer la journalisation sur la page Settings (Paramètres) du groupe.

1. Dans Console IoT AWS, choisissez Greengrass, puis Groupes.2. Choisissez le groupe dans lequel vous souhaitez configurer la journalisation.3. Sur la page de configuration de groupe, choisissez Settings (Paramètres).4. Choisissez l'emplacement de journalisation, comme suit :

• Pour configurer la journalisation CloudWatch, pour la configuration des journaux CloudWatch,choisissez Edit (Modifier).

• Pour configurer la journalisation du système de fichiers, pour la configuration des journaux locaux,choisissez Edit (Modifier).

Vous pouvez configurer la journalisation pour un emplacement ou les deux.5. Sur la page Configure logging Group (Configurer le groupe de journalisation), choisissez Add another

log type (Ajouter un autre type de journal).6. Choisissez la source de l'événement, comme suit :

• Pour consigner les événements de fonctions Lambda définies par l'utilisateur, choisissez UserLambdas (Lambdas utilisateur).

• Pour consigner les événements des composants du système AWS Greengrass, choisissezGreengrass system (Système Greengrass).

Vous pouvez choisir un composant ou les deux.7. Sélectionnez Update.8. Choisissez le plus bas niveau d'événements que vous souhaitez consigner. Les évènements en

dessous de ce seuil sont filtrés, mais ne sont pas stockés.9. Pour les journaux du système de fichiers, spécifiez une limite d'espace disque.10. Choisissez Save.

Configurer la journalisation (API)Vous pouvez utiliser les API de journalisation AWS Greengrass pour configurer la journalisation parprogrammation. Par exemple, utilisez l'action CreateLoggerDefinition pour créer une définitiond'enregistreur d'événements en fonction d'une charge utile LoggerDefinitionVersion, qui utilise lasyntaxe suivante :

{ "Loggers": [ { "Id": "string", "Type": "FileSystem|AWSCloudWatch", "Component": "GreengrassSystem|Lambda", "Level": "DEBUG|INFO|WARN|ERROR|FATAL", "Space": "integer" },

201

http://docs.aws.amazon.com/greengrass/latest/apireference/createloggerdefinition-post.html

http://docs.aws.amazon.com/greengrass/latest/apireference/definitions-loggerdefinitionversion.html

AWS Greengrass Guide de l'utilisateurExemple de configuration

{ "Id": "string", ... } ]}

LoggerDefinitionVersion est un tableau d'un ou de plusieurs objets Logger dont les propriétéssuivantes :

Id

Identifiant unique de l'enregistreur d'événements.Type

Mécanisme de stockage pour les événements de journaux. Quand AWSCloudWatch est utilisé, lesjournaux d'événements sont envoyés à CloudWatch Logs. Lorsque FileSystem est utilisé, lesjournaux d'événements sont stockés dans le système de fichiers local.

Valeurs valides: AWSCloudWatch, FileSystemComponent

Source de l'événement de journal. Lorsque GreengrassSystem est utilisé, les événements provenantdes composants système Greengrass sont consignés. Quand Lambda est utilisé, les événementsprovenant des fonctions Lambda définies par l'utilisateur sont consignés.

Valeurs valides: GreengrassSystem, LambdaLevel

Seuil du niveau de journalisation. Les journaux d'évènements en dessous de ce seuil sont filtrés, maisne sont pas stockés.

Valeurs valides : DEBUG, INFO (recommandée), WARN, ERROR, FATALSpace

Volume maximum de stockage local, en Ko, à utiliser pour stocker les journaux. Ce champ s'appliqueuniquement lorsque Type est défini sur FileSystem.

Exemple de configurationL'exemple LoggerDefinitionVersion suivant spécifie un fichier de configuration qui :

• Active la journalisation du système de fichiers ERROR (et supérieur) pour les composants du systèmeAWS Greengrass.

• Active la journalisation du système de fichiers INFO (et supérieur) pour les fonctions Lambda définies parl'utilisateur.

• Active la journalisation CloudWatch INFO (et supérieur) pour les fonctions Lambda définies parl'utilisateur.

{ "Name": "LoggingExample", "InitialVersion": { "Loggers": [ { "Id": "1", "Component": "GreengrassSystem",

202

http://docs.aws.amazon.com/greengrass/latest/apireference/definitions-logger.html

AWS Greengrass Guide de l'utilisateurLimites de journalisation

"Level": "ERROR", "Space": 10240, "Type": "FileSystem" }, { "Id": "2", "Component": "Lambda", "Level": "INFO", "Space": 10240, "Type": "FileSystem" }, { "Id": "3", "Component": "Lambda", "Level": "INFO", "Type": "AWSCloudWatch" } ] }}

Lorsque vous avez créé une version de la définition de l'enregistreur d'événements, vous pouvez utiliserson ARN de version pour créer un groupe de version avant de déployer le groupe.

Limites de journalisationAWS Greengrass possède les limitations de journalisation suivantes.

Transactions par secondeLorsque la journalisation dans CloudWatch est activée, le composant de consignation regroupe lesévènements de journalisation en local avant de les envoyer à CloudWatch afin que la journalisation puisseêtre effectuée à un rythme plus élevé que cinq demandes par seconde par flux de journaux.

MémoireSi AWS Greengrass est configuré pour envoyer des journaux à CloudWatch et qu'une fonction Lambdagénère des journaux à un rythme supérieur à 5 Mo/seconde pendant une longue période, le canal detraitement interne risque de devenir saturé. En théorie, le pire des cas est une fonction à 6 Mo par Lambda.

Décalage d'horlogeLorsque la journalisation dans CloudWatch est activée, le composant de journalisation signe les demandesenvoyées à CloudWatch en suivant le processus de signature normal de Signature Version 4. Si l'heuresystème définie sur l'appareil Noyau AWS Greengrass est désynchronisée de plus de 15 minutes, lesdemandes sont rejetées.

Utilisation du disqueUtilisez la formule suivante pour calculer le volume total maximal d'espace disque affecté à lajournalisation.

greengrass-system-component-space * 8 // 7 if automatic IP detection is disabled + 128KB // the internal log for the local logging component

203

http://docs.aws.amazon.com/AmazonS3/latest/API/sig-v4-authenticating-requests.html

AWS Greengrass Guide de l'utilisateurPerte de journaux

+ lambda-space * lambda-count // different versions of a Lambda function are treated as one

Où:

greengrass-system-component-space

Volume maximal de stockage local pour les journaux des composants du système AWS Greengrass.lambda-space

Volume maximal de stockage local pour les journaux Lambda.lambda-count

Nombre de fonctions Lambda déployées.

Perte de journauxSi votre appareil Noyau AWS Greengrass est configuré pour écrire des journaux uniquement dansCloudWatch et qu'aucune connexion Internet n'est disponible, vous n'avez aucun moyen pour récupérer lesjournaux actuellement en mémoire.

Lorsque les fonctions Lambda sont interrompues (par exemple, pendant le déploiement), quelquessecondes de journaux ne sont pas écrites dans CloudWatch.

204


Résolution des problèmes desapplications AWS Greengrass

Utilisez les informations suivantes pour résoudre les problèmes dans AWS Greengrass.

Problèmes

Symptôme Solution

L'erreur 403 Forbidden s'affiche dans les journauxlors du déploiement.

Assurez-vous que la stratégie du Noyau AWSGreengrass dans le cloud inclut « greengrass:* »en tant qu'action autorisée.

Le Device Shadow n'est pas synchronisé avec lecloud.

Vérifiez que le Noyau AWS Greengrassdispose d'autorisations pour lesactions « iot:UpdateThingShadow » et« iot:GetThingShadow ».

Voir aussi Dépannage des problèmesde temporisation de la synchronisationshadow (p. 212).

Le logiciel Noyau AWS Greengrass ne s'exécutepas sur Raspberry Pi, car l'espace de nomsutilisateur n'est pas activé.

Exécutez rpi-update de lancer la mise à jour.Raspbian a publié un nouveau kernel 4.9 danslequel l'espace de noms utilisateur est activé.

Une erreur ConcurrentDeployment se produitlorsque vous exécutez create-deployment pourla première fois.

Un déploiement peut être en cours. Vous pouvezexécuter get-deployment-history pour voir siun déploiement a été créé. Si ce n'est pas le cas,essayez de recréer le déploiement.

Le logiciel Noyau AWS Greengrass ne démarrepas correctement.

• Vérifiez que vous utilisez les fichiers binairesappropriés pour votre architecture.

• Recherchez des messages d'erreur dansruntime.log. Pour plus d'informations,consultez Résolution des problèmes avec lesjournaux (p. 208).

• Vérifiez que votre appareil Noyau AWSGreengrass dispose d'un stockage localdisponible.

Le logiciel Noyau AWS Greengrass nedémarre pas sur un Raspberry Pi et vousrecevez le message d'erreur suivant :Failed to invoke PutLogEventson local Cloudwatch, logGroup: /GreengrassSystem/connection_manager,error: RequestError: send requestfailed caused by: Post http://path/cloudwatch/logs/: dial tcp address:getsockopt: connection refused,response: { }.

Cela peut se produire si la version du systèmed'exploitation est Raspbian Stretch. Vous pouvezexécuter la commande suivante dans le terminalpour voir la version du système d'exploitationinstallé sur votre Pi :

cat /etc/os-release

Nous vous recommandons d'utiliser la plateformeprise en charge (p. 13) (actuellement RaspianJessie, 2017-03-02). Cependant, si vouschoisissez d'exécuter le logiciel Noyau AWS

205




Symptôme SolutionGreengrass sur Raspbian Stretch, ajoutezcgroup_enable=memory à votre fichier /boot/cmdline.txt puis redémarrez l'appareil.

Note

Vous pouvez rencontrer d'autresproblèmes si vous exécutez le logicielprincipal AWS Greengrass sur uneplateforme non prise en charge.

Le logiciel Noyau AWS Greengrass ne démarrepas et vous recevez le message d'erreursuivant : Unable to create serverdue to: failed to load group:chmod /greengrass-root/ggc/deployment/lambda/arn:aws:lambda:region:account-id:function:function-name:version/file-name: no such fileor directory.

Si vous avez déployé une fonction ??? (p. 131)sur le noyau, vérifiez la propriété Handler dela fonction dans le fichier group.json (situédans /greengrass-root/ggc/deployment/group). Si le gestionnaire n'est pas le nom exactde votre exécutable compilé, remplacez le contenudu fichier group.json par un objet JSON vide({}), et démarrez Greengrass en exécutant lescommandes suivantes :


Ensuite, utilisez l'API AWS Lambda pour mettreà jour le paramètre handler de la configurationde la fonction, publier une nouvelle version dela fonction, et mettre à jour l'alias. Pour plusd'informations, consultez la page Gestion desversions et alias de la fonction AWS Lambda.

En supposant que vous ayez ajouté par alias lafonction à votre groupe Greengrass (recommandé),vous pouvez maintenant redéployer votre groupe.(Si ce n'est pas le cas, vous devez pointer vers lanouvelle version ou le nouvel alias de la fonctiondans votre définition de groupe et les abonnementsavant de déployer le groupe.)

Le logiciel Noyau AWS Greengrass ne démarrepas et vous recevez le message d'erreur suivant :Spool size should be at least 262144bytes.

Ouvrez le fichier group.json (situédans /greengrass-root/ggc/deployment/group),remplacez le contenu du fichier par un objet JSONvide ({}), et démarrez Greengrass en exécutantles commandes suivantes :


Ensuite, suivez la procédure the section called“Pour mettre en cache des messages dans lestockage local” (p. 28), et assurez-vous de spécifierune valeur GG_CONFIG_MAX_SIZE_BYTESsupérieure ou égale à 262 144 pour la fonctionGGCloudSpooler.

206

http://docs.aws.amazon.com/cli/latest/reference/lambda/




Symptôme Solution

Le script greengrassd affiche : unable toaccept TCP connection. accept tcp[::]:8000: accept4: too many openfiles.

La limite du descripteur de fichier du logiciel NoyauAWS Greengrass a atteint le seuil défini et doit êtreaugmenté.

Utilisez la commande suivante:

ulimit -n 2048

et redémarrez le logiciel Noyau AWS Greengrass.

Note

Dans cet exemple, la limite est augmentéeà 2 048. Choisissez une valeur adaptée àvotre cas d'utilisation.

Le message d'erreur suivant s'affiche :Runtime execution error: unableto start lambda container.container_linux.go:259: startingcontainer process caused"process_linux.go:345: container initcaused \"rootfs_linux.go:50: preparingrootfs caused \\\"permission denied\\\"\""

Installez AWS Greengrass directement sousle répertoire racine, ou assurez-vous que lerépertoire /greengrass et ses répertoires parentdisposent des autorisations execute pour tous lesutilisateurs.

Le déploiement échoue avec le message d'erreursuivant : Greengrass is not authorizedto assume the Service Role associatedwith this account.

À l'aide de l'AWS CLI, vérifiez qu'un rôle deservice approprié est associé votre compte enutilisant GetServiceRoleForAccount et vérifiezque le compte possède au minimum le rôleAWSGreengrassResourceAccessRolePolicy.Si vous devez associer un rôle de serviceGreengrass à votre compte, utilisezAssociateServiceRoleToAccount.

207

http://docs.aws.amazon.com/greengrass/latest/apireference/getserviceroleforaccount-get.html

http://docs.aws.amazon.com/greengrass/latest/apireference/associateserviceroletoaccount-put.html

AWS Greengrass Guide de l'utilisateurRésolution des problèmes avec les journaux

Symptôme Solution

Le déploiement n'est pas terminé. Assurez-vous que le démon AWS Greengrass esten cours d'exécution sur votre appareil principal.Exécutez les commandes suivantes dans votreterminal principal pour vérifier que le démon est encours d'exécution et démarrez-le, si nécessaire.

1. Pour vérifier si le démon est en coursd'exécution :


Si la sortie contient une entrée root pour /greengrass/ggc/packages/1.5.0/bin/daemon, le démon est en cours d'exécution.

La version du chemin d'accès dépend dulogiciel AWS Greengrass Core installé survotre appareil principal.

2. Pour démarrer le démon :


Le déploiement n'est pas terminé et le runtime.logcontient plusieurs entrées wait 1s forcontainer to stop.

Redémarrez le démon AWS Greengrass enexécutant les commandes suivantes sur votreterminal principal.

cd /greengrass/ggc/core/sudo ./greengrassd stopsudo ./greengrassd start

Le message d'erreur suivant s'affiche :Deployment guid of type NewDeploymentfor group guid failed error: Errorwhile processing. group config isinvalid: 112 or [119 0] don't have rwpermission on the file: path

Assurez-vous que le propriétaire du groupe durépertoire path dispose des autorisations delecture et d'écriture pour le répertoire.

Si vous ne parvenez pas à trouver ou à résoudre votre problème à l'aide de ces informations, vous pouvezfaire des recherches dans le forum AWS Greengrass ou publier un nouveau thread. Les membres del'équipe AWS Greengrass surveillent activement le forum.

Résolution des problèmes avec les journauxGGC v1.6.0

Si les journaux sont configurés pour être stockés dans le système de fichiers local, commencez parexaminer les emplacements suivants. La lecture des journaux sur le système de fichiers requiert desprivilèges racine.

208

https://forums.aws.amazon.com/forum.jspa?forumID=254


greengrass-root/ggc/var/log/crash.log

Affiche les messages générés lorsqu'un Noyau AWS Greengrass tombe en panne.greengrass-root/ggc/var/log/system/runtime.log

Affiche les messages sur le composant qui est en échec.greengrass-root/ggc/var/log/system/

Contient tous les journaux des composants système AWS Greengrass, tels que le gestionnairede certificats et le gestionnaire de connexions. En utilisant les messages affichés dans ggc/var/log/system/ et ggc/var/log/system/runtime.log, vous devez être en mesure d'identifierles erreurs qui se sont produites dans les composants du système AWS Greengrass.

greengrass-root/ggc/var/log/user/

Contient tous les journaux des fonctions Lambda définies par l'utilisateur. Recherchez dans cedossier des messages d'erreur de vos fonctions Lambda locales.

Note

Par défaut, greengrass_root est le répertoire /greengrass. Si un répertoire enécriture (p. 24) est configuré, les journaux se trouvent dans ce répertoire.

Si les journaux sont configurés pour être stockés sur le cloud, utilisez CloudWatch Logs pour afficherles messages de journalisation. Notez que crash.log ne se trouve que dans les journaux dusystème de fichiers du périphérique Noyau AWS Greengrass.

Si AWS IoT est configuré pour écrire des fichiers journaux dans CloudWatch, vérifiez les informationsde ces fichiers journaux si des erreurs de connexion surviennent lorsque des composants du systèmetentent de se connecter à AWS IoT.

Pour plus d'informations sur la journalisation AWS Greengrass, consultez Surveillance (p. 199).GGC v1.5.0








Note

Par défaut, greengrass_root est le répertoire /greengrass.

209












Note








Affiche les messages sur le composant qui est en échec.

210


greengrass-root/ggc/var/log/system/




Note






greengrass-root/var/log/crash.log

Affiche les messages générés lorsqu'un Noyau AWS Greengrass tombe en panne.greengrass-root/var/log/system/runtime.log

Affiche les messages sur le composant qui est en échec.greengrass-root/var/log/system/

Contient tous les journaux des composants système AWS Greengrass, tels que le gestionnairede certificats et le gestionnaire de connexions. En utilisant les messages affichés dans var/log/system/ et var/log/system/runtime.log, vous devez être en mesure d'identifier les erreursqui se sont produites dans les composants du système AWS Greengrass.

greengrass-root/var/log/user/


Note


Si AWS Greengrass est configuré pour écrire les journaux dans CloudWatch, vous pouvez consulterles messages des journaux dans la console CloudWatch (p. 199). Notez que crash.log ne se trouveque dans les journaux du système de fichiers du périphérique Noyau AWS Greengrass.

211

AWS Greengrass Guide de l'utilisateurRésolution des problèmes de stockage


Résolution des problèmes de stockageLorsque le stockage de fichiers local est plein, il se peut que certains composants commencent à tomberen panne :

• Les mises à jour locales de Shadow ne se produisent pas.• Les nouveaux certificats Noyau AWS Greengrass du serveur MQTT ne peuvent pas être téléchargés

localement.• Les déploiements échouent.

Vous devez toujours connaître la quantité d'espace libre disponible en local. Vous pouvez la calculeren fonction de la taille des fonctions Lambda déployées, de la configuration de la journalisation (voirRésolutions des problèmes avec les journaux (p. 208)) et le nombre de shadows stockées localement.

Messages de résolution des problèmesTous les messages envoyés au sein d'AWS Greengrass sont envoyés avec QoS 0. Par défaut, AWSGreengrass stocke les messages dans une file d'attente en mémoire. Par conséquent, les messages nontraités sont perdus lorsque le Noyau AWS Greengrass redémarre, par exemple après un déploiementde groupe ou un redémarrage de l'appareil. Cependant, vous pouvez configurer AWS Greengrass(v) pour mettre en cache des messages dans le système de fichiers, afin qu'ils soient conservés lorsdes redémarrages du noyau. Vous pouvez également configurer la taille de la file d'attente. Pour plusd'informations, consultez the section called “File d'attente de messages MQTT” (p. 27).

Note

Lorsque vous utilisez la file d'attente en mémoire par défaut, nous vous recommandons dedéployer des groupes ou de redémarrer l'appareil lorsque l'interruption de service est la moinsimportante.

Si vous configurez une taille de file d'attente, assurez-vous qu'elle est supérieure ou égale à 262 144 octets(256 Ko). Sinon, AWS Greengrass peut ne pas démarrer correctement.

Dépannage des problèmes de temporisation de lasynchronisation shadow

GGC v1.6.0

S'il y a un retard important dans la communication entre un appareil principal Greengrass et le cloud,la synchronisation shadow peut échouer en raison d'un délai d'expiration. Vous pouvez voir quelquechose de similaire à ce qui suit dans vos fichiers journaux :

[2017-07-20T10:01:58.006Z][ERROR]-cloud_shadow_client.go:57,Cloud shadow client error: unable to get cloud shadow what_the_thing_is_named for synchronization. Get https://1234567890abcd.iot.us-west-2.amazonaws.com:8443/things/what_the_thing_is_named/shadow: net/http: request canceled (Client.Timeout exceeded while awaiting headers)

212

AWS Greengrass Guide de l'utilisateurDépannage des problèmes de

temporisation de la synchronisation shadow

[2017-07-20T10:01:58.006Z][WARN]-sync_manager.go:263,Failed to get cloud copy: Get https://1234567890abcd.iot.us-west-2.amazonaws.com:8443/things/what_the_thing_is_named/shadow: net/http: request canceled (Client.Timeout exceeded while awaiting headers)[2017-07-20T10:01:58.006Z][ERROR]-sync_manager.go:375,Failed to execute sync operation {what_the_thing_is_named VersionDiscontinued []}"

Pour remédier à ce problème, vous pouvez configurer la durée pendant laquelle votre appareilGreengrass principal attend une réponse de l'hôte. Ouvrez le fichier greengrass-root/config/config.json et ajoutez un champ system.shadowSyncTimeout avec un délai en secondes.Exemples :

{ "coreThing": { "caPath": "root-ca.pem", "certPath": "cloud.pem.crt", "keyPath": "cloud.pem.key", "thingArn": "arn:aws:iot:us-west-2:049039099382:thing/GGTestGroup42_Core", "iotHost": "your-AWS-IoT-endpoint", "ggHost": "greengrass.iot.us-west-2.amazonaws.com", "keepAlive": 600 }, "runtime": { "cgroup": { "useSystemd": "yes" } }, "system": { "shadowSyncTimeout": 10 }}

Si aucune valeur shadowSyncTimeout n'est spécifiée dans le fichier config.json, la valeur par défautest d'1 seconde.

GGC v1.5.0


[2017-07-20T10:01:58.006Z][ERROR]-cloud_shadow_client.go:57,Cloud shadow client error: unable to get cloud shadow what_the_thing_is_named for synchronization. Get https://1234567890abcd.iot.us-west-2.amazonaws.com:8443/things/what_the_thing_is_named/shadow: net/http: request canceled (Client.Timeout exceeded while awaiting headers)[2017-07-20T10:01:58.006Z][WARN]-sync_manager.go:263,Failed to get cloud copy: Get https://1234567890abcd.iot.us-west-2.amazonaws.com:8443/things/what_the_thing_is_named/shadow: net/http: request canceled (Client.Timeout exceeded while awaiting headers)[2017-07-20T10:01:58.006Z][ERROR]-sync_manager.go:375,Failed to execute sync operation {what_the_thing_is_named VersionDiscontinued []}"


{ "coreThing": { "caPath": "root-ca.pem",

213



"certPath": "cloud.pem.crt", "keyPath": "cloud.pem.key", "thingArn": "arn:aws:iot:us-west-2:049039099382:thing/GGTestGroup42_Core", "iotHost": "your-AWS-IoT-endpoint", "ggHost": "greengrass.iot.us-west-2.amazonaws.com", "keepAlive": 600 }, "runtime": { "cgroup": { "useSystemd": "yes" } }, "system": { "shadowSyncTimeout": 10 }}


GGC v1.3.0





214




GGC v1.1.0






GGC v1.0.0

Non pris en charge.

215

AWS Greengrass Guide de l'utilisateurMises à jour antérieures

Historique du document pour AWSGreengrass

Le tableau suivant décrit les modifications importantes apportées au Manuel du développeur de AWSGreengrass après juin 2018. Pour recevoir les notifications des mises à jour de cette documentation,abonnez-vous à un flux RSS.

update-history-change update-history-description update-history-date

Sortie de AWS Greengrassversion 1.6.0

Nouvelles fonctions : file d'attentede messages configurable,intervalle de tentative dereconnexion configurable,ressources de volume sous /proc et répertoire en écritureconfigurable.

July 26, 2018

Mises à jour antérieuresLe tableau suivant décrit les modifications importantes apportées au Manuel du développeur de AWSGreengrass avant juillet 2018.

Modification Description Date

Sortie de AWSGreengrassversion 1.5.0


• Inférence d'apprentissage automatique locale à l'aide des modèlesformés dans le cloud. Pour plus d'informations, consultez Exécuterl'inférence de Machine Learning (p. 159).

• Les fonctions Lambda Greengrass prennent en charge les donnéesd'entrée binaires en plus de JSON.

Pour plus d'informations, consultez Versions d'Noyau AWSGreengrass (p. 2).

29 mars 2018



• Agent de mise à jour OTA capable de gérer les tâches de mise àjour Greengrass déployées dans le cloud. Pour plus d'informations,consultez Mises à jour OTA des principaux logiciels AWSGreengrass (p. 119).

• Accès aux ressources et aux périphériques locaux à partir de fonctionsLambda Greengrass. Pour plus d'informations, consultez Accès auxressources locales avec les fonctions Lambda (p. 134).

27 novembre 2017

216

http://docs.aws.amazon.com/greengrass/latest/developerguide/what-is-gg.html#ggc-versions

http://docs.aws.amazon.com/greengrass/latest/developerguide/what-is-gg.html#ggc-versions

AWS Greengrass Guide de l'utilisateurMises à jour antérieures

Modification Description Date



• Réinitialisation de Groupe AWS Greengrass déployés. Pour plusd'informations, consultez Réinitialiser les déploiements (p. 125).

• Prise en charge des environnements d'exécution Node.js 6.10 etLambda Java 8, en plus de Python 2.7.

20septembre2017


AWS Greengrass est disponible pour tous. 7 juin 2017

217

Documents

AWS Greengrass - Guide de l'utilisateur · AWS Greengrass Guide de l'utilisateur Versions de AWS Greengrass Core • Répertoire en écriture configurable. Le logiciel Noyau AWS Greengrass