aws greengrass - guía para desarrolladores · api restful de detección de greengrass ... • las...

AWS GreengrassGuía para desarrolladores

AWS Greengrass Guía para desarrolladores

AWS Greengrass: Guía para desarrolladoresCopyright © 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 Contents¿Qué es AWS Greengrass? ................................................................................................................. 1

Software AWS Greengrass Core ................................................................................................... 2Versiones de AWS Greengrass Core ..................................................................................... 2

Grupos de AWS Greengrass ........................................................................................................ 4Dispositivos de AWS Greengrass .................................................................................................. 5SDK ......................................................................................................................................... 6Plataformas compatibles y requisitos ........................................................................................... 12Esperamos tener noticias suyas .................................................................................................. 17AWS Greengrass Core ................................................................................................................ 2

Archivo de configuración de AWS Greengrass Core ............................................................... 17Directorio de escritura ....................................................................................................... 24Cola de mensajes MQTT ................................................................................................... 26Iniciar Greengrass en el arranque del sistema ....................................................................... 29

Introducción a AWS Greengrass ......................................................................................................... 30Requisitos ................................................................................................................................ 30Cree una cuenta de AWS .......................................................................................................... 31Módulo 1: Configuración del entorno para Greengrass .................................................................... 31

Configuración de un Raspberry Pi ....................................................................................... 31Configuración de una instancia Amazon EC2 ........................................................................ 37Configuración de otros dispositivos ...................................................................................... 40

Módulo 2: Instalación del software de Greengrass Core .................................................................. 44Configuración de AWS Greengrass en AWS IoT .................................................................... 44Inicio de AWS Greengrass en el dispositivo del núcleo ........................................................... 49

Módulo 3 (primera parte): funciones de Lambda en AWS Greengrass ............................................... 52Creación y empaquetado de una función de Lambda ............................................................. 52Configuración de la función de Lambda para AWS Greengrass ................................................ 59Implementación de configuraciones de nube en un dispositivo del núcleo .................................. 65Verificación de la ejecución de función de Lambda en el dispositivo .......................................... 67

Módulo 3 (segunda parte): funciones de Lambda en AWS Greengrass .............................................. 70Creación y empaquetado de la función de Lambda ................................................................ 70Configuración de funciones de Lambda de larga duración para AWS Greengrass ........................ 72Prueba de funciones de Lambda de larga duración ................................................................ 74Prueba de funciones de Lambda bajo demanda .................................................................... 79

Módulo 4: Interacción con dispositivos en un grupo de AWS Greengrass ........................................... 82Creación de dispositivos de AWS IoT en un grupo de AWS Greengrass .................................... 83Configuración de suscripciones ........................................................................................... 87Instalar el AWS IoT Device SDK para Python ....................................................................... 88Prueba de las comunicaciones ........................................................................................... 93

Módulo 5: Interacción con sombras de dispositivo .......................................................................... 95Configuración de dispositivos y suscripciones ....................................................................... 96Descarga de los archivos necesarios ................................................................................... 99Prueba de las comunicaciones (sincronizaciones de dispositivos deshabilitadas) ......................... 99Prueba de las comunicaciones (sincronizaciones de dispositivos habilitadas) ............................ 101

Módulo 6: Acceso a servicios en la nube de AWS ....................................................................... 102Configuración de roles de IAM .......................................................................................... 103Creación y configuración de la función de Lambda ............................................................... 107Configuración de suscripciones ......................................................................................... 112Prueba de las comunicaciones .......................................................................................... 115

Actualizaciones de OTA del software AWS Greengrass Core ................................................................. 118Agente OTA de Greengrass ..................................................................................................... 119Integración con sistemas Init ..................................................................................................... 121

Actualización OTA automática con managedRespawn .......................................................... 122Actualización de AWS Greengrass Core con regeneración administrada .................................. 122

Actualización automática del agente OTA ................................................................................... 123

iii


Actualización del software Greengrass Core ................................................................................ 123Restablecimiento de implementaciones ............................................................................................... 124Ejecutar funciones de Lambda locales ............................................................................................... 126

SDK ...................................................................................................................................... 126Migración de funciones de Lambda basadas en la nube ........................................................ 127

Alias y versiones de la función .................................................................................................. 127Configuración específica del grupo ............................................................................................ 128Flujos de comunicación ............................................................................................................ 129

Mensajes MQTT ............................................................................................................. 129Otros flujos de comunicación ............................................................................................ 129

Configuración del ciclo de vida .................................................................................................. 130Ejecutables Lambda ................................................................................................................ 130

Crear un ejecutable Lambda ............................................................................................. 131Obtener acceso a recursos locales con funciones de Lambda ................................................................ 133

Tipos de recursos admitidos ..................................................................................................... 133Requisitos .............................................................................................................................. 134

Recursos de volumen en el directorio /proc ......................................................................... 134Permiso de acceso a los archivos del propietario del grupo ........................................................... 135

Véase también ................................................................................................................ 135Uso de la CLI ......................................................................................................................... 135

Creación de recursos locales ............................................................................................ 135Creación de la función de Greengrass ............................................................................... 137Adición de la función de Lambda al grupo .......................................................................... 138Solución de problemas ..................................................................................................... 139

Mediante la consola ................................................................................................................ 140Requisitos previos ........................................................................................................... 140Creación de un paquete de implementación de la función de Lambda ..................................... 141Cree y publique una función de Lambda ............................................................................. 143Adición de la función de Lambda al grupo .......................................................................... 147Añadir un recurso local al grupo ........................................................................................ 150Añada suscripciones al grupo ........................................................................................... 151Implemente el grupo ........................................................................................................ 153Prueba de acceso al recurso local ..................................................................................... 155

Cómo realizar la inferencia de aprendizaje automático .......................................................................... 158Funcionamiento de la inferencia de aprendizaje automático de AWS Greengrass .............................. 158Recursos de aprendizaje automático .......................................................................................... 159

Orígenes de modelos admitidos ........................................................................................ 159Requisitos .............................................................................................................................. 161Bibliotecas precompiladas para marcos de trabajo de ML .............................................................. 161

Control de versiones de MXNet ......................................................................................... 161Limitaciones de la distribución de modelos de TensorFlow en Raspberry Pi .............................. 162

Cómo configurar Amazon SageMaker para usar MXNet v0.11 ........................................................ 162Cómo configurar la inferencia de aprendizaje automático .............................................................. 163

Requisitos previos ........................................................................................................... 164Configurar el Raspberry Pi ............................................................................................... 164Instalar el marco de trabajo MXNet .................................................................................... 165Crear un paquete de modelo ............................................................................................ 167Cree y publique una función de Lambda ............................................................................. 167Adición de la función de Lambda al grupo .......................................................................... 172Añadir recursos al grupo .................................................................................................. 174Añadir una suscripción al grupo ........................................................................................ 177Implemente el grupo ........................................................................................................ 179Prueba de la aplicación .................................................................................................... 180Pasos siguientes ............................................................................................................. 183Configuración de un dispositivo NVIDIA Jetson TX2 ............................................................. 184

API RESTful de detección de Greengrass ........................................................................................... 185Solicitud ................................................................................................................................. 185

iv


Respuesta .............................................................................................................................. 185Autorización ............................................................................................................................ 186Documentos de respuesta de detección de ejemplo ..................................................................... 186

OPC-UA en Greengrass ................................................................................................................... 188Información general sobre la arquitectura ................................................................................... 188Configurar un servidor OPC-UA de prueba ................................................................................. 189Asegurarse de que el grupo de Greengrass está listo ................................................................... 190Utilizar OPC-UA en Greengrass para interactuar con los servidores OPC-UA .................................... 190Compruebe que la función de Lambda recibe Publish de OPC-UA y los publica en Greengrass ............ 192Pasos siguientes ..................................................................................................................... 193

Seguridad de AWS Greengrass ......................................................................................................... 194Configuración de la seguridad de Greengrass ............................................................................. 195Flujo de trabajo de conexión de dispositivos ............................................................................... 195Flujo de trabajo de mensajería de Greengrass ............................................................................ 196Rotación de certificados de servidor del núcleo de MQTT .............................................................. 196AWS Greengrass Cipher Suites ................................................................................................ 196

Monitorización ................................................................................................................................. 198CloudWatch Logs .................................................................................................................... 198Logs del sistema de archivos .................................................................................................... 198Configuración de registro predeterminada ................................................................................... 199Configuración del registro para AWS Greengrass ......................................................................... 199

Configuración del registro (consola) ................................................................................... 200Configuración del registro (API) ......................................................................................... 200Ejemplo de configuración ................................................................................................. 201

Limitaciones de registro ........................................................................................................... 202Transacciones por segundo .............................................................................................. 202Memoria ........................................................................................................................ 202Sesgo del reloj ............................................................................................................... 202Consumo de disco .......................................................................................................... 202Pérdida de logs .............................................................................................................. 203

Solución de problemas de aplicaciones de AWS Greengrass ................................................................. 204............................................................................................................................................ 204

Solución de problemas con logs ................................................................................................ 207Solución de problemas de almacenamiento ................................................................................. 211Solución de problemas con mensajes ........................................................................................ 211Solución de problemas de tiempo de espera de sincronización de sombras agotado .......................... 211

Historial de revisión ......................................................................................................................... 215Actualizaciones anteriores ........................................................................................................ 215

v


¿Qué es AWS Greengrass?AWS Greengrass es un software que amplía las capacidades de la nube de AWS a los dispositivos localesy permite a esos dispositivos recopilar y analizar datos más cerca del origen de la información, a la vezque asegura que se comunican de forma segura entre sí en las redes locales. Más en concreto, losdesarrolladores que utilizan AWS Greengrass pueden crear código sin servidor (funciones AWS Lambda)en la nube e implementarlo cómodamente en dispositivos para ejecutar localmente las aplicaciones.

En el siguiente diagrama se muestra la arquitectura básica de AWS Greengrass.

AWS Greengrass permite que los clientes utilicen sus funciones de Lambda para crear dispositivosIoT y lógica de aplicación. En concreto, AWS Greengrass permite la administración basada en la nubede aplicaciones que pueden implementarse para ejecutarse localmente. Las funciones de Lambdaimplementadas localmente se activan por eventos locales, mensajes de la nube u otras fuentes.

En AWS Greengrass, los dispositivos se comunican de manera segura a través de una red local eintercambian mensajes entre sí sin tener que conectarse a la nube. AWS Greengrass proporciona unadministrador de mensajes de publicación/envío local que puede almacenar mensajes en búfer de manerainteligente si se pierde la conectividad, de manera que se conserven los mensajes de entrada y salida en lanube.

AWS Greengrass protege los datos de usuario:

• A través de la autorización y autenticación seguras de los dispositivos.• A través de conectividad segura en la red local.• Entre los dispositivos locales y la nube.

Las credenciales de seguridad de los dispositivos funcionan dentro de un grupo hasta que se revocan,aunque se interrumpa la conectividad a la nube, de manera que los dispositivos puedan seguircomunicándose de forma segura en el nivel local.

AWS Greengrass proporciona actualizaciones de software de funciones de Lambda de manera segura ytransparente.

AWS Greengrass consta de:

• Distribuciones de software• Software núcleo de AWS Greengrass

1

AWS Greengrass Guía para desarrolladoresSoftware AWS Greengrass Core

• SDK núcleo de AWS Greengrass• Servicio en la nube

• API de AWS Greengrass• Características

• Tiempo de ejecución de Lambda• Implementación de sombras• Administrador de mensajes• Administración de grupos• Servicio de detección• Agente de actualización transparente• Acceso a recursos locales• Inferencia de aprendizaje automático

Software AWS Greengrass CoreEl software núcleo de AWS Greengrass proporciona las siguientes funcionalidades:

• Permite implementar y ejecutar aplicaciones locales creadas con funciones Lambda y administradas através de la API de implementación.

• Habilita la mensajería local entre dispositivos a través de una red segura mediante de un esquema desuscripción administrado por medio del protocolo MQTT.

• Garantiza conexiones seguras entre los dispositivos y la nube mediante la autenticación y la autorizaciónde dispositivos.

• Proporciona actualizaciones de software para funciones Lambda definidas por el usuario de manerasegura y transparente.

El software núcleo de AWS Greengrass consta de:

Las instancias de núcleo de AWS Greengrass se configuran a través de las API de AWS Greengrass quecrean y actualizan las definiciones de grupos de AWS Greengrass almacenadas en la nube.

Versiones de AWS Greengrass CoreLas siguientes pestañas describe las novedades y cambios en las versiones de software de núcleo deAWS Greengrass.

GGC v1.6.0

Versión actual.

Nuevas características:

• que ejecutan código binario en el núcleo de Greengrass. Utilice el nuevo para escribir en C y C++.Para obtener más información, consulte the section called “Ejecutables Lambda” (p. 130).

• Opción de almacenamiento en caché local de mensajes que pueden persistir entre reinicios. Puededefinir la configuración de almacenamiento para mensajes MQTT que se ponen a la cola parasu procesamiento. Para obtener más información, consulte the section called “Cola de mensajesMQTT” (p. 26).

• Intervalo configurable de reintentos de reconexión máximos para cuando el dispositivodel núcleo está desconectado. Para obtener más información, consulte la propiedadmqttMaxConnectionRetryInterval en the section called “Archivo de configuración de AWSGreengrass Core” (p. 17).

2

AWS Greengrass Guía para desarrolladoresVersiones de AWS Greengrass Core

• Acceso del recurso local al directorio /proc del host. Para obtener más información, consulteObtener acceso a recursos locales con funciones de Lambda (p. 133).

• Directorio de escritura configurable. El software de núcleo de AWS Greengrass se puedeimplementar en ubicaciones de solo lectura y de lectura y escritura. Para obtener más información,consulte the section called “Directorio de escritura” (p. 24).

Mejoras y correcciones de errores:

• Se ha mejorado el rendimiento de la publicación de mensajes en el núcleo de Greengrass y entrelos dispositivos y el núcleo.

• Se han reducido los recursos de computación necesarios para procesar los registros generados porfunciones de Lambda definidas por el usuario.

GGC v1.5.0


• La inferencia de aprendizaje automático (ML) de AWS Greengrass ya está disponible con caráctergeneral. Puede llevar a cabo inferencias de aprendizaje automático localmente en los dispositivosde AWS Greengrass con modelos creados y entrenados en la nube. Para obtener más información,consulte Cómo realizar la inferencia de aprendizaje automático (p. 158).

• Las funciones de Lambda de Greengrass ahora admiten datos binarios como carga de entrada,además de JSON. Para utilizar esta característica, debe actualizar el SDK de AWS GreengrassCore a la versión 1.1.0, que puede descargar desde la página Software de la consola de AWS IoT.

Mejoras y correcciones de errores:

• Se ha reducido la huella de memoria global.• Se han realizado mejoras de desempeño para enviar mensajes a la nube.• Se han realizado mejoras de rendimiento y de estabilidad en el agente de descargas, el

administrador de certificados de dispositivos.y el agente de actualización OTA.• Correcciones de errores menores.

GGC v1.3.0


• El agente de actualización transparente (OTA) es capaz de administrar trabajos de actualizaciónde Greengrass implementados en la nube. El agente se encuentra en el nuevo directorio /greengrass/ota. Para obtener más información, consulte Actualizaciones de OTA del softwareAWS Greengrass Core (p. 118).

• La característica de acceso a recursos locales permite a las funciones de Lambda de Greengrassobtener acceso a los recursos locales, como dispositivos periféricos y volúmenes. Para obtener másinformación, consulte Obtener acceso a recursos locales con funciones de Lambda (p. 133).

GGC v1.1.0


• Los grupos de AWS Greengrass implementados se pueden restablecer eliminando funciones,suscripciones y configuraciones de Lambda. Para obtener más información, consulteRestablecimiento de implementaciones (p. 124).

• Compatibilidad con los runtimes Lambda de Node.js 6.10 y Java 8, además de Python 2.7.

3

AWS Greengrass Guía para desarrolladoresGrupos de AWS Greengrass

Para migrar de la versión anterior de núcleo de AWS Greengrass:

• Copie los certificados de la carpeta /greengrass/configuration/certs en /greengrass/certs.

• Copie /greengrass/configuration/config.json en /greengrass/config/config.json.

• Ejecute /greengrass/ggc/core/greengrassd en lugar de /greengrass/greengrassd.• Implemente el grupo en el nuevo núcleo.

GGC v1.0.0

Versión inicial.

Grupos de AWS GreengrassLos "grupos de AWS Greengrass" se pueden definir como una recopilación de valores de configuraciónpara núcleo de AWS Greengrass y los dispositivos que se comunican con ellos. En el siguiente diagramase muestran los objetos que componen un grupo de AWS Greengrass.

En el diagrama anterior:

A: Definición de grupo de AWS Greengrass

Una recopilación de información sobre el grupo de AWS Greengrass.B: Valores de configuración de grupo de AWS Greengrass

Entre ellas se incluyen:• Rol de grupo de AWS Greengrass.• Configuración del log.

4

AWS Greengrass Guía para desarrolladoresDispositivos de AWS Greengrass

• Autoridad de certificación y configuración de conexión local.• Información de conectividad de núcleo de AWS Greengrass.

C: núcleo de AWS Greengrass

El objeto de AWS IoT que representa al núcleo de AWS Greengrass.D: Definición de la función de Lambda

Una lista de funciones de Lambda que se implementarán en el núcleo de AWS Greengrass del grupo,con datos de configuración asociados. Para obtener más información, consulte Ejecutar funciones deLambda locales (p. 126).

E: Definición de suscripción

Una lista de suscripciones que permiten la comunicación mediante mensajes MQTT. Una suscripcióndefine:• Un origen del mensaje. Puede ser un objeto AWS IoT (dispositivo), función de Lambda, AWS IoT o

el servicio de sombra de AWS Greengrass local.• Un asunto, que es un tema de MQTT o un filtro de temas que se utiliza para filtrar datos de

mensajes.• Un destino de mensaje, que identifica el destino para los mensajes publicados por el origen de los

mensajes. Puede ser un objeto AWS IoT (dispositivo), función de Lambda, AWS IoT o el servicio desombra de AWS Greengrass local.

Para obtener más información, consulte the section called “Flujo de trabajo de mensajería deGreengrass” (p. 196).

F: Definición de dispositivos

Una lista que contiene un núcleo de AWS Greengrass y objetos AWS IoT que son miembros del grupode AWS Greengrass con datos de configuración asociados. Estos datos especifican qué dispositivosson núcleos de AWS Greengrass y qué dispositivos deben sincronizar los datos de las sombras conAWS IoT.

G: Definición de recurso

Una lista de los recursos locales y recursos de aprendizaje automático en el núcleo de AWSGreengrass, con datos de configuración asociados. Para obtener más información, consulte Obteneracceso a recursos locales con funciones de Lambda (p. 133) y Cómo realizar la inferencia deaprendizaje automático (p. 158).

Cuando se implementan, la definición de grupo de AWS Greengrass, las funciones de Lambda, losrecursos y la tabla de suscripciones se copian en un dispositivo de núcleo de AWS Greengrass.

Dispositivos de AWS GreengrassExisten dos tipos de dispositivos:

• Núcleos de AWS Greengrass.• Dispositivos de AWS IoT conectados a un núcleo de AWS Greengrass.

Un núcleo de AWS Greengrass es un dispositivo AWS IoT que ejecuta software de AWS Greengrassespecializado que se comunica directamente con los servicios de nube de AWS Greengrass e AWS IoT.Se trata de un dispositivo AWS IoT con su propio certificado que se utiliza para la autenticación con AWSIoT. Tiene una sombra de dispositivo y existe en el registro de dispositivos AWS IoT. Los núcleos deAWS Greengrass ejecutan un runtime de Lambda local, un agente de implementación y un rastreadorde direcciones IP en el servicio de nube de AWS Greengrass para permitir que los dispositivos AWS IoTdetecten automáticamente su información de conexión de grupo y núcleo.

5

AWS Greengrass Guía para desarrolladoresSDK

Cualquier dispositivo AWS IoT puede conectarse a un núcleo de AWS Greengrass. Estos dispositivosejecutan software escrito con el SDK para dispositivos AWS IoT.

La siguiente tabla muestra cómo se relacionan estos tipos de dispositivos.

El dispositivo de núcleo de AWS Greengrass almacena los certificados en dos ubicaciones:

• Certificado del dispositivo del núcleo de /greengrass/certs: el certificado del dispositivo del núcleo sedenomina hash.cert.pem (por ejemplo, 86c84488a5.cert.pem). Este certificado se utiliza paraautenticar el núcleo al conectarse con los servicios de AWS IoT y de AWS Greengrass.

• Certificado de servidor del núcleo de MQTT de /greengrass/ggc/var/state/server: el certificado deservidor del núcleo de MQTT se denomina server.crt. Este certificado se utiliza para la autenticaciónmutua entre el servicio de MQTT local (que está en el núcleo de Greengrass) y los dispositivos deGreengrass antes de que se intercambien mensajes.

SDKCuando se trabaja con AWS Greengrass se utilizan los siguientes SDK:

GGC 1.6.0

AWS SDK

Puede utilizar los SDK de AWS para compilar aplicaciones que funcionen con cualquier serviciode AWS, incluidos Amazon S3, Amazon DynamoDB, AWS IoT, AWS Greengrass y otros.En el contexto de AWS Greengrass, puede utilizar el SDK de AWS en funciones de Lambda

6


implementadas para hacer llamadas directas a cualquier servicio de AWS. Para obtener másinformación, consulte the section called “SDK” (p. 126).

SDKs de dispositivos AWS IoT

Los SDK para dispositivos AWS IoT le ayudan a conectar los dispositivos a los servicios deAWS IoT o AWS Greengrass. Los dispositivos deben saber a qué grupo de AWS Greengrasspertenecen y la dirección IP del núcleo de AWS Greengrass al que deben conectarse.

Aunque puede utilizar cualquiera de los SDK para dispositivos AWS IoT para conectar con unnúcleo de AWS Greengrass, solo los SDK de C++ y Python proporcionan funcionalidad específicade AWS Greengrass, tal como acceso al servicio de detección de AWS Greengrass y descargasde CA raíz de núcleo de AWS Greengrass. Para obtener más información, consulte SDK dedispositivos AWS IoT.

SDK de AWS Greengrass Core

El SDK de AWS Greengrass Core permite a las funciones de Lambda interactuar con el núcleode AWS Greengrass en el que se ejecutan para publicar mensajes, interactuar con el serviciode sombras de dispositivo local o invocar otras funciones de Lambda implementadas. Este SDKse utiliza exclusivamente para escribir funciones de Lambda que se ejecutan en el tiempo deejecución de Lambda en un núcleo de AWS Greengrass. Para obtener más información, consultethe section called “SDK” (p. 126).

GGC v1.5.0

AWS SDK

Puede utilizar los SDK de AWS para compilar aplicaciones que funcionen con cualquier serviciode AWS, incluidos Amazon S3, Amazon DynamoDB, AWS IoT, AWS Greengrass y otros. En elcontexto de AWS Greengrass, puede utilizar el SDK de AWS dentro de funciones de Lambdaimplementadas para hacer llamadas directas a cualquier servicio de AWS.





El SDK de AWS Greengrass Core permite a las funciones de Lambda interactuar con el núcleode AWS Greengrass en el que se ejecutan para publicar mensajes, interactuar con el serviciode sombras de dispositivo local o invocar otras funciones de Lambda implementadas. EsteSDK se utiliza exclusivamente para escribir funciones de Lambda que se ejecutan en el tiempode ejecución de Lambda en un núcleo de AWS Greengrass. Las funciones de Lambda que seejecutan en un núcleo de AWS Greengrass pueden interactuar con servicios de la nube de AWSdirectamente mediante el SDK de AWS. El SDK de AWS Greengrass Core y el SDK de AWS seencuentran en diferentes paquetes, por lo que puede utilizar ambos paquetes simultáneamente.Puede descargar el SDK de AWS Greengrass Core desde la página Software de la consola deAWS IoT.

El SDK de AWS Greengrass Core sigue el modelo de programación del SDK de AWS. Permitetrasladar fácilmente funciones de Lambda desarrolladas para la nube a funciones de Lambda

7

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




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



que se ejecutan en un núcleo de AWS Greengrass. Por ejemplo, utilizando el SDK de AWS, lasiguiente función de Lambda publica un mensaje en el tema "/some/topic" en la nube:

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

Para trasladar esta función de Lambda para su ejecución en un núcleo de AWS Greengrass,sustituya la instrucción import boto3 por import greengrasssdk, tal y como se muestra enel siguiente fragmento:

Note

El SDK de AWS Greengrass Core solo permite enviar mensajes MQTT con QoS = 0.

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

Esto permite probar las funciones de Lambda en la nube y migrarlas a AWS Greengrass con elmínimo esfuerzo.

Note

El AWS SDK forma parte del entorno de manera nativa cuando se ejecuta una funciónLambda en la nube de AWS. Si desea utilizar boto3 en una función Lambda implementadaen un núcleo de AWS Greengrass, no olvide incluir el AWS SDK en el paquete. Además, sidecide utilizar el SDK principal de AWS Greengrass y el AWS SDK simultáneamente en elmismo paquete, las funciones Lambda deben utilizar el espacio de nombres correcto. Paraobtener más información acerca de cómo crear un paquete de implementación, consulte:.

• Creación de un paquete de implementación de AWS Lambda (Python)• Creación de un paquete de implementación de AWS Lambda (NodeJS)• Creación de un paquete de implementación de AWS Lambda (Java)

GGC v1.3.0

AWS SDK




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





El SDK de AWS Greengrass Core sigue el modelo de programación del SDK de AWS. Permitetrasladar fácilmente funciones de Lambda desarrolladas para la nube a funciones de Lambdaque se ejecutan en un núcleo de AWS Greengrass. Por ejemplo, utilizando el SDK de AWS, lasiguiente función de Lambda publica un mensaje en el tema "/some/topic" en la nube:



Note




Note

El AWS SDK forma parte del entorno de manera nativa cuando se ejecuta una funciónLambda en la nube de AWS. Si desea utilizar boto3 en una función Lambda implementadaen un núcleo de AWS Greengrass, no olvide incluir el AWS SDK en el paquete. Además, si

9






decide utilizar el SDK principal de AWS Greengrass y el AWS SDK simultáneamente en elmismo paquete, las funciones Lambda deben utilizar el espacio de nombres correcto. Paraobtener más información acerca de cómo crear un paquete de implementación, consulte:.


GGC v1.1.0

AWS SDK










10









Note




Note



GGC v1.0.0

AWS SDK






El SDK de AWS Greengrass Core permite a las funciones de Lambda interactuar con el núcleode AWS Greengrass en el que se ejecutan para publicar mensajes, interactuar con el serviciode sombras de dispositivo local o invocar otras funciones de Lambda implementadas. EsteSDK se utiliza exclusivamente para escribir funciones de Lambda que se ejecutan en el tiempode ejecución de Lambda en un núcleo de AWS Greengrass. Las funciones de Lambda que seejecutan en un núcleo de AWS Greengrass pueden interactuar con servicios de la nube de AWSdirectamente mediante el SDK de AWS. El SDK de AWS Greengrass Core y el SDK de AWS se

11






AWS Greengrass Guía para desarrolladoresPlataformas compatibles y requisitos

encuentran en diferentes paquetes, por lo que puede utilizar ambos paquetes simultáneamente.Puede descargar el SDK de AWS Greengrass Core desde la página Software de la consola deAWS IoT.




Note




Note


• Creación de un paquete de implementación de AWS Lambda (Python)

Plataformas compatibles y requisitosEl software de núcleo de AWS Greengrass es compatible con las plataformas que se indican aquí yrequiere unas pocas dependencias.

GGC v1.6.0

• Plataformas admitidas:

12





• Arquitectura: ARMv7l. Sistema operativo: Linux. Distribución: Raspbian Jessie, 2017-03-02• Arquitectura: x86_64. Sistema operativo: Linux. Distribución: Amazon Linux (amzn-ami-

hvm-2016.09.1.20170119-x86_64-ebs)• Arquitectura: x86_64. Sistema operativo: Linux. Distribución: Ubuntu 14.04 – 16.04• Arquitectura: ARMv8 (AArch64). Sistema operativo: Linux. Distribución: Ubuntu 14.04 – 16.04

(Annapurna Alpine V2)• Se requieren los elementos siguientes:

• Al menos 128 MB de RAM asignados al dispositivo núcleo de AWS Greengrass.• Kernel de Linux versión 4.4 o superior: si bien varias versiones pueden funcionar con AWS

Greengrass, para una seguridad y un desempeño óptimos, recomendamos la versión 4.4 osuperior.

• Biblioteca Glibc versión 2.14 o superior.• El directorio /var/run debe existir en el dispositivo.• AWS Greengrass requiere que el dispositivo tenga habilitada la protección de enlaces

permanentes y simbólicos. Sin eso, AWS Greengrass solo puede ejecutarse en modo no seguro,mediante la marca -i.

• El usuario y el grupo ggc_user y ggc_group deben existir en el dispositivo.• Las siguientes configuraciones de kernel de Linux deben estar habilitado en el dispositivo:

• Espacio de nombres: CONFIG_IPC_NS, CONFIG_UTS_NS, CONFIG_USER_NS,CONFIG_PID_NS

• Grupos de control: CONFIG_CGROUP_DEVICE, CONFIG_CGROUPS, CONFIG_MEMCG• Otros: CONFIG_POSIX_MQUEUE, CONFIG_OVERLAY_FS,

CONFIG_HAVE_ARCH_SECCOMP_FILTER, CONFIG_SECCOMP_FILTER, CONFIG_KEYS,CONFIG_SECCOMP

• /dev/stdin, /dev/stdout y /dev/stderr deben estar habilitados.• El kernel de Linux debe admitir grupos de control.• La memoria cgroup debe estar habilitada y montada para permitir que AWS Greengrass

establezca el límite de memoria para las funciones de Lambda.• El certificado raíz para Amazon S3 e AWS IoT debe estar presente en el almacén de confianza

del sistema.• Los siguientes elementos pueden ser opcionales:

• Los dispositivos cgroup deben estar habilitados y montados si se usan funciones de Lambda conAcceso a recursos locales (LRA) (p. 133) para abrir archivos en el dispositivo de núcleo de AWSGreengrass.

• Si se usan las funciones de Lambda de Python, es necesario Python versión 2.7. De ser así,asegúrese de que está agregado a la variable de entorno PATH.

• Si se usan las funciones de Lambda de Node.JS, es necesario NodeJS versión 6.10 o posterior.De ser así, asegúrese de que está agregado a la variable de entorno PATH.

• Si se usan las funciones de Lambda de Java, es necesario Java versión 8 o posterior. De ser así,asegúrese de que está agregado a la variable de entorno PATH.

• Es necesario OpenSSL 1.0.1 o posterior para Agente OTA de Greengrass (p. 119), así comolos siguientes comandos: wget, realpath, tar, readlink, basename, dirname, pidof, df,grep y umount.

GGC v1.5.0

• Plataformas admitidas:• Arquitectura: ARMv7l. Sistema operativo: Linux. Distribución: Raspbian Jessie, 2017-03-02• Arquitectura: x86_64. Sistema operativo: Linux. Distribución: Amazon Linux (amzn-ami-

hvm-2016.09.1.20170119-x86_64-ebs)

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/

https://www.nodejs.org/

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

https://www.openssl.org/



• Arquitectura: x86_64. Sistema operativo: Linux. Distribución: Ubuntu 14.04 – 16.04• Arquitectura: ARMv8 (AArch64). Sistema operativo: Linux. Distribución: Ubuntu 14.04 – 16.04


• Al menos 128 MB de RAM asignados al dispositivo núcleo de AWS Greengrass.• Kernel de Linux versión 4.4 o superior: si bien varias versiones pueden funcionar con AWS

Greengrass, para una seguridad y un desempeño óptimos, recomendamos la versión 4.4 osuperior.

• Biblioteca Glibc versión 2.14 o superior.• El directorio /var/run debe existir en el dispositivo.• AWS Greengrass requiere que el dispositivo tenga habilitada la protección de enlaces








del sistema.• Los siguientes elementos pueden ser opcionales:

• Los dispositivos cgroup deben estar habilitados y montados si se usan funciones de Lambda conAcceso a recursos locales (LRA) (p. 133) para abrir archivos en el dispositivo de núcleo de AWSGreengrass.


• Si se usan las funciones de Lambda de Node.JS, es necesario NodeJS versión 6.10 o posterior.De ser así, asegúrese de que está agregado a la variable de entorno PATH.


• Es necesario OpenSSL 1.0.1 o posterior para Agente OTA de Greengrass (p. 119), así comolos siguientes comandos: wget, realpath, tar, readlink, basename, dirname, pidof, df,grep y umount.

GGC v1.3.0



(Annapurna Alpine V2)

14









• Se requieren los elementos siguientes:• Al menos 128 MB de RAM asignados al dispositivo núcleo de AWS Greengrass.• Kernel de Linux versión 4.4 o posterior. Si bien varias versiones pueden funcionar con AWS

Greengrass, para una seguridad y rendimiento óptimos, recomendamos la versión 4.4 o posterior.• Biblioteca Glibc versión 2.14 o posterior.• El directorio /var/run debe existir en el dispositivo.• AWS Greengrass requiere que el dispositivo tenga habilitada la protección de enlaces






• Es necesario el paquete sqlite3 para sombras de dispositivos de AWS IoT. Asegúrese de queestá agregado a la variable de entorno PATH.



del sistema.• Los siguientes elementos podrían ser opcionales:

• Los dispositivos cgroup deben estar habilitados y montados si se usan funciones de Lambda conacceso a recursos locales (LRA) (p. 133) para abrir archivos en el dispositivo de núcleo de AWSGreengrass.


• Si se usan las funciones de Lambda de Node.JS, es necesario Node.js versión 6.10 o posterior.De ser así, asegúrese de que está agregado a la variable de entorno PATH.


• Es necesario OpenSSL 1.01 o posterior para Agente OTA de Greengrass (p. 119) sí como lossiguientes comandos: wget, realpath, tar, readlink, basename, dirname, pidof, df,grep y umount.

GGC v1.1.0




• Al menos 128 MB de RAM asignados al dispositivo núcleo de AWS Greengrass.

15


https://www.sqlite.org/








• Kernel de Linux versión 4.4 o posterior. Si bien varias versiones pueden funcionar con AWSGreengrass, para una seguridad y rendimiento óptimos, recomendamos la versión 4.4 o posterior.

• Biblioteca Glibc versión 2.14 o posterior.• El directorio /var/run debe existir en el dispositivo.• AWS Greengrass requiere que el dispositivo tenga habilitada la protección de enlaces











• Si se usan las funciones de Lambda de Node.JS, es necesario Node.js versión 6.10 o posterior.De ser así, asegúrese de que está agregado a la variable de entorno PATH.


GGC v1.0.0




• Al menos 128 MB de RAM asignados al dispositivo núcleo de AWS Greengrass.• Kernel de Linux versión 4.4 o posterior. Si bien varias versiones pueden funcionar con AWS

Greengrass, para una seguridad y rendimiento óptimos, recomendamos la versión 4.4 o posterior.• Biblioteca Glibc versión 2.14 o posterior.• El directorio /var/run debe existir en el dispositivo.• AWS Greengrass requiere que el dispositivo tenga habilitada la protección de enlaces

permanentes y simbólicos. Sin eso, AWS Greengrass solo puede ejecutarse en modo no seguro,mediante la marca -i. 16









AWS Greengrass Guía para desarrolladoresEsperamos tener noticias suyas










Esperamos tener noticias suyasAgradecemos sus comentarios. Para contactar con nosotros, visite el Foro de AWS Greengrass.

Configuración de AWS Greengrass CoreUn núcleo de AWS Greengrass es un objeto AWS IoT. Al igual que ocurre con otros dispositivos AWSIoT, hay un núcleo en el registro, tiene una sombra de dispositivo y utiliza un certificado de dispositivopara la autenticación con AWS IoT. El dispositivo del núcleo ejecuta el software de núcleo de AWSGreengrass, que le permite administrar los procesos locales para grupos de Greengrass, como, porejemplo, comunicación, sincronización de sombras e intercambio de tokens.

El software núcleo de AWS Greengrass consta de:Note

Archivo de configuración de AWS Greengrass CoreEl archivo de configuración para el software de núcleo de AWS Greengrass es el archivo config.json,que se encuentra en el directorio /greengrass-root/config. Para revisar el contenido de este archivo,ejecute el siguiente comando:

cat /greengrass-root/config/config.json

Note

En AWS Greengrass Core v1.0.0, se implementa config.json para /greengrass-root/configuración.

A continuación se muestra un ejemplo de un archivo config.json.

17




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

AWS Greengrass Guía para desarrolladoresArchivo de configuración de AWS Greengrass Core

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 utiliza la opción Easy group creation (Creación de grupo sencilla) de consola de AWSGreengrass, entonces el archivo config.json se implementa en el dispositivo del núcleo en unestado de trabajo que especifica la configuración predeterminada.

El archivo config.json admite las siguientes propiedades:

Campo Descripción Notas

caPath La ruta del CA raíz de AWS IoTdel directorio /greengrass-root/certs.

Guarde el archivo en/greengrass-root/certs.

certPath La ruta del certificado denúcleo de AWS Greengrassdel directorio /greengrass-root/certs.


keyPath La ruta de la clave privada denúcleo de AWS Greengrassdel directorio /greengrass/certs.


thingArn El Nombre de recurso deAmazon (ARN) del objeto deAWS IoT que representa eldispositivo núcleo de AWSGreengrass.

Busque esto para su núcleo enconsola de AWS Greengrassen Cores (Núcleos) o puedeejecutar el comando de CLIaws greengrass list-core-definitions.

iotHost El punto de enlace de AWS IoT. Busque esto en consolade AWS IoT en Settings(Configuración) o puedeejecutar el comando deCLI aws iot describe-endpoint.

18

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

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


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




ggHost El punto de enlace de AWSGreengrass.

Este valor usa el formatogreengrass.iot.region.amazonaws.com.Usa la misma región queiotHost.

keepAlive El periodo de MQTTKeepAlive en segundos.

Se trata de un valor opcional. Elvalor predeterminado es 600.

mqttMaxConnectionRetryIntervalEl intervalo máximo (ensegundos) entre los reintentosde conexión MQTT si se pierdela conexión.

Especifique este valor como unnúmero entero sin firmar. Setrata de un valor opcional. Elvalor predeterminado es 60.

useSystemd Indica si su dispositivo usasystemd.

Los valores válidos sonyes o no. Ejecute el scriptcheck_ggc_dependenciesen el Módulo 1 (p. 31) paracomprobar si el dispositivo usasystemd.

managedRespawn Una característica deactualizaciones transparentes(OTA) opcional, que indica queel agente OTA debe ejecutar uncódigo personalizado antes deuna actualización.

Los valores válidos sontrue o false. Para obtenermás información, consulteActualizaciones de OTA delsoftware AWS GreengrassCore (p. 118).

writeDirectory El directorio de escritura dondeAWS Greengrass crea todos losrecursos de lectura y escritura.

Se trata de un valor opcional.Para obtener más información,consulte Configurar undirectorio de escritura paraAWS Greengrass (p. 24).

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}

El archivo config.json aparece en /greengrass/config/ y contiene los parámetros siguientes:

19

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



caPath La ruta del certificado de CAraíz de AWS IoT de la carpeta /greengrass/certs.

Guarde el archivo en la carpeta/greengrass/certs.

certPath La ruta del certificado de núcleode AWS Greengrass de lacarpeta /greengrass/certs.


keyPath La ruta de la clave privada denúcleo de AWS Greengrassde la carpeta /greengrass/certs.


thingArn El Nombre de recurso deAmazon (ARN) del objeto deAWS IoT que representa núcleode AWS Greengrass.

Busque esto para su núcleo enconsola de AWS Greengrassen Cores (Núcleos) o puedeejecutar el comando awsgreengrass list-core-definitions.

iotHost El punto de enlace de AWS IoT. Busque esto en consolade AWS IoT en Settings(Configuración) o puedeejecutar el comando aws iotdescribe-endpoint.


Este valor usa el formatogreengrass.iot.region.amazonaws.com.Usa la misma región queiotHost.


Se trata de un valor opcional.El valor predeterminado es 600segundos.

useSystemd Indica si su dispositivo usasystemd.

Los valores son yes ono. Utilice el script dedependencias del Módulo1 (p. 31) para comprobar siel dispositivo usa systemd.


Para obtener más información,consulte Actualizacionesde OTA del software AWSGreengrass Core (p. 118).

GGC v1.3.0

{ "coreThing": { "caPath": "ROOT_CA_PEM_HERE", "certPath": "CLOUD_PEM_CRT_HERE", "keyPath": "CLOUD_PEM_KEY_HERE", "thingArn": "THING_ARN_HERE",

20










"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}

El archivo config.json aparece en /greengrass/config/ y contiene los parámetros siguientes:









Se puede encontrar en consolade AWS Greengrass, en ladefinición de su objeto de AWSIoT.

iotHost El punto de enlace de AWS IoT. Se puede encontrar en consolade AWS IoT, en Settings.


Se puede encontrar en consolade AWS IoT, en Settings congreengrass. como prefijo.



useSystemd Una marca binaria si eldispositivo usa systemd.



Para obtener más información,consulte Actualizacionesde OTA del software AWSGreengrass Core (p. 118).

21





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" } }}

El archivo config.json existe en /greengrass/config/ y contiene los parámetros siguientes:

















22





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" } }}

El archivo config.json existe en /greengrass/configuration/ y contiene los parámetrossiguientes:


caPath La ruta del certificado deCA raíz de AWS IoT de lacarpeta /greengrass/configuration/certs.

Guarde el archivo en lacarpeta /greengrass/configuration/certs.

certPath La ruta del certificado denúcleo de AWS Greengrassde la carpeta /greengrass/configuration/certs.


keyPath La ruta de la clave privada denúcleo de AWS Greengrassde la carpeta /greengrass/configuration/certs.











23




AWS Greengrass Guía para desarrolladoresDirectorio de escritura

Configurar un directorio de escritura para AWSGreengrassDe forma predeterminada, el software de núcleo de AWS Greengrass se implementa en un solo directorioraíz donde AWS Greengrass realiza todas las operaciones de lectura y escritura. Sin embargo, puedeconfigurar AWS Greengrass para que utilice un directorio independiente para todas las operacionesde escritura, incluida la creación de directorios y archivos. En este caso, AWS Greengrass utiliza dosdirectorios de nivel superior:

• El directorio greengrass-root, que puede dejar como lectura-escritura o, si lo desea, solo lectura.Contiene el software de núcleo de AWS Greengrass y otros componentes fundamentales que debenpermanecer inmutables durante el tiempo de ejecución, como, por ejemplo, certificados y config.json.

• El directorio de escritura especificado. Contiene contenido con permiso de escritura, como registros,información de estado y funciones de Lambda implementadas, definidas por el usuario.

Esta configuración da como resultado la siguiente estructura de directorios.

Directorio raíz de 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/

Directorio de escritura

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

24

AWS Greengrass Guía para desarrolladoresDirectorio de escritura

| |-- state/

Para configurar un directorio de escritura

1. Ejecute el siguiente comando para detener el daemon de AWS Greengrass:

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

2. Abra greengrass-root/config/config.json para editarlo como usuario.3. Añada writeDirectory como parámetro y especifique la ruta al directorio de destino, tal y como se

muestra en el siguiente ejemplo.

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

Note

Puede actualizar la configuración writeDirectory tantas veces como desee. Despuésde actualizar la configuración, AWS Greengrass utiliza el directorio de escritura reciénespecificado en el siguiente inicio, pero no migra contenido desde el directorio de escrituraanterior.

4. Ahora que el directorio de escritura está configurado, tiene la opción de hacer que el directoriogreengrass-root sea de solo lectura. Para obtener instrucciones, consulte Cómo hacer que eldirectorio raíz de Greengrass sea de solo lectura (p. 25).

De lo contrario, inicie el daemon de AWS Greengrass:

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

Cómo hacer que el directorio raíz de Greengrass sea de solo lectura

1. Conceda el acceso necesario a AWS Greengrass:

Note

Este paso solo es necesario si desea hacer el directorio raíz de Greengrass de solo lectura.El directorio de escritura debe estar configurado antes de comenzar este procedimiento.

a. Otorgue permisos de lectura y escritura al propietario de config.json.

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

b. Haga a ggc_user el propietario de los certificados y los directorios Lambda del sistema.

25

AWS Greengrass Guía para desarrolladoresCola de mensajes MQTT

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. Haga que el directorio raíz greengrass-root sea de solo lectura empleando el mecanismo queprefiera.

Note

Una forma para que el directorio raíz greengrass-root sea de solo lectura es montar eldirectorio como de solo lectura. Sin embargo, para aplicar actualizaciones OTA al softwaredel núcleo de un directorio montado, en primer lugar, es necesario desmontar el directorioy luego volver a montarlo después de la actualización. Puede añadir estas operacionesumount y mount a los scripts ota_pre_update y ota_post_update. Para obtener másinformación sobre las actualizaciones OTA, consulte the section called “Agente OTA deGreengrass” (p. 119) y the section called “Actualización de AWS Greengrass Core conregeneración administrada” (p. 122).

3. Inicie el daemon.

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

Si los permisos del paso 1 no están establecidas correctamente, el daemon no se iniciará.

Cola de mensajes MQTTLos mensajes MQTT que se destinan a destinos en la nube se ponen en la cola a la espera deprocesamiento. Los mensajes en la cola se procesan siguiendo el orden primero en entrar, primero en salir(FIFO). Después de que un mensaje se procesa y se publica en la nube, el mensaje se elimina de la cola.AWS Greengrass administra la cola por medio de una función de Lambda GGCloudSpooler definida porel sistema.

Configurar la cola de mensajes MQTTPuede configurar AWS Greengrass para almacenar los mensajes sin procesar en la memoria o en elalmacenamiento en caché local A diferencia del almacenamiento en memoria, el almacenamiento encaché local tiene la capacidad de persistir a través de reinicios del núcleo (por ejemplo, después de laimplementación de un grupo o reinicio de un dispositivo), por lo que AWS Greengrass puede continuarprocesando mensajes. También puede configurar el tamaño del almacenamiento.

Note

Las versiones 1.5.0 y anteriores usan almacenamiento en memoria con un tamaño de cola de 2,5MB. No puede ajustar la configuración de almacenamiento para versiones anteriores.

Para definir la configuración de almacenamiento se utilizan las siguientes variables de entorno para lafunción de Lambda GGCloudSpooler.

• GG_CONFIG_STORAGE_TYPE. La ubicación de la cola de mensajes. Los siguientes valores sonválidos:• FileSystem. Almacena los mensajes sin procesar en el almacenamiento en caché local. Cuando

el núcleo se reinicia, se conservan los mensajes que hay en cola a la espera de procesamiento. Losmensajes se eliminan después de que se procesan.

• Memory (predeterminada). Almacena los mensajes sin procesar en la memoria. Cuando el núcleo sereinicia, los mensajes en la cola se pierden.

26


Esta opción está optimizada para dispositivos con capacidades limitadas de hardware. Si se utilizaesta configuración, le recomendamos que implemente grupos o reinicie el dispositivo en un momentoen el que la interrupción del servicio sea mínima.

• GG_CONFIG_MAX_SIZE_BYTES. El tamaño de almacenamiento en bytes. Este valor puede sercualquier número entero que no sea negativo superior o igual a 262144 (256 KB); un tamaño máspequeño impide que se inicie el software de núcleo de AWS Greengrass. El valor predeterminado es2.5 MB de tamaño. Cuando se alcanza el límite de tamaño, los mensajes en cola más antiguos sesustituyen por mensajes nuevos.

Para almacenar los mensajes en caché en el almacenamiento localPara configurar AWS Greengrass para almacenar los mensajes en caché en el sistema de archivos demodo que persistan entre los reinicios del núcleo, debe crear una versión de definición de la función dondela función GGCloudSpooler especifique el tipo de almacenamiento FileSystem. Debe utilizar la API deAWS Greengrass para configurar el almacenamiento en caché local. No puede hacer esto en la consola.

En el procedimiento siguiente, se usa el comando de CLI create-function-definition-versionpara configurar la cola de impresión para que guarde los mensajes que hay en cola en el sistema dearchivos. También configura un tamaño de cola de 2.6 MB.

Note

Este procedimiento supone que va a actualizar la configuración de la versión más reciente de ungrupo existente.

1. Obtenga los ID de la versión de grupo y grupo de Greengrass de destino.

aws greengrass list-groups

2. Copie las propiedades Id y LatestVersion de su grupo de destino del resultado.3. Obtenga la última versión del grupo.

• Reemplace id-grupo con el Id que ha copiado.• Reemplace id-última-versión-grupo con la LatestVersion que ha copiado.

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

4. Desde el objeto Definition en el resultado, copie el ComponentDefinitionVersionArn paracada componente del grupo excepto FunctionDefinitionVersionArn. Utilizará estos valorescuando cree una nueva versión del grupo.

5. Desde FunctionDefinitionVersionArn en el resultado, copie el ID de la definición de la función.El ID es el GUID que sigue al segmento functions en el ARN.

Note

Si lo desea, para crear una definición de la función ejecute el comando create-function-definition y luego copie el ID del resultado.

6. Añada una versión de definición de la función a la definición de la función.

• Reemplace id-definición-función con el Id que ha copiado de la definición de la función.• Reemplace id-función-arbitraria con un nombre para la función, como, por ejemplo,spooler-function.

27

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

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

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


• Agregue las funciones de Lambda que desea incluir en esta versión en la matriz functions. Puedeutilizar el comando get-function-definition-version para obtener las funciones de de unaversión de la definición de función existente.

Warning

Asegúrese de que se especifica un valor para GG_CONFIG_MAX_SIZE_BYTES que seamayor o igual a 262144. Un tamaño más pequeño impide que se inicie el software de núcleode AWS Greengrass.

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. Copie el Arn de la versión de definición de la función del resultado.8. Cree una versión de grupo que contenga la función de Lambda definida por el sistema.

• Reemplace id-grupo con el Id del grupo.• Reemplace arn-versión-definición-núcleo con el CoreDefinitionVersionArn que ha

copiado de la última versión del grupo.• Reemplace arn-versión-definición-función con el Arn que ha copiado para la nueva

versión de definición de la función.• Reemplace los ARN para otros componentes del grupo empleando los valoresComponentDefinitionVersionArn que ha copiado de la última versión del grupo.

• Elimine los parámetros no utilizados. Por ejemplo, elimine --resource-definition-version-arn si la versión de su grupo no contiene ningún recurso.

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. Copie la Version del resultado. Este es el ID de la nueva versión del grupo.10. Implemente el grupo.

• Reemplace id-grupo con el Id que ha copiado para el grupo.• Reemplace id-versión-grupo con el Version que ha copiado para el nuevo grupo.

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

28

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

AWS Greengrass Guía para desarrolladoresIniciar Greengrass en el arranque del sistema

Para actualizar la configuración de almacenamiento, utilice la API de AWS Greengrass para crearuna nueva versión de la definición de la función que contenga la función GGCloudSpooler con laconfiguración actualizada. A continuación, añada la versión de la definición de la función a una nuevaversión del grupo (junto con los demás componentes del grupo) e implemente la versión del grupo. Sidesea restaurar la configuración predeterminada, puede crear una versión de definición de la función queno incluya la función GGCloudSpooler.

Esta función de Lambda definida por el sistema no es visible en la consola. Sin embargo, después deque la función se añade a la última versión del grupo, se incluye en las implementaciones que se realizandesde la consola (a menos que utilice la API para sustituirla o eliminarla).

Configurar el sistema Init para que inicie el daemon deGreengrassEs una buena práctica configurar el sistema init para que inicie el daemon de Greengrass durante elarranque, especialmente si administra grandes flotas de dispositivos.

Existen diferentes tipos de sistema init, como initd, systemd y SystemV, que utilizan parámetros deconfiguración similares. En el siguiente ejemplo se muestra un archivo de servicio para systemd. Elparámetro Type se establece en forking porque greengrassd (que se utiliza para iniciar Greengrass)bifurca el proceso del daemon de Greengrass y el parámetro Restart está establecido en on-failurepara indicar a systemd que reinicie Greengrass si Greengrass entra en un estado de error.

Note

Para ver si su dispositivo usa systemd, ejecute el script check_ggc_dependencies como sedescribe en el Módulo 1 (p. 31). A continuación, para utilizar systemd, asegúrese de que elparámetro useSystemd en config.json (p. 17) está establecido en 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

Para obtener información acerca de cómo crear y habilitar un archivo de servicio para systemd en unRaspberry Pi, consulte SYSTEMD en la documentación de Raspberry Pi.

29

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

AWS Greengrass Guía para desarrolladoresRequisitos

Introducción a AWS GreengrassEste tutorial incluye seis módulos, cada uno de ellos diseñado para mostrarle los aspectos básicos deAWS Greengrass y ayudarle a empezar con los pasos mínimos posibles. Este tutorial cubre:

• El modelo de programación de AWS Greengrass• Conceptos fundamentales, como dispositivos del núcleo, grupos y suscripciones de AWS Greengrass• El proceso de implementación para ejecutar funciones AWS Lambda en el borde

RequisitosPara completar este tutorial, necesitará lo siguiente:

• Un sistema Mac, Windows o de tipo UNIX.• Una cuenta de Amazon Web Services (AWS). Si no tiene una cuenta de AWS, consulte the section

called “Cree una cuenta de AWS” (p. 31).• El uso de una región de AWS que admita AWS Greengrass. Para ver la lista de las regiones que AWS

Greengrass admite, consulte Regiones y puntos de enlace de AWS en la AWS General Reference.

Important

Tome nota de su región para asegurarse de usarla de forma consistente durante todo estetutorial; cambiar de región accidentalmente a mitad del tutorial sería problemático. En el últimoejercicio de este tutorial, se supone que la región con la que se está trabajando es EE.UU. Este(Norte de Virginia), así que recomendamos que utilice dicha región, de ser posible.

• Un Raspberry Pi 3 Model B con una tarjeta microSD de 8 GB o una instancia Amazon EC2. Ya que AWSGreengrass está diseñado para usarse con hardware físico, le recomendamos que utilice un RaspberryPi.

Note

Si no conoce el modelo de su Raspberry Pi, puede ejecutar el siguiente comando:

cat /proc/cpuinfo

Cerca de la parte inferior de la lista, anote el valor del atributo Revision. Puede determinarel modelo de su Pi utilizando este valor junto con la tabla de ¿Qué Pi tengo? Por ejemplo, siel valor de Revision es a02082, en la tabla se puede ver que el dispositivo Pi es un modelo3 B y que su arquitectura debe ser armv71 o superior. Para determinar la arquitectura de suRaspberry Pi, ejecute el siguiente comando:

uname -m

El resultado debe ser superior o igual a armv71.• Conocimientos básicos sobre Python 2.7.

Aunque este tutorial se centra en la ejecución de AWS Greengrass en un Raspberry Pi o en una instanciaAmazon EC2, también se admiten otras plataformas. Para obtener más información, consulte Plataformascompatibles y requisitos (p. 12).

30

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

https://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 Guía para desarrolladoresCree una cuenta de AWS

Cree una cuenta de AWSSi no dispone de una cuenta de AWS, siga estos pasos:

1. Abra la página de inicio de AWS y elija Crear una cuenta de AWS.

Note

Si ha iniciado sesión en AWS recientemente, es posible que vea el mensaje Sign In to theConsole.

2. Siga las instrucciones en línea. Parte del procedimiento de inscripción consiste en recibir una llamadatelefónica y escribir un PIN con el teclado del teléfono.

Important

Asegúrese de que su cuenta tenga privilegios administrativos antes de continuar.

Módulo 1: Configuración del entorno paraGreengrass

Este módulo le enseña a preparar un Raspberry Pi de serie, una instancia Amazon EC2 o cualquier otrotipo de dispositivo para que lo use AWS Greengrass.

Important

Utilice la lista desplegable Filter View en la esquina superior derecha de esta página web paraelegir la plataforma.

Completar este módulo debería tomarle menos de 30 minutos.

Configuración de un Raspberry PiSi es la primera vez que configura un Raspberry Pi, debe seguir todos estos pasos. Si está utilizando unRaspberry Pi existente, puede ir directamente al paso 9. Sin embargo, le recomendamos que vuelva ainstalar la imagen del sistema operativo de su Raspberry Pi, tal y como se recomienda en el paso 2.

1. Descargue e instale una aplicación para formatear tarjetas SD, como SD Memory Card Formatter oPiBakery. Inserte la tarjeta SD en su equipo. Inicie el programa y elija la unidad donde insertó la tarjetaSD. Puede formatear rápidamente la tarjeta SD.

2. Descargue el sistema operativo Raspbian Jessie como un archivo .zip. Actualmente, AWSGreengrass solo admite 2017-03-02-raspbian-jessie.zip.

3. En una herramienta de escritura de tarjetas SD (como Etcher), siga las instrucciones para escribir elarchivo 2017-03-02-raspbian-jessie.zip descargado en la tarjeta SD. Dado que la imagen delsistema operativo es grande, este paso puede tardar un tiempo. Extraiga la tarjeta SD del equipo einserte la tarjeta microSD en el Raspberry Pi.

4. Para la primera operación de inicio, le recomendamos que conecte el Raspberry Pi a un monitor (através de HDMI), un teclado y un ratón. A continuación, conecte su Pi a una fuente de alimentaciónpor microUSB para que se inicie el sistema operativo Raspbian.

5. Es posible que desee configurar la distribución del teclado del Pi antes de continuar. Para hacerlo,seleccione el icono de Raspberry en la esquina superior derecha, elija Preferences y, a continuación,Mouse and Keyboard Settings. A continuación, elija la pestaña Keyboard, Keyboard Layout y luegoelija una variante de teclado adecuada.

6. A continuación, conecte su Raspberry Pi a Internet a través de una red Wi-Fi o un cable Ethernet.

31

http://aws.amazon.com/

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

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


https://etcher.io/

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

AWS Greengrass Guía para desarrolladoresConfiguración de un Raspberry Pi

Note

Conecte su Raspberry Pi a la misma red que a la que está conectado su equipo y asegúresede que tanto tu equipo como Raspberry Pi tienen acceso a Internet antes de continuar. Siestá en un entorno de trabajo o detrás de un firewall, es posible que necesite conectar sudispositivo Pi y su equipo a la red de invitados para que ambos dispositivos estén en lamisma red. Sin embargo, esta solución podría desconectar su equipo de los recursos dela red local, como la intranet. Otra solución puede ser conectar el dispositivo Pi y el equipoa la red wifi de invitados y conectar la red local a través de un cable Ethernet. Con estaconfiguración, el equipo debería poder conectarse al Raspberry Pi a través de la red wifi deinvitados y a los recursos de la red local a través del cable Ethernet.

7. Debe configurar SSH en el Raspberry Pi para conectarse de forma remota. En su Raspberry Pi, abrauna ventana de terminal y ejecute el siguiente comando:

sudo raspi-config

Debería ver lo siguiente:

Desplácese hacia abajo y elija Interfacing Options y, a continuación, elija P2 SSH. Cuando se lesolicite, seleccione Yes utilizando la tecla Tab (y después Intro). Ahora SSH debería estar habilitado.Elija OK. Presione la tecla Tab para finalizar y luego presione la tecla Intro. Por último, reinicie elRaspberry Pi ejecutando el siguiente comando:

sudo reboot

8. En su Raspberry Pi ejecute el siguiente comando en el terminal:

hostname -I

Se devuelve la dirección IP de su Raspberry Pi.

Note

Si, en el paso siguiente, recibe el mensaje Are you sure you want to continueconnecting (yes/no)? relacionado con la huella digital de la clave ECDSA, escriba yes.La contraseña predeterminada del Raspberry Pi es raspberry.

Si utiliza macOS, abra una ventana de terminal y escriba lo siguiente:

32

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

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


ssh pi@IP-address

Aquí, IP-address se corresponde con la dirección IP del Raspberry Pi, que ha obtenido utilizando elcomando hostname -I.

Si utiliza Windows, tendrá que instalar y configurar PuTTY. Elija Connection, Data y asegúrese de quePrompt está seleccionado:

A continuación, elija Session, escriba la dirección IP del Raspberry Pi y elija Open con la configuraciónpredeterminada. Por ejemplo (es muy probable que su dirección IP sea diferente):

33

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


Si se abre el cuadro de diálogo Security Alert (Alerta de seguridad) de PuTTY, elija una respuestaadecuada como Yes (Sí).

De esta forma, se abrirá una ventana de terminal similar a la siguiente. El nombre de inicio de sesión yla contraseña predeterminados del Raspberry Pi son pi y raspberry, respectivamente.

34


Note

Si su equipo está conectado a una red remota mediante VPN (por ejemplo, una red deltrabajo), puede haber problemas para conectarse desde el equipo al Raspberry Pi medianteSSH.

9. Ahora está preparado para configurar el Raspberry Pi para AWS Greengrass. En primer lugar, ejecutelos siguientes comandos desde una ventana de terminal de Raspberry Pi local o una ventana determinal de SSH:

sudo adduser --system ggc_usersudo addgroup --system ggc_group

10. Ejecute los siguientes comandos para actualizar la versión de kernel de Linux de su Raspberry Pi.

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

Aunque es posible que varias versiones del kernel funcionen con AWS Greengrass, para obtener elmejor desempeño y seguridad, le recomendamos que use la versión del kernel que se indica en elpaso 2. Para activar el nuevo firmware, reinicie el Raspberry Pi:

sudo reboot

Si es necesario, espere aproximadamente un minuto y vuelva a conectarse al Raspberry Pi medianteSSH. A continuación, ejecute el siguiente comando para asegurarse de que dispone de la versión dekernel adecuada:

uname -a

Debería recibir un resultado parecido al siguiente, en el que el elemento clave es la información sobrela versión de Raspberry Pi con Linux 4.9.30:

35


11. Para mejorar la seguridad en el dispositivo Pi, ejecute los siguientes comandos para habilitar laprotección de enlaces permanentes y simbólicos al inicio del sistema operativo.

cd /etc/sysctl.dls

Si ve el archivo 98-rpi.conf, utilice un editor de texto (como, por ejemplo, leafpad, nano o vi)para añadir las siguientes dos líneas al final del archivo (puede ejecutar el editor de texto con elcomando sudo para evitar problemas de permisos de escritura, al igual que en sudo nano 98-rpi.conf).

fs.protected_hardlinks = 1fs.protected_symlinks = 1

Si no ve el archivo 98-rpi.conf, siga las instrucciones del archivo README.sysctl.

Ahora reinicie el dispositivo Pi:

sudo reboot

Después de aproximadamente un minuto, conéctese al dispositivo Pi mediante SSH comocorresponda y, a continuación, ejecute los siguientes comandos desde un terminal de Raspberry Pipara confirmar el cambio entre enlaces permanentes y simbólicos:

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

Debería ver fs.protected_hardlinks = 1 y fs.protected_symlinks = 1.12. Su Raspberry Pi ya debería estar preparado para AWS Greengrass. Para asegurarse de que

dispone de todas las dependencias necesarias para AWS Greengrass, descargue el comprobador dedependencias de AWS Greengrass desde el repositorio de GitHub y ejecútelo en el dispositivo Pi delsiguiente modo:

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 relación con el comando more, presione la tecla de la barra espaciadora para ver otra pantalla detexto.

Important

Este tutorial solo utiliza el AWS IoT Device SDK para Python. Por lo tanto, puede pasar poralto las advertencias de que falta el NodeJS 6.10 opcional y los requisitos previos de Java 8que el script check_ggc_dependencies pueda producir.

Para obtener más información acerca del comando modprobe, puede ejecutar man modprobe en elterminal.

36

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

AWS Greengrass Guía para desarrolladoresConfiguración de una instancia Amazon EC2

Ya está terminada la configuración del dispositivo Raspberry Pi. Siga en the section called “Módulo 2:Instalación del software de Greengrass Core” (p. 44).

Configuración de una instancia Amazon EC21. Inicie sesión en la Consola de administración de AWS y lance una instancia Amazon EC2 mediante

una AMI (Imagen de máquina de Amazon) de Amazon Linux. Para obtener más información acerca delas instancias Amazon EC2, consulte la Amazon EC2 Getting Started Guide.

2. Después de que se ejecute la instancia Amazon EC2, habilite el puerto 8883 para permitir lascomunicaciones MQTT entrantes para que otros dispositivos puedan conectarse con núcleo deAWS Greengrass. En el panel de navegación izquierdo de la consola de Amazon EC2, elija SecurityGroups.

Elija la instancia que acaba de lanzar y, a continuación, elija la pestaña Inbound.

37

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

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


De forma predeterminada, solo se habilita un puerto para SSH. Para habilitar el puerto 8883, elija elbotón Edit. A continuación, elija el botón Add Rule y cree una regla TCP personalizada, tal y como semuestra más abajo y, a continuación, seleccione Save.

3. En el panel izquierdo, elija Instances, elija su instancia y, después, elija el botón Connect. Conéctesea la instancia Amazon EC2 mediante SSH. Puede utilizar PuTTY para Windows o Terminal paramacOS.

38



4. Una vez conectado a la instancia Amazon EC2 a través de SSH, ejecute los siguientes comandospara crear el usuario ggc_user y el grupo ggc_group:

sudo adduser --system ggc_usersudo groupadd --system ggc_group

5. Para mejorar la seguridad en el dispositivo, habilite la protección de enlaces permanentes y simbólicosal inicio del sistema operativo. Para ello, ejecute los comandos siguientes:

cd /etc/sysctl.dls

Utilice su editor de texto favorito (leadpad, nano, vi, etc.) para añadir las dos líneas siguientes alfinal del archivo 00-defaults.conf. Es posible que tenga que cambiar los permisos (utilizando elcomando chmod) para escribir en el archivo o utilizar el comando sudo para editar como raíz (porejemplo, sudo nano 00-defaults.conf).

fs.protected_hardlinks = 1fs.protected_symlinks = 1

Ejecute el siguiente comando para volver a arrancar la instancia Amazon EC2.

39

AWS Greengrass Guía para desarrolladoresConfiguración de otros dispositivos

sudo reboot

Después de unos minutos, conéctese a la instancia mediante SSH como antes. A continuación,ejecute el siguiente comando para confirmar el cambio.

sudo sysctl -a | grep fs.protected

Debería ver los enlaces permanentes y simbólicos establecidos en 1.6. Extraiga y ejecute el siguiente script para montar grupos de control de Linux (cgroups). Es una

dependencia de 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

Su instancia Amazon EC2 ahora debería estar preparada para AWS Greengrass. Para asegurarsede que dispone de todas las dependencias, extraiga y ejecute el script de dependencias de AWSGreengrass siguiente desde el repositorio de 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

Ya está terminada la configuración de la instancia Amazon EC2. Siga en the section called “Módulo 2:Instalación del software de Greengrass Core” (p. 44).

Configuración de otros dispositivosSi es la primera vez que usa AWS Greengrass, le recomendamos que use un Raspberry Pi o una instanciaAmazon EC2 y que siga los pasos anteriores para configurar el dispositivo. Siga los pasos que se indicanmás abajo para preparar su propio dispositivo compatible con AWS Greengrass para AWS Greengrass.

1. Para asegurarse de que tiene preparados otros dispositivos para ejecutar AWS Greengrass,descargue y extraiga el comprobador de dependencias de Greengrass desde el repositorio de GitHuby luego ejecute los comandos siguientes:

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

Este script se ejecuta en plataformas compatibles con AWS Greengrass y requiere los siguientescomandos del sistema Linux:

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

2. Instale en su dispositivo todas las dependencias necesarias, tal y como indica el script dedependencias. En caso de que falten dependencias en el nivel del kernel, es posible que tenga que

40

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




volver a compilar el kernel. Para montar grupos de control de Linux (cgroups), puede ejecutar elscript cgroupfs-mount.

Note

Si no hay errores en la salida, AWS Greengrass debería poder ejecutarse correctamente enel dispositivo.

Para ver la lista de requisitos y dependencias de AWS Greengrass, consulte Plataformas compatiblesy requisitos (p. 12).

Configuración de NVIDIA Jetson TX2 para AWS GreengrassSi el dispositivo del núcleo es un dispositivo NVIDIA Jetson TX2, este se debe configurar antes de instalarAWS Greengrass. En los pasos siguientes se describe cómo escribir el firmware en un instalador JetPack ycómo volver a compilar el kernel de manera que el dispositivo esté listo para instalar el software de núcleode AWS Greengrass.

Note

La versión del instalador JetPack que se utiliza depende de la versión del conjunto deherramientas CUDA de destino. En las siguientes instrucciones se presupone que está utilizandoJetPack 3.1 y la versión 8.0 del conjunto de herramientas CUDA, ya que los archivos binariospara TensorFlow v1.4.0 que AWS Greengrass proporciona para la inferencia de aprendizajeautomático (ML) están compilados con esta versión de CUDA. Para obtener más informaciónsobre la inferencia de aprendizaje automático de AWS Greengrass, consulte Cómo realizar lainferencia de aprendizaje automático (p. 158).

Cómo escribir el firmware de JetPack 3.1

1. En un escritorio físico que ejecute Ubuntu 14 o 16, escriba el firmware de JetPack 3.1, tal como sedescribe en Download and Install JetPack L4T.

Siga las instrucciones del instalador para instalar todos los paquetes y las dependencias en la placaJetson, que debe estar conectada al escritorio con un cable Micro-B. Inicie el dispositivo en modo derecuperación forzada.

Note

Después de la instalación de JetPack, debe utilizar las credenciales de ubuntu para iniciarsesión en el dispositivo. El agente SSH se bloquea cuando intenta iniciar sesión utilizandocualquier otra cuenta, incluso si se utiliza SSH directamente en la placa con esta cuenta.

2. Reinicie la placa en modo normal y, a continuación, conecte una pantalla a la placa.

Cómo volver a compilar el kernel de NVIDIA Jetson TX2Ejecute los siguientes comandos en la placa Jetson.

1. Compruebe las configuraciones del kernel:

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

41

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. Compruebe la configuración del desempeño y de alimentación:

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

3. Coloque la placa Jetson en el modo de alto desempeño:

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

4. Clone el repositorio de Git:

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

5. Modifique el script getKernelSources.sh, basándose en el siguiente listado de cambios:

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. Ejecute el script getKernelSources:

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

7. Cuando el sistema le pida que escriba algo para continuar, presione CTRL + Z para poner el script ensegundo plano.

42


8. Vaya a /usr/src/kernel/kernel-4.4/security/keys y edite el archivo Kconfig añadiendo las líneassiguientes entre KEYS y PERSISTENT_KEYRINGS:

config KEYS_COMPAT def_bool y depends on COMPAT && KEYS

9. Quite la pausa del script:

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

Escriba algunos caracteres para desbloquear el script.10. En la ventana de configuración que se abre, elija Enable loadable module support (Habilitar soporte de

módulos que se pueden cargar) y, a continuación, abra el submenú para habilitar la verificación de lafirma optionModule. Utilice las teclas de flecha para moverse y la barra espaciadora para seleccionaruna opción. A continuación, guarde los cambios y salga.

11. Verifique que KEYS_COMPAT está habilitado:

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

12. Abra la interfaz de configuración del kernel y habilite las configuraciones del kernel:

nvidia@tegra-ubuntu:~$ sudo make xconfig

Se abre una ventana que muestra todas las configuraciones del kernel. Utilice FIND para buscar lassiguientes palabras clave y márquelas.

Note

Las palabras clave varían en función de la configuración. La lista siguiente contieneversiones alternativas entre paréntesis que pueden ayudarle a encontrar las palabras claveequivalentes para su configuración.

• CONFIG_POSIX_MQUEUE (Cola de mensajes de POSIX)• CONFIG_OF_OVERLAY (Soporte del sistema de archivos de superposición)• CONFIG_OVERLAY_FS (Soporte del sistema de archivos de superposición)• CONFIG_USER_NS (Espacio de nombres de usuario)• CONFIG_MEMCG (Controlador de recurso de memoria para grupo de control)• CONFIG_CGROUP_DEVICE (Controlador de dispositivo para grupos de control)

13. Compile el kernel:

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

14. Verifique que las configuraciones del kernel están habilitadas:

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

43

AWS Greengrass Guía para desarrolladoresMódulo 2: Instalación del software de 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. Copie la imagen:

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

Módulo 2: Instalación del software de GreengrassCore

Este módulo le enseña a instalar el software de núcleo de AWS Greengrass en su dispositivo. Antes decomenzar, asegúrese de que ha completado el Módulo 1 (p. 31).

El software núcleo de AWS Greengrass proporciona las siguientes funcionalidades:

• Permite implementar y ejecutar aplicaciones locales que se han creado con funciones AWS Lambda y seadministran a través de la API de implementación.

• Habilita la mensajería local entre dispositivos a través de una red segura mediante de un esquema desuscripción administrado por medio del protocolo MQTT.

• Garantiza conexiones seguras entre los dispositivos y la nube mediante la autenticación y la autorizaciónde dispositivos.

• Proporciona actualizaciones de software para funciones de Lambda definidas por el usuario de manerasegura y transparente.

Completar este módulo debería tomarle menos de 30 minutos.

Configuración de AWS Greengrass en AWS IoT1. Inicie sesión en la Consola de administración de AWS en su equipo y abra consola de AWS IoT. Si es

la primera vez que abre esta consola, elija Get started.

A continuación, seleccione Greengrass:

44

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

AWS Greengrass Guía para desarrolladoresConfiguración de AWS Greengrass en AWS IoT

2. En la página Welcome to AWS Greengrass, elija Get Started:

45


3. Cree un grupo de AWS Greengrass. Un grupo de AWS Greengrass contiene información acerca delos dispositivos y la forma de procesar los mensajes en el grupo. Cada grupo de AWS Greengrassrequiere un dispositivo núcleo de AWS Greengrass que procese los mensajes enviados en el grupo.Un núcleo de AWS Greengrass necesita un certificado y una política de AWS IoT para obtener accesoa AWS Greengrass y servicios en la nube de AWS. En la página Set up your Greengrass group, elijaUse easy creation.

4. Escriba un nombre para el grupo (por ejemplo, MyFirstGroup) y luego elija Next:

46


5. Use el nombre predeterminado para núcleo de AWS Greengrass y, a continuación, elija Next:

6. En la página Run a scripted easy Group creation, elija Create Group and Core.

47


AWS IoT crea un grupo de AWS Greengrass automáticamente con las políticas de seguridad y losarchivos de configuración predeterminados para que pueda cargarlos en su dispositivo.

7. En la página de confirmación, descargue los recursos de seguridad del núcleo y el software AWSGreengrass Core, tal y como se indica a continuación:

a. En Download and store your Core's security resources (Descargar y almacenar los recursos deseguridad del núcleo), elija Download these resources as a tar.gz (Descargar estos recursoscomo un tar.gz) para descargar los recursos de seguridad necesarios de su núcleo de AWSGreengrass.

b. En Software configurations (Configuraciones de software) del software núcleo de AWSGreengrass, elija la distribución y la arquitectura de la CPU (y el sistema operativo, si esnecesario) que mejor se adapte a su dispositivo principal:

• Si utiliza un Raspberry Pi, descargue el paquete ARMv7l for Raspbian Jessie.• Si utiliza una instancia Amazon EC2, descargue uno de los paquetes de x86_64.

48

AWS Greengrass Guía para desarrolladoresInicio de AWS Greengrass en el dispositivo del núcleo

Important

Debe descargar tanto los recursos de seguridad como el software AWS Greengrass Coreantes de elegir Finish (Finalizar).

8. Después de descargar los recursos de seguridad y el software de AWS Greengrass Core, elija Finish(Finalizar).

La página de configuración de grupo se muestra en la consola:

Inicio de AWS Greengrass en el dispositivo del núcleo1. En el paso anterior (p. 48), descargó dos archivos desde el consola de AWS Greengrass:

• greengrass-OS-architecture-1.5.0.tar.gz: este archivo comprimido contiene el softwarede núcleo de AWS Greengrass que se ejecuta en el dispositivo de núcleo de AWS Greengrass.

• GUID-setup.tar.gz: este archivo comprimido contiene certificados de seguridad que permitencomunicaciones seguras con la nube de AWS IoT y el archivo config.json con información deconfiguración específica de su AWS IoT y del punto de enlace de núcleo de AWS Greengrass.

49


Si no recuerda la dirección IP de su dispositivo de núcleo de AWS Greengrass, abra un terminal en eldispositivo de núcleo de AWS Greengrass y ejecute el siguiente comando:

hostname -I

En función del sistema operativo, elija una pestaña para transferir los dos archivos comprimidos desdeel equipo al dispositivo de núcleo de AWS Greengrass:

Note

Recuerde que el nombre de inicio de sesión y la contraseña predeterminados del RaspberryPi son pi y raspberry, respectivamente.

Windows

Para transferir los archivos comprimidos desde el equipo a un dispositivo de núcleo de AWSGreengrass Raspberry Pi, utilice una herramienta adecuada, como WinSCP o el comando dePuTTY pscp. Para utilizar el comando pscp, abra una ventana del símbolo de sistema en elequipo y ejecute lo siguiente:

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

Por ejemplo:

macOS

Para transferir los archivos comprimidos desde un equipo Mac a un dispositivo RaspberryPi de núcleo de AWS Greengrass, abra una ventana de terminal en el equipo y ejecute loscomandos siguientes (tenga en cuenta que ruta-hacia-archivos-descargados suele ser~/Downloads).

Note

Es posible que se le soliciten dos contraseñas. De ocurrir, la primera contraseña serápara el comando sudo de Mac y la segunda, para el 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

Sistema similar a UNIX

Para transferir los archivos comprimidos desde un equipo a un dispositivo Raspberry Pi denúcleo de AWS Greengrass, abra una ventana de terminal en el equipo y ejecute los comandossiguientes:

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

50

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



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

Navegador web de Raspberry Pi

Si descargó los archivos comprimidos a través del navegador web del Raspberry Pi, dichosarchivos seguramente estén en la carpeta ~/Downloads del dispositivo Pi (es decir, /home/pi/Downloads). Si no están allí, posiblemente estén en la carpeta ~ del dispositivo Pi (es decir, /home/pi).

Abra un terminal en el dispositivo de núcleo de AWS Greengrass y diríjase a la carpeta que contienelos archivos comprimidos (es decir, ruta-hacia-archivos-comprimidos).

cd path-to-compressed-files

A continuación, ejecute los siguientes comandos para descomprimir el archivo binario de núcleo deAWS Greengrass y los recursos de seguridad (certificados, etc.). file:

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

Entre otras cosas, el primer comando crea el directorio /greengrass en la carpeta raíz deldispositivo de núcleo de AWS Greengrass (mediante el argumento -C /). El segundo comandocopia los certificados en la carpeta /greengrass/certs y el archivo config.json en la carpeta /greengrass/config (mediante el argumento -C /greengrass). Para obtener más información,consulte Archivo de configuración de AWS Greengrass Core (p. 17).

2. Instale el certificado de CA raíz de Symantec VeriSign en su dispositivo. Este certificado permite quesu dispositivo se comunique con AWS IoT mediante el protocolo de mensajería MQTT a través deTLS. Asegúrese de que el dispositivo de núcleo de AWS Greengrass está conectado a Internet y, acontinuación, ejecute los comandos siguientes (tenga en cuenta que -O es la letra mayúscula 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

Ejecute el siguiente comando para confirmar que el archivo root.ca.pem no está vacío:

cat root.ca.pem

Si el archivo root.ca.pem está vacío, compruebe la URL de wget y vuelva a intentarlo.3. Use los siguientes comandos para iniciar AWS Greengrass.

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

Debería ver un resultado similar a este (fíjese en el número PID):

51


AWS Greengrass Guía para desarrolladoresMódulo 3 (primera parte): funciones

de Lambda en AWS Greengrass

Note

Para configurar su dispositivo de núcleo para iniciar AWS Greengrass en el arranquedel sistema, consulte, consulte the section called “Iniciar Greengrass en el arranque delsistema” (p. 29).

A continuación, ejecute el siguiente comando para confirmar que el software de núcleo de AWSGreengrass (demonio) funciona. Sustituya PID-number por su propio número PID:

ps aux | grep PID-number

Debería ver una ruta al daemon de AWS Greengrass en ejecución, como en /greengrass/ggc/packages/1.5.0/bin/daemon. Si tiene problemas para iniciar AWS Greengrass, consulte Soluciónde problemas de aplicaciones de AWS Greengrass (p. 204).

Módulo 3 (primera parte): funciones de Lambda enAWS Greengrass

Este módulo enseña a configurar una función de Lambda y a implementarla en el dispositivo de núcleode AWS Greengrass. Contiene información sobre mensajería MQTT, suscripciones, implementaciones enAWS Greengrass y configuraciones de funciones de Lambda.

En la primera parte de este módulo, aprenderá a implementar una función de Lambda en núcleo de AWSGreengrass que envía mensajes "Hello World" a la nube de AWS Greengrass. La segunda parte (p. 70)cubre las diferencias entre funciones de Lambda bajo demanda y de larga duración que se ejecutan ennúcleo de AWS Greengrass. Antes de comenzar, asegúrese de que ha completado el Módulo 1 (p. 31)y el Módulo 2 (p. 44) y tiene un dispositivo de núcleo de AWS Greengrass en funcionamiento. Tengaen cuenta que el Módulo 3 (primera parte) (p. 52) y el Módulo 3 (segunda parte) (p. 70) deben llevaraproximadamente 30 minutos cada uno.

Creación y empaquetado de una función de LambdaPara que una función de Lambda de Python se ejecute en un núcleo de AWS Greengrass, debeempaquetarse con carpetas específicas del SDK de AWS Greengrass Core. A continuación, hará losiguiente:

• Descargue el SDK de AWS Greengrass Core para Python en su equipo (no en el dispositivo de núcleode AWS Greengrass).

52

AWS Greengrass Guía para desarrolladoresCreación y empaquetado de una función de Lambda

• Descomprima el archivo del SDK descargado.• Obtenga la función de Lambda de Python (denominada greengrassHelloWorld.py), del SDK

descomprimido.• Cree un paquete de implementación de funciones Lambda llamadohello_world_python_lambda.zip que contenga greengrassHelloWorld.py y la carpetagreengrasssdk.

• Cargue el paquete hello_world_python_lambda.zip mediante la consola de Lambda.• Transfiera el paquete al dispositivo de núcleo de AWS Greengrass con la consola de AWS Greengrass.

1. En consola de AWS IoT, elija Software.

2. En SDKs (SDK), en AWS Greengrass Core SDK (SDK de AWS Greengrass Core), elija Configuredownload (Configurar descarga).

53


3. Elija Python 2.7 version 1.1.0 (Python 2.7 versión 1.1.0) y, a continuación, elija Download GreengrassCore SDK (Descargar SDK de Greengrass Core).

4. Descomprima el SDK descargado. Para obtener instrucciones, elija la pestaña que corresponde a susistema operativo.

Windows

Utilice una herramienta para descomprimir .tar.gz archivos en Windows, como 7-Zip, WinZiposimilares. Por ejemplo, la herramienta 7-Zip puede utilizarse para descomprimir greengrass-core-python-sdk-1.1.0.tar.gz de la siguiente manera:

1. Después de instalar 7-Zip, vaya al archivo greengrass-core-python-sdk-1.1.0.tar.gzcon el explorador de archivos de Windows (tecla del logo de Windows + E), haga clic con elbotón derecho en el archivo, elija 7-Zip y, a continuación, seleccione Open archive.

2. En la ventana de 7-Zip resultante, haga doble clic en greegrass-core-python-sdk-1.1.0.tar, aws_greengrass_core_sdk, examples y HelloWorld y, acontinuación, en greengrassHelloWorld.zip.

3. También puede utilizar la tecla Ctrl para seleccionar la carpeta greengrasssdk y el archivoLambda greengrassHelloWorld.py de Python. A continuación, seleccione Extract, elijauna ubicación para extraer los archivos y seleccione OK.

macOS

1. Use Finder para ir hasta el archivo greengrass-core-python-sdk-1.1.0.tar.gz y hagadoble clic en él. De este modo se crea la carpeta aws_greengrass_core_sdk.

2. Expanda primero la carpeta aws_greengrass_core_sdk; después, la carpeta examples y,finalmente, la carpeta HelloWorld.

54

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

http://www.winzip.com/


3. Haga doble clic en el archivo greengrassHelloWorld.zip. Esto crea la carpetagreengrassHelloWorld; amplíela.


1. Abra una ventana de terminal y vaya al directorio que contiene el archivo greengrass-core-python-sdk-1.1.0.tar.gz.

2. Ejecute el comando siguiente para descomprimir el archivo:

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

Esto crea el directorio aws_greengrass_core_sdk. A continuación, ejecute los comandossiguientes:

cd /aws_greengrass_core_sdk/examples/HelloWorldsudo unzip greengrassHelloWorld.zip

Usará la carpeta greengrasssdk y el código de la función Lambda greengrassHelloWorld.pyde Python en el siguiente paso.

Observe que, cada cinco segundos, la función de Lambda greengrassHelloWorld.py publica unode los dos mensajes posibles en el tema hello/world, tal y como se muestra en el código siguiente(para ahorrar espacio, se han eliminado todos los comentarios del código):

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. Para crear la función Lambda greengrassHelloWorld.py, debe empaquetar el archivogreengrassHelloWorld.py y la carpeta greengrasssdk en un archivo .zip comprimido. Estees el paquete de implementación de la función de Lambda. Para este tutorial, asigne al paquete elnombre hello_world_python_lambda.zip:

55


En sistemas de tipo UNIX (incluido el terminal de Mac), se puede hacer con el siguiente comando:

sudo zip -r hello_world_python_lambda.zip greengrasssdk greengrassHelloWorld.py

Note

En función de la distribución, es posible que tenga que instalar zip en primer lugar. Porejemplo, sudo apt-get install zip (este comando de instalación puede ser diferenteen su distribución).

Ya está listo para crear la función Lambda y cargar el paquete de implementación.6. Abra la consola de Lambda y elija Create function (Crear función).7. Elija Author from scratch.8. Denomine a la función Greengrass_HelloWorld y establezca los demás campos como se indica a

continuación:

• Runtime (Tiempo de ejecución): elija Python 2.7.• Role (Rol): elija Create new role from templates(s) (Crear nuevo rol a partir de las plantillas).• Role name: escriba un nombre único para el rol.

Tenga en cuenta que AWS Greengrass no usa este rol.

A continuación, elija Create function (Crear función).

56


9. Cargue su paquete de implementación de la función de Lambda, tal y como se indica a continuación:

a. En la pestaña Configuration (Configuración), en Function code (Código de función), configure loscampos siguientes:

• Code entry type (Tipo de entrada de código): elija Upload a .ZIP file (Cargar un archivo .ZIP).• Runtime (Tiempo de ejecución): elija Python 2.7.• Handler (Controlador): escriba greengrassHelloWorld.function_handler.

b. Elija Upload (Cargar) y, a continuación, elija hello_world_python_lambda.zip. El tamañodel archivo hello_world_python_lambda.zip puede variar.

57


c. Seleccione Save.

Tip

Para ver su código cargado, elija Edit code inline (Editar código insertado) en el menúCode entry type (Tipo de entrada de código).

10.Publish la función de Lambda tal y como se indica a continuación:

a. En el menú Actions, elija Publish new version:

b. En Version description, escriba First version y, a continuación, elija Publish:

11.Cree un alias para la versión de la función de Lambda, tal como se indica a continuación:

Note

Los grupos de Greengrass pueden hacer referencia a una función de Lambda por alias(recomendado) o por versión. Si se utiliza un alias, resulta más fácil administrar lasactualizaciones del código, ya que no es necesario modificar la tabla de suscripciones ni ladefinición de grupo cuando se actualiza el código de la función. En su lugar, solo tiene quehacer que el alias apunte a la nueva versión de la función.

a. En el menú Actions, seleccione Create alias.

58

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

AWS Greengrass Guía para desarrolladoresConfiguración de la función deLambda para AWS Greengrass

b. Denomine al alias GG_HelloWorld, establezca la versión en 1 (que corresponde con la versiónque acaba de publicar) y, a continuación, elija Create (Crear).

Note

AWS Greengrass no admite alias de Lambda para versiones de $LATEST.

Configuración de la función de Lambda para AWSGreengrassAhora está listo para configurar la función de Lambda para AWS Greengrass.

1. En consola de AWS IoT, en Greengrass, elija Groups (Grupos) y, a continuación, elija el grupo que hacreado en el módulo 2 (p. 44).

2. En la página de configuración de grupo, seleccione Lambdas.

59


3. Elija Add your first Lambda (Añadir su primera función de Lambda).

60


4. Elija Use existing Lambda.

5. Busque el nombre de la Lambda que ha creado en el paso anterior (Greengrass_HelloWorld, no elnombre del alias), selecciónelo y luego elija Next:

61


6. Para la versión, elija Alias: GG_HelloWorld y, a continuación, elija Finish. Debería ver la función deLambda Greengrass_HelloWorld en el grupo, con el alias GG_HelloWorld.

7. Elija los puntos suspensivos (…) de la función de Lambda y, después, seleccione Edit Configuration(Editar configuración):

8. En la página Group-specific Lambda configuration (Configuración Lambda específica del grupo),realice los cambios siguientes:

• Establezca Timeout (Tiempo de espera) en 25 segundos. Esta función de Lambda está inactivadurante 20 segundos antes de cada invocación.

• En Lambda lifecycle (Ciclo de vida de Lambda), seleccione Make this function long-lived andkeep it running indefinitely (Prolongar la vida útil de esta función y mantenerla en ejecuciónindefinidamente).

Una función de Lambda de larga duración se inicia automáticamente después de que se inicia AWSGreengrass, y se mantiene en ejecución en su propio contenedor (o entorno de pruebas). Estocontrasta con una función de Lambda bajo demanda, que se inicia cuando se la invoca y se detienecuando no quedan tareas que ejecutar. Para obtener más información, consulte the section called“Configuración del ciclo de vida” (p. 130).

Note

La función de Lambda de este tutorial acepta cargas de entrada JSON, pero las funcionesde también admiten cargas de entrada binarias. La compatibilidad con datos binarios resultaespecialmente útil a la hora de interactuar con los datos de los dispositivos, ya que las

62


capacidades de hardware restringidas de estos a menudo hacen que sea difícil o imposibleconstruir un tipo de datos JSON.

9. Elija Update (Actualizar) para guardar los cambios en la configuración de la función de Lambda.10. Una función de Lambda de AWS Greengrass puede suscribirse o publicar mensajes (utilizando el

protocolo MQTT):

• En y desde otros dispositivos (o sombras de dispositivo) en núcleo de AWS Greengrass. Lainformación sobre sombras de dispositivo se proporciona en el Módulo 5 (p. 95).

• En otras funciones de Lambda.• En la nube de AWS IoT.

grupo de AWS Greengrass controla cómo interactúan estos componentes mediante suscripciones quepermiten mayor seguridad y proporcionan interacciones predecibles.

Una suscripción se compone de un origen, un destino y un tema. El origen es el autor del mensaje.El destino es el destinatario del mensaje. El tema permite filtrar los datos que se envían desde elorigen hasta el destino. El origen o el destino pueden ser un dispositivo de AWS Greengrass, unafunción de Lambda, una sombra de dispositivo o la nube de AWS IoT. La suscripción está dirigida,ya que los mensajes fluyen en una dirección específica. Para que dispositivo de AWS Greengrassenvíe y reciba mensajes de una función de Lambda, debe configurar dos suscripciones: una desdeel dispositivo a la Lambda y otra desde la función de Lambda al dispositivo. La función de LambdaGreengrass_HelloWorld envía mensajes solo al tema hello/world en la nube de AWS IoT, tal ycomo se muestra en el siguiente fragmento de código de greengrassHelloWorld.py:

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

Dado que la función de Lambda Greengrass_HelloWorld solo envía mensajes al tema hello/world en la nube de AWS IoT, solo debe crearse una suscripción desde la función de Lambda a lanube de AWS IoT, tal y como se muestra a continuación.

11. En la página de configuración de grupo, elija Subscriptions (Suscripciones) y, a continuación, elija Addyour first Subscription (Añadir su primera suscripción).

63

http://mqtt.org/


12. En el campo Select a source, elija Select. A continuación, en la pestaña Lambdas, elijaGreengrass_HelloWorld como origen.

13. En el campo Select a target, elija Select. Luego, en la pestaña Service, elija IoT Cloud y, acontinuación, elija Next.

64

AWS Greengrass Guía para desarrolladoresImplementación de configuracionesde nube en un dispositivo del núcleo

14. En el campo Optional topic filter, escriba hello/world y luego elija Next.

15. Por último, seleccione Finish (Finalizar).

Implementación de configuraciones de nube en undispositivo del núcleo de AWS Greengrass1. Asegúrese de que el dispositivo núcleo de AWS Greengrass está conectado a Internet (por ejemplo,

compruebe si puede navegar a una página web).2. Asegúrese de que el demonio de AWS Greengrass se está ejecutando en su dispositivo del núcleo.

Ejecute los siguientes comandos en el terminal del dispositivo del núcleo.

a. Para comprobar si el demonio está en ejecución:

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

65

AWS Greengrass Guía para desarrolladoresImplementación de configuracionesde nube en un dispositivo del núcleo

Si la salida contiene una entrada root para /greengrass/ggc/packages/1.5.0/bin/daemon, el demonio está en ejecución.

b. Para comenzar el demonio:


Ahora ya está preparado para implementar la función de Lambda y las configuraciones desuscripciones en el dispositivo de núcleo de AWS Greengrass.

3. En la consola de AWS IoT, en la página de configuración de grupo, en el menú Actions (Acciones),elija Deploy (Implementar).

4. En la página Configure how devices discover your core, elija Automatic detection. Esto permite alos dispositivos adquirir automáticamente la información de conexión del dispositivo principal, comola dirección IP, el DNS y el número de puerto. Se recomienda la detección automática, pero AWSGreengrass también es compatible con puntos de enlace especificados manualmente. Solo se lesolicitará el método de detección la primera vez que se implemente el grupo.

5. Si se le solicita, elija Grant permission (Conceder permisos) en la página Grant permission to accessother services (Conceder permisos para obtener acceso a otros servicios). De este modo se crea el rolde servicio de Greengrass, que permite a AWS Greengrass obtener acceso a otros servicios de AWSen su nombre. Este rol es necesario para que las implementaciones se realicen correctamente. Soloes necesario hacerlo una vez para cada cuenta.

La primera implementación puede tardar unos minutos. Cuando termine la implementación, debería ver elmensaje Successfully completed (Realizado correctamente) en la columna Status (Estado) de la páginaDeployments (Implementaciones):

66

AWS Greengrass Guía para desarrolladoresVerificación de la ejecución de

función de Lambda en el dispositivo

Para obtener ayuda para solucionar cualquier problema que encuentre, consulte Solución de problemas deaplicaciones de AWS Greengrass (p. 204).

Verificación de la ejecución de función de Lambda enel dispositivoEn el panel izquierdo de consola de AWS IoT, elija Test.

67



En el campo Subscription topic (Tema de suscripción), escriba hello/world; no elija Subscribe to topic(Suscribirse a tema) aún. En Quality of Service, seleccione 0. En MQTT payload display, seleccioneDisplay payloads as strings (more accurate).

68



A continuación, elija Subscribe to topic.

Suponiendo que la función de Lambda se esté ejecutando en el dispositivo, publicará mensajes en el temahello/world similares al siguiente:

69

AWS Greengrass Guía para desarrolladoresMódulo 3 (segunda parte): funciones

de Lambda en AWS Greengrass

Note

Aunque la función de Lambda que se ejecuta en el dispositivo de núcleo de AWS Greengrasssigue enviando mensajes MQTT al tema hello/world en la nube de AWS IoT, no detenga eldemonio de AWS Greengrass, ya que los módulos restantes suponen que se está ejecutando.

Módulo 3 (segunda parte): funciones de Lambda enAWS Greengrass

Este módulo enseña a configurar una función de Lambda y a implementarla en el dispositivo de núcleode AWS Greengrass. Contiene información sobre mensajería MQTT, suscripciones, implementaciones enAWS Greengrass y configuraciones de funciones de Lambda.

En la primera parte (p. 52) de este módulo se explicó cómo implementar una función de Lambda ennúcleo de AWS Greengrass que envía mensajes "Hello World" a la nube de AWS Greengrass. En estaparte, se explican las diferencias entre funciones de Lambda bajo demanda y de larga duración que seejecutan en núcleo de AWS Greengrass. Antes de comenzar, asegúrese de haber completado el Módulo1 (p. 31), el Módulo 2 (p. 44) y el Módulo 3 (primera parte) (p. 52). Completar este módulo deberíallevarle aproximadamente 30 minutos.

Creación y empaquetado de la función de Lambda1. Descargue el código de función de Lambda en su equipo (no el dispositivo del núcleo de Greengrass),

tal y como se indica a continuación:

a. En un navegador web, abra el archivo greengrassHelloWorldCounter.py en GitHub.b. Elija Raw (Sin formato) para abrir la versión sin formato del archivo.

c. Utilice Ctrl + S (o Comando + S en el Mac) para guardar una copia del archivogreengrassHelloWorldCounter.py. Guarde el archivo en una carpeta que contenga lacarpeta greengrasssdk.

Note

Para los sistemas de tipo UNIX, puede ejecutar el siguiente comando de terminal paradescargar el archivo greengrassHelloWorldCounter.py:

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

2. Comprima el archivo greengrassHelloWorldCounter.py con el SDK en un archivo .zip,tal y como se describe en el Módulo 3 (primera parte) (p. 52). Asigne al paquete el nombrehello_world_counter_python_lambda.zip.

70

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

AWS Greengrass Guía para desarrolladoresCreación y empaquetado de la función de Lambda

3. En la consola de Lambda, cree una función de Python 2.7 denominadaGreengrass_HelloWorld_Counter, tal como se describe en el Módulo 3 (primeraparte) (p. 52). Puede usar el rol existente.



• Code entry type (Tipo de entrada de código): elija Upload a .ZIP file (Cargar un archivo .ZIP).• Runtime (Tiempo de ejecución): elija Python 2.7.• Handler (Controlador): escriba greengrassHelloWorldCounter.function_handler.

b. Elija Upload (Cargar) y, a continuación, elija hello_world_counter_python_lambda.zip.

c. En la parte superior de la página, elija Save.5. Publicar la primera versión de la función, tal y como se indica a continuación:

a. En el menú Actions, elija Publish new version. En Version description (Descripción de la versión),escriba Primera versión.

b. Elija Publish.6. Cree un alias para la versión de la función, tal y como se indica a continuación:

a. En el menú Actions (Acciones), elija Create alias (Crear alias) y configure los valores siguientes:

• Name (Nombre): escriba GG_HW_Counter.• Version (Versión): elija 1.

b. Seleccione Create.

71

AWS Greengrass Guía para desarrolladoresConfiguración de funciones de Lambda

de larga duración para AWS Greengrass

Recuerde que los alias crean una única entidad para su función de Lambda a la que puedensuscribirse los dispositivos de AWS Greengrass sin necesidad de tener que actualizar lassuscripciones con los números de versión de Lambda cada vez que se modifica la función.

Configuración de funciones de Lambda de largaduración para AWS GreengrassAhora está listo para configurar la función de Lambda para AWS Greengrass.

1. En consola de AWS IoT, en Greengrass, elija Groups (Grupos) y, a continuación, elija el grupo que hacreado en el Módulo 2 (p. 44).

2. En la página de configuración de grupo, elija Lambdas y, a continuación, elija Add Lambda (AñadirLambda).

3. En la página Add a Lambda to your Greengrass Group, elija Use existing Lambda.4. En la página Use existing Lambda (Usar función de Lambda existente), elija

Greengrass_HelloWorld_Counter y, a continuación, elija Next (Siguiente).

5. En la página Select a Lambda version (Seleccionar una versión Lambda), elija Alias: GG_HW_Countery, a continuación, elija Finish (Finalizar).

6. En la página Lambdas, en el menú Greengrass_HelloWorld_Counter, elija Edit Configuration (Editarconfiguración).

72

AWS Greengrass Guía para desarrolladoresConfiguración de funciones de Lambda

de larga duración para AWS Greengrass

7. En la página de configuración, edite las propiedades siguientes:

• Timeout (Tiempo de espera): configúrelo en 25 segundos. Esta función de Lambda está inactivadurante 20 segundos antes de cada invocación.

• Lambda lifecycle (Ciclo de vida de Lambda): elija Make this function long-lived and keep it runningindefinitely (Prolongar la vida útil de esta función y mantenerla en ejecución indefinidamente).

8. Elija Update.

73

AWS Greengrass Guía para desarrolladoresPrueba de funciones de Lambda de larga duración

Prueba de funciones de Lambda de larga duraciónSe iniciará automáticamente una función de Lambda de larga duración cuando se inicie núcleode AWS Greengrass y se ejecute en un único contenedor (o entorno de pruebas). Toda variableo procesamiento previo que se defina fuera del controlador de la función se conserva para cadainvocación del controlador de la función. Las diversas invocaciones del controlador de la función seponen en cola hasta que se hayan ejecutado las invocaciones anteriores. La función de LambdagreengrassHelloWorldCounter.py es similar a la función greengrassHelloWorld.py, salvoque haya una variable, my_counter, que se encuentre fuera del método function_handler(event,context) (los comentarios del código se han eliminado para ahorrar espacio):

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. En la página de configuración de grupo, elija Subscriptions (Suscripciones) y, a continuación, AddSubscription (Añadir suscripción). En Select a source, elija la pestaña Lambdas y, a continuación, elijaGreengrass_HelloWorld_Counter. A continuación, en Select a target (Seleccionar un destino), elija lapestaña Services (Servicios), elija IoT Cloud (Nube de IoT) y, a continuación, elija Next (Siguiente).

74


En Optional topic filter, escriba hello/world/counter. Elija Next y, a continuación, elija Finish.

Esta suscripción única solo va en una dirección: desde la función de LambdaGreengrass_HelloWorld_Counter a la nube de AWS IoT. Para activar esta función de Lambda desde lanube, deberá crear una suscripción en la dirección contraria.

2. Añada otra suscripción con IoT Cloud como origen y Greengrass_HelloWorld_Counter como destino.Use el tema hello/world/counter/trigger:

75


Tenga en cuenta la extensión /trigger de arriba. Ha creado dos suscripciones y no deben interferirentre sí.

3. Asegúrese de que el demonio de AWS Greengrass esté en ejecución, tal y como se describe enImplementación de configuraciones de nube en un dispositivo del núcleo (p. 65).

Tenga en cuenta que, con el demonio en ejecución, la función de LambdagreengrassHelloWorld.py anterior seguirá enviando mensajes al tema hello/world (en lanube de AWS IoT). Sin embargo, esto no interfiere en los mensajes que se envían desde la funciónde Lambda greengrassHelloWorldCounter.py a la nube de AWS IoT, ya que se dirigen a otrotema, es decir hello/world/counter.

4. En la página de configuración de grupo, en el menú Actions (Acciones), elija Deploy (Implementar)para implementar la configuración de grupo actualizada en su dispositivo de núcleo de AWSGreengrass.

Para obtener ayuda para solucionar cualquier problema que encuentre, consulte Solución deproblemas de aplicaciones de AWS Greengrass (p. 204).

5. Cuando termine la implementación, en consola de AWS IoT, elija Test. En Subscription topic, escribahello/world/counter. En Quality of Service, seleccione 0. En MQTT payload display, seleccioneDisplay payloads as strings y luego elija Subscribe to topic.

76


A diferencia de la primera parte (p. 52) de este módulo, no debería ver ningúnmensaje después de suscribirse a hello/world/counter. Esto se debe a que elcódigo greengrassHelloWorldCounter.py para publicar en el tema hello/world/counter se encuentra dentro de la función function_handler(event, context) yfunction_handler(event, context) solo se activa cuando recibe un mensaje de MQTT en eltema hello/world/counter/trigger. Para explicar esto en mayor profundidad, piense en lassuscripciones relacionadas con greengrass_HelloWorld_Counter:

En la segunda fila, vemos que la función de Lambda greengrass_HelloWorld_Counter puedeenviar mensajes a IoT Cloud en el tema hello/world/counter. En la tercera fila, vemos queIoT Cloud puede enviar mensajes a la función de Lambda greengrass_HelloWorld_Countercuando se envía este mensaje al tema hello/world/counter/trigger (tengaen cuenta que la palabra trigger no tiene nada en especial). La función de Lambdagreengrass_HelloWorld_Counter omite estos mensajes enviados y simplemente ejecutael código en function_handler(event, context), que envía un mensaje de vueltaal tema hello/mundo/counter en la nube de AWS IoT (consulte la lista de código degreengrassHelloWorldCounter.py anterior).

77


Por lo tanto, para activar el controlador function_handler(event, context), publique cualquiermensaje (el mensaje predeterminado está bien) en el tema hello/world/counter/trigger, tal ycomo se muestra a continuación.

Cada vez que se publica un mensaje en el tema hello/world/counter/trigger, la variablemy_counter se incrementa (consulte Invocation Count a continuación). Dado que elcontrolador de la función de Lambda incluye un ciclo de suspensión de 20 segundos (es decir,time.sleep(20)), activar repetidamente el controlador pondrá las respuestas en cola desde núcleode AWS Greengrass:

78

AWS Greengrass Guía para desarrolladoresPrueba de funciones de Lambda bajo demanda

Prueba de funciones de Lambda bajo demandaUna función de Lambda bajo demanda tiene una funcionalidad similar a una función de Lambda en lanube de AWS. Varias invocaciones de una función de Lambda bajo demanda pueden ejecutarse enparalelo. Una invocación de la función de Lambda crea un contenedor independiente para procesarinvocaciones o reutiliza un contenedor existente si los recursos lo permiten. No se conserva ningunavariable o procesamiento previo que se defina fuera del controlador de la función cuando se crean nuevoscontenedores. Para obtener más información, consulte the section called “Configuración del ciclo devida” (p. 130).

1. En la página de configuración de grupo, seleccione Lambdas. En la función de LambdaGreengrass_HelloWorld_Counter, elija Edit Configuration.

2. En Lambda lifecycle, seleccione On-demand function.

A continuación, elija Update.

79



4. Cuando termine la implementación, en consola de AWS IoT, elija Test. En Subscription topic, escribahello/world/counter. En Quality of Service, seleccione 0. En MQTT payload display, seleccioneDisplay payloads as strings y luego elija Subscribe to topic.

Nuevamente, no debería poder ver ningún mensaje después de suscribirse. Para activar la funciónen el tema hello/world/counter/trigger, envíe un mensaje (el mensaje predeterminado está bien) y,a continuación, elija Publish to topic tres veces, en un plazo de cinco segundos después de cadapulsación del botón.

80


Cada publicación activa el controlador de la función y crea un nuevo contenedor para cada invocación.El número de invocaciones no aumenta por cada una de las tres veces que se activa la función, yaque cada función de Lambda bajo demanda tiene su propio contenedor/entorno de pruebas.

Espere aproximadamente treinta segundos o más y, a continuación, elija Publish to topic. En estemomento, debería ver el número de invocaciones incrementado.

81

AWS Greengrass Guía para desarrolladoresMódulo 4: Interacción con dispositivos

en un grupo de AWS Greengrass

Esto muestra que se vuelve a usar un contenedor que se ha creado inicialmente a partir de unainvocación anterior y que se han almacenado las variables de procesamiento previo fuera delcontrolador de funciones.

Ahora debería entender los dos tipos de funciones de Lambda que se pueden ejecutar en núcleo deAWS Greengrass. El siguiente módulo, el Módulo 4 (p. 82), le muestra cómo pueden interactuar losdispositivos dentro de grupo de AWS Greengrass.

Módulo 4: Interacción con dispositivos en un grupode AWS Greengrass

En este módulo, se describe cómo los dispositivos AWS IoT pueden conectarse a un dispositivo de núcleode AWS Greengrass y comunicarse con él. Los dispositivos de AWS IoT que se conectan a un núcleo deAWS Greengrass forman parte de un grupo de AWS Greengrass y pueden participar en el paradigma deprogramación de AWS Greengrass. En este módulo, un dispositivo de AWS Greengrass envía un mensaje"Hello Word" a otro dispositivo de AWS Greengrass dentro del grupo de AWS Greengrass:

82

AWS Greengrass Guía para desarrolladoresCreación de dispositivos de AWS IoT


Antes de comenzar, asegúrese de que ha completado el Módulo 1 (p. 31), el Módulo 2 (p. 44),el Módulo 3 (primera parte) (p. 52)y el Módulo 3 (segunda parte) (p. 70). No necesita otroscomponentes ni dispositivos. Completar este módulo debería tomarle menos de 30 minutos.

Creación de dispositivos de AWS IoT en un grupo deAWS Greengrass1. En consola de AWS IoT, elija Greengrass, elija Groups y, a continuación, elija el grupo para abrir la

página de configuración. A continuación, elija Devices y luego seleccione Add your first Device.

83



Elija Create New Device:

Registre este dispositivo como HelloWorld_Publisher y, a continuación, elija Next:

84



En 1-Click, elija Use Defaults:

Cree una carpeta en su equipo.

Descargue los certificados para su dispositivo en la carpeta y, a continuación, descomprímalos (paradescomprimir archivos tar.gz en Windows, consulte la pestaña Windows en el paso 2 de Creación yempaquetado de una función de Lambda (p. 52)).

85



Anote el componente del nombre de archivo de tipo GUID común del dispositivo HelloWorld_Publisher(en este ejemplo, 51d2737e90), ya que se necesitará más tarde. Por último, seleccione Finish(Finalizar).

2. Al elegir Add Device, repita el paso 1 para añadir otro dispositivo al grupo y denomíneloHelloWorld_Subscriber. Descargue los certificados del segundo dispositivo también en suequipo y guárdelos en la misma carpeta que el primer conjunto de certificados. Elija Finalizar.De nuevo, anote el componente del nombre de archivo de tipo GUID común del dispositivoHelloWorld_Subscriber.

Debería tener dos dispositivos en su grupo de AWS Greengrass:

3. Descargue otro certificado raíz de AWS IoT de Symantec y guárdelo como root-ca-cert.pem enla carpeta que acaba de crear. Para este módulo, este certificado y los certificados y las claves deambos dispositivos deben estar en una carpeta de su equipo (no en el dispositivo de núcleo de AWSGreengrass).

86


AWS Greengrass Guía para desarrolladoresConfiguración de suscripciones

Note

Si está utilizando un navegador web en el equipo Mac y recibe una alerta This certificate isalready installed as a certificate authority (Este certificado ya está instalado como entidadde certificación), puede abrir una ventana de terminal y ejecutar los siguientes comandospara descargar el certificado en la carpeta que contiene los certificados y las claves de losdispositivos de HelloWorld_Publisher y 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

Ejecute cat root-ca-cert.pem para asegurarse de que el archivo no esté vacío. Deestarlo, compruebe la URL y pruebe el comando curl de nuevo.

Configuración de suscripcionesEn este paso, va a permitir que el dispositivo HelloWorld_Publisher envíe un mensaje HelloWorld aldispositivo HelloWorld_Subscriber.

1. En la página de configuración de grupo, elija Subscriptions (Suscripciones) y, a continuación, elija AddSubscription (Añadir suscripción). En Select a source, elija Select, Devices y HelloWorld_Publisher.Del mismo modo, en Select a target, elija HelloWorld_Subscriber. Por último, elija Next:

En Optional topic filter, escriba hello/world/pubsub:

87

AWS Greengrass Guía para desarrolladoresInstalar el AWS IoT Device SDK para Python

A continuación, elija Next seguido de Finish.

Note

Puede eliminar las suscripciones de los módulos anteriores. Para ello, elija Subscriptions(Suscripciones), elija los puntos suspensivos (...) asociados a una suscripción y, acontinuación, seleccione Delete (Eliminar).


3. En la página de configuración de grupo, en el menú Actions (Acciones), elija Deploy (Implementar)para implementar la configuración de grupo actualizada en su dispositivo de núcleo de AWSGreengrass:

Para confirmar que la implementación se ha realizado correctamente, elija Deployments(Implementaciones). Debería ver el mensaje Successfully completed (Realizado correctamente) casitan pronto como comience la implementación.


Instalar el AWS IoT Device SDK para PythonTodos los dispositivos AWS IoT pueden usar el AWS IoT Device SDK para Python para comunicarsecon la nube de AWS IoT y con dispositivos de núcleo de AWS Greengrass (mediante el lenguaje deprogramación Python). Tenga en cuenta que el SDK requiere Python 2, versión 2.7+ o Python 3, versión3.3+. Además, el SDK requiere OpenSSL, versión 1.0.1+ (TLS, versión 1.2) compilado con el ejecutable dePython.

Para instalar el SDK con todos los componentes necesarios en el equipo, elija la pestaña correspondiente:

Windows

1. Abra un símbolo del sistema elevado y ejecute el siguiente comando:

python --version

Si no devuelve información sobre la versión o si la versión es inferior a 2.7 para Python 2 o a 3.3para Python 3, siga las instrucciones de la página Downloading Python (Descargar Python) parainstalar Python 2.7+ o Python 3.3+. Para obtener más información, consulte Using Python onWindows (tenga en cuenta menú desplegable para seleccionar el número de versión de Python).

2. Desde un explorador web, descargue el archivo de AWS IoT Device SDK para Python zipy guárdelo como aws-iot-device-sdk-python-latest.zip (este debe ser el nombrepredeterminado). El archivo zip se suele guardar en la carpeta Downloads. Descomprima aws-

88

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


iot-device-sdk-python-latest.zip en una ubicación adecuada, como, por ejemplo, sudirectorio de inicio (es decir, cd %HOME%). Tenga en cuenta la ruta de la carpeta descomprimidaaws-iot-device-sdk-python-latest. En el siguiente paso, ruta-a-carpeta-SDKindicará esta ruta.

3. Ejecute el siguiente comando desde el símbolo del sistema elevado:

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

macOS

1. Abra una ventana de terminal y ejecute el siguiente comando:

python --version

Si no devuelve información sobre la versión o si la versión es inferior a 2.7 para Python 2 o a 3.3para Python 3, siga las instrucciones de la página Downloading Python para instalar Python 2.7+o Python 3.3+. Para obtener más información, consulte Using Python on a Macintosh (tenga encuenta menú desplegable para seleccionar el número de versión de Python).

2. En la ventana de terminal, ejecute los siguientes comandos para determinar la versión deOpenSSL:

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

Compruebe el valor de la versión de OpenSSL.

Note

Utilice print(ssl.OPENSSL_VERSION) si ejecuta Python 3.

Para cerrar manualmente el shell de Python, ejecute el siguiente comando:

>>> exit()

Si la versión de OpenSSL es 1.0.1 o posterior, vaya al paso 3. De lo contrario, siga los pasos acontinuación:

• En la ventana de terminal, ejecute el siguiente comando para determinar si el equipo estáutilizando Simple Python Version Management:

which pyenv

Si devuelve una ruta de archivo, elija la pestaña Con pyenv. Si no devuelve nada, elija la pestañaSin pyenv.

Con pyenv

1. Consulte Python Releases for Max OS X (o similar) para informarse acerca de la últimaversión de Python estable. A continuación, el marcador última-versión-de-Pythonindica dicho valor.

2. En una ventana de terminal, ejecute los siguientes comandos:

89


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

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


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

Por ejemplo, si la última versión de Python 2 es 2.7.14, estos comandos serían:

pyenv install 2.7.14pyenv global 2.7.14

3. Cierre la ventana de terminal y vuelva a abrirla.4. En la ventana de terminal que acaba de reabrir, ejecute los siguientes comandos:


La versión de OpenSSL debe ser al menos 1.0.1. Si la versión es inferior a 1.0.1 y laactualización ha fallado, compruebe el valor de la versión utilizado en los comandosanteriores pyenv install y pyenv global, y vuelva a intentarlo.

5. Ejecute el siguiente comando para cerrar el shell de Python:

>>> exit()

Sin pyenv

1. Desde una ventana de terminal, ejecute el siguiente comando para determinar si brew estáinstalado.

which brew

Si no devuelve una ruta, instale brew de la siguiente manera:

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

Note

Siga las instrucciones de instalación y tenga presente que la descarga de lasherramientas de línea de comandos Xcode puede tardar.

2. Ejecute los comandos siguientes:

brew updatebrew install opensslbrew install python@2

Recuerde que el AWS IoT Device SDK para Python requiere OpenSSL 1.0.1 (o posterior)compilado con el ejecutable de Python. El comando anterior brew install pythoninstala un ejecutable python2 que cumple este requisito. El ejecutable python2 se instalaen el directorio /usr/local/bin, que debe ser parte de la variable de entorno PATH.Para confirmarlo, ejecute el comando siguiente:

python2 --version

90

https://brew.sh/


Si se proporciona información de la versión de python2, vaya al siguiente paso. De locontrario, agregue la siguiente línea a su perfil de shell para añadir de forma permanente laruta /usr/local/bin a la variable de entorno PATH:

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

Por ejemplo, si está utilizando .bash_profile o aún no dispone de un perfil de shell,ejecute este comando desde una ventana de terminal:

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

A continuación, ejecute el comando source en el perfil de shell y compruebe si python2--version proporciona información de la versión. Por ejemplo, si está utilizando.bash_profile, ejecute los siguientes comandos.

source ~/.bash_profilepython2 --version

Debe devolver información de la versión de python2.3. Agregue la siguiente línea a su perfil de shell:

alias python="python2"

Por ejemplo, si está utilizando .bash_profile o aún no dispone de un perfil de shell,ejecute este comando:

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

4. A continuación, ejecute el comando source en el perfil de shell. Por ejemplo, si estáutilizando .bash_profile, ejecute el siguiente comando:

source ~/.bash_profile

Ahora, al invocar el comando python, se ejecutará el ejecutable de Python que contienela versión de OpenSSL necesaria (es decir, python2).

5. Ejecute los comandos siguientes:


La versión de OpenSSL debe ser 1.0.1 o posterior.6. Para cerrar el shell de Python, ejecute siguiente comando:

>>> exit()

3. Ejecute los siguientes comandos para instalar el AWS IoT Device SDK para Python:

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

91

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

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



1. En una ventana de terminal de , ejecute el siguiente comando:

python --version

Si no devuelve información sobre la versión o si la versión es inferior a 2.7 para Python 2 o a 3.3para Python 3, siga las instrucciones de la página Downloading Python para instalar Python 2.7+o Python 3.3+. Para obtener más información, consulte Using Python on Unix platforms (tenga encuenta menú desplegable para seleccionar el número de versión de Python)

2. En el terminal, ejecute los siguientes comandos para determinar la versión de OpenSSL:


Compruebe el valor de la versión de OpenSSL.

Para cerrar manualmente el shell de Python, ejecute el siguiente comando:

>>> exit()

Si la versión de OpenSSL es 1.0.1 o posterior, vaya al paso siguiente. De lo contrario, ejecute loscomandos necesarios para actualizar OpenSSL según su distribución. Por ejemplo: sudo yumupdate openssl, sudo apt-get update, etc.

Ejecute los siguientes comandos para determinar si la versión de OpenSSL es 1.0.1 o posterior:

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

3. Ejecute los siguientes comandos para instalar el AWS IoT Device SDK para Python:

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

Después de instalar el AWS IoT Device SDK para Python, vaya a la carpeta samples del SDK, la carpetagreengrass, y copie el archivo basicDiscovery.py a la carpeta que contiene los archivos de loscertificados de dispositivos de HelloWorld_Publisher y HelloWorld_Subscriber, tal y como se muestra en elsiguiente ejemplo (los componentes de nombre de archivo de tipo GUIDserán diferentes):

92


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

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

AWS Greengrass Guía para desarrolladoresPrueba de las comunicaciones

Prueba de las comunicaciones1. Asegúrese de que su equipo y el dispositivo de núcleo de AWS Greengrass están conectados a

Internet y utilizan la misma red. Use el siguiente procedimiento para confirmar lo anterior:

a. Determine la dirección IP del núcleo de AWS Greengrass ejecutando el siguiente comando:

hostname -I

b. Desde su equipo, ejecute el siguiente comando utilizando la dirección IP del dispositivo del núcleo(puede utilizar Ctrl + C para detener el comando ping):

ping IP-address

Si la salida es similar a la siguiente, eso indica que la comunicación entre el equipo y el dispositivode núcleo de AWS Greengrass es correcta (fíjese en el 0 % de pérdida de paquetes):

2. En consola de AWS IoT, elija Settings y fíjese en el valor de Endpoint:

93


Abajo, el valor del punto de enlace se indica mediante AWS_IOT_ENDPOINT.3. Elija Greengrass, Groups y luego elija su grupo. Elija Settings, seleccione Manually manage

connection information y luego elija View Cores for specific endpoint information. Elija el dispositivo delnúcleo y, a continuación, Connectivity. Elija Edit y asegúrese de que solo tiene un valor de Endpointque debe ser la dirección IP del dispositivo de núcleo de AWS Greengrass (para el puerto 8883). ElijaUpdate. Esto garantiza que el script basicDiscovery.py se conecte a la dirección IP del dispositivode núcleo de AWS Greengrass correcta.

4. Abra dos ventanas de la línea de comando en el equipo (no en el dispositivo de núcleo de AWSGreengrass). Una ventana de la línea de comando se usará para el dispositivo HelloWorld_Publishery la otra para el dispositivo HelloWorld_Subscriber. Cada vez que se ejecuta el siguiente script porprimera vez (basicDiscovery.py), el servicio de detección de AWS Greengrass establece laconexión con núcleo de AWS Greengrass. Cuando un dispositivo ha detectado el núcleo de AWSGreengrass y se ha conectado correctamente a él, la mensajería y las operaciones futuras puedenejecutarse de forma local (sin necesidad de conexión a Internet).

Note

Puede ejecutar el siguiente comando desde la carpeta que contiene el archivobasicDiscovery.py de la información de uso detallada del script:

python basicDiscovery.py --help

En la ventana del dispositivo HelloWorld_Publisher, ejecute los siguientes comandos:

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'

Debería ver un resultado similar a este:

94

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

AWS Greengrass Guía para desarrolladoresMódulo 5: Interacción con sombras de dispositivo

Note

Si recibe un mensaje acerca de argumentos no reconocidos, intente cambiar las comillassimples por comillas dobles en el parámetro message.

5. En la ventana del dispositivo HelloWorld_Subscriber, ejecute los siguientes comandos:

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

Debería ver los siguientes datos de salida:

Observe que al cerrar la ventana de HelloWorld_Publisher se detiene la acumulación de mensajesadicionales en la ventana HelloWorld_Subscriber.

Para obtener más información acerca del uso más reciente de basicDiscovery.py, consulte el archivoREADME de AWS IoT Device SDK para Python.

Módulo 5: Interacción con sombras de dispositivoEn este módulo avanzado, se muestra cómo pueden interactuar los dispositivos de AWS Greengrass consombras de dispositivos de AWS IoT en un grupo de AWS Greengrass. Una sombra es un documentoJSON que se usa para almacenar la información del estado actual o deseado de un objeto. En estemódulo, verá cómo un dispositivo de AWS Greengrass (GG_Switch) puede modificar el estado de otrodispositivo de AWS Greengrass (GG_TrafficLight) y cómo estos estados pueden sincronizarse con lanube de AWS Greengrass:

95

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

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

AWS Greengrass Guía para desarrolladoresConfiguración de dispositivos y suscripciones

Antes de comenzar, asegúrese de que ha completado el Módulo 1 (p. 31), el Módulo 2 (p. 44), elMódulo 3 (primera parte) (p. 52)y el Módulo 3 (segunda parte) (p. 70). También debería comprenderel procedimiento para conectar dispositivos a un núcleo de AWS Greengrass (Módulo 4 (p. 82)). Nonecesita otros componentes ni dispositivos. Completar este módulo debería tomarle aproximadamente30 minutos.

Configuración de dispositivos y suscripciones1. Cree dos dispositivos en su grupo de AWS Greengrass, GG_Switch y GG_TrafficLight. Utilice la

configuración de seguridad predeterminada.

96


Guarde los certificados de los dispositivos en su equipo. Anote el componente del nombre de archivode tipo GUID de GG_Switch y GG_TrafficLight, ya que se necesitarán más tarde. Puede volver autilizar el certificado de CA raíz de VeriSign anterior o descargar uno nuevo.

Ahora, cada sombra puede sincronizarse con el AWS IoT cuando núcleo de AWS Greengrassse conecte a Internet. En primer lugar, utilizará las sombras locales sin sincronizar las sombrasa la nube. Más adelante, en el módulo, habilitará la sincronización. De forma predeterminada, lasincronización con la nube debe estar deshabilitada. Si no está deshabilitado, en Devices, elija lospuntos suspensivos (...) y, a continuación, elija Local Shadow Only.

2. Elija Subscriptions y cree las siguientes suscripciones de su grupo. (Para obtener más informaciónacerca del signo $, consulte Temas reservados). Por ejemplo, para configurar la suscripción de laprimera fila, elija Add Subscription (Añadir suscripción), en Select a source (Seleccionar un origen)elija Select (Seleccionar), seleccione la pestaña Devices (Dispositivos) y luego elija GG_Switch. EnSelect a target, elija Select, luego Local Shadow Service y, a continuación, Next. En Optional topicfilter, escriba (o copie y pegue) $aws/things/GG_TrafficLight/shadow/update, elija Next yluego Finish. Con un procedimiento similar, complete las suscripciones restantes:

Fuente Objetivo Tema Notas

GG_Switch Servicio de sombralocal

$aws/things/GG_TrafficLight/shadow/update

GG_Switch envíauna solicitud deactualización al temade actualización.

Servicio de sombralocal

GG_Switch $aws/things/GG_TrafficLight/shadow/update/accepted

GG_Switch necesitasaber si se aceptó o serechazó la solicitud deactualización.


GG_Switch $aws/things/GG_TrafficLight/shadow/update/rejected


GG_TrafficLight Servicio de sombralocal


GG_TrafficLight envíauna actualización desu estado al tema deactualización.


GG_TrafficLight $aws/things/GG_TrafficLight/shadow/update/delta

El servicio desombra local envíauna actualizaciónde recepción a

97

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


Fuente Objetivo Tema NotasGG_TrafficLight através del tema delta.


GG_TrafficLight $aws/things/GG_TrafficLight/shadow/update/accepted

GG_TrafficLightnecesita sabersi se aceptó o serechazó la solicitudde actualización deGG_Switch.


GG_TrafficLight $aws/things/GG_TrafficLight/shadow/update/rejected


Note

Aunque puede utilizar comodines (por ejemplo, $aws/things/GG_TrafficLight/shadow/#) para consolidar algunas de las suscripciones, no le recomendamos que lo haga.

Las rutas de los temas se deben escribir exactamente tal y como se muestra en la tabla. No incluyauna / adicional al final de un tema. Puede pasar el ratón sobre una ruta de Topic para ver la rutacompleta en la información sobre herramientas emergente:

Note

Cada dispositivo tiene su propio servicio de sombra de dispositivo. Para obtener másinformación, consulte Temas MQTT de sombras.

98

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

AWS Greengrass Guía para desarrolladoresDescarga de los archivos necesarios




Descarga de los archivos necesarios1. Si aún no lo ha hecho, instale AWS IoT Device SDK para Python. Siga las instrucciones que se

detallan en el archivo README. Este SDK lo utilizan todos los dispositivos AWS IoT para comunicarsecon la nube de AWS IoT y con los núcleos de AWS Greengrass.

2. En el repositorio de muestras de AWS Greengrass en GitHub, descargue los archivoslightController.py y trafficLight.py en su equipo y muévalos a la carpeta que contiene loscertificados de los dispositivos GG_Switch y GG_TrafficLight:

El script lightController.py se corresponde con el dispositivo GG_Switch y el scripttrafficLight.py con el dispositivo GG_TrafficLight.

Prueba de las comunicaciones (sincronizaciones dedispositivos deshabilitadas)1. Abra dos ventanas de la línea de comando en el equipo (no en el dispositivo de núcleo de AWS

Greengrass). Una ventana de la línea de comando se usará para el dispositivo GG_Switch y la otrapara el dispositivo GG_TrafficLight. Cuando ambos scripts se ejecutan por primera vez, se ejecuta elservicio de detección de AWS Greengrass para conectarse a núcleo de AWS Greengrass (a través deInternet). Una vez que un dispositivo ha detectado un núcleo de AWS Greengrass y se ha conectado

99

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

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



(sincronizaciones de dispositivos deshabilitadas)

correctamente a él, las operaciones futuras pueden ejecutarse de forma local. Antes de ejecutar lossiguientes comandos, asegúrese de que su equipo y núcleo de AWS Greengrass están conectados aInternet y utilizan la misma red.

En la ventana de la línea de comandos de GG_Switch, ejecute lo siguiente:

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

En la ventana de la línea de comando de GG_TrafficLight, ejecute lo siguiente:

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

Para buscar el punto de enlace que se utilizará para el valor de marcador de posiciónAWS_IOT_ENDPOINT, abra la consola de AWS IoT y elija Settings (Configuración).

Cada 20 segundos, el interruptor actualiza el estado de sombra a los valores G, Y y R, y la luzmostrará su nuevo estado, tal que se muestra a continuación.

Salida de GG_Switch:

Salida de GG_TrafficLight:

2. En consola de AWS IoT, elija los dispositivos de grupo de AWS Greengrass, y, a continuación,GG_TrafficLight:

100


(sincronizaciones de dispositivos habilitadas)

Elija Shadow. En Shadow State, no debería aparecer ninguna actualización de este tema de sombradespués de que GG_Switch cambie de estado porque GG_TrafficLight está establecido en LOCALSHADOW ONLY, al contrario que SHADOW SYNCING TO CLOUD, tal y como se explica en lasiguiente sección.

3. Pulse Ctrl + C en la ventana de la línea de comando de GG_Switch (lightController.py) y fíjeseen que la ventana de GG_TrafficLight (trafficLight.py) deja de recibir mensajes de cambio deestado.

Prueba de las comunicaciones (sincronizaciones dedispositivos habilitadas)1. En consola de AWS IoT, elija el grupo de AWS Greengrass, seleccione Devices, elija los puntos

suspensivos del dispositivo GG_TrafficLight y luego elija Sync to the Cloud:

Debería recibir una notificación que indica que la sombra de dispositivo se ha actualizado.2. Desde la página Deployments (Implementaciones), implemente la configuración actualizada en su

dispositivo de núcleo de AWS Greengrass.3. Repita el paso en el que se crean dos ventanas de la línea de comando (p. 99).4. En consola de AWS IoT, elija los dispositivos de grupo de AWS Greengrass, , GG_TrafficLight y

Shadow.

101

AWS Greengrass Guía para desarrolladoresMódulo 6: Acceso a servicios en la nube de AWS

Dado que ha habilitado las sincronizaciones de la sombra GG_TrafficLight con AWS IoT, el estado desombra en la nube debería actualizarse automáticamente cuando GG_Switch envíe una actualización.Esta funcionalidad puede usarse para exponer el estado de un dispositivo de AWS Greengrass en lanube de AWS IoT.

Note

Si es necesario, solucione los problemas utilizando los registros de núcleo de AWSGreengrass, particularmente router.log:

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

Para obtener más información, consulte Solución de problemas de aplicaciones de AWSGreengrass (p. 204).

Módulo 6: Acceso a servicios en la nube de AWSEn este módulo avanzado, se muestra cómo los núcleos de AWS Greengrass pueden interactuar con otrosAmazon Web Services en la nube. Este módulo se basa en el ejemplo del semáforo proporcionado en elMódulo 5 (p. 95) y usa una función de Lambda adicional que procesa estados de sombra y carga unresumen en una tabla de Amazon DynamoDB.

102

AWS Greengrass Guía para desarrolladoresConfiguración de roles de IAM

Antes de comenzar, asegúrese de que ha completado los módulos 1 (p. 31) al 5 (p. 95). No necesitaotros componentes ni dispositivos. Completar este módulo debería tomarle aproximadamente 30 minutos.

Note

En este módulo, se crea y actualiza una tabla en DynamoDB. La mayoría de las operaciones sonpequeñas y se engloban en el capa gratuita de AWS. Consulte la documentación de precios deDynamoDB para obtener más información.

Configuración de roles de IAM1. Dado que estamos creando una función de Lambda que obtiene acceso a otros servicios de AWS,

tenemos que crear un rol de IAM que tenga acceso a DynamoDB y a AWS Greengrass. Paraobtener más información acerca de IAM, consulte la documentación de AWS Identity and AccessManagement.

En la consola de IAM, elija Roles y, a continuación, elija Create Role (Crear rol):

103

https://aws.amazon.com/dynamodb/pricing/

https://aws.amazon.com/dynamodb/pricing/

https://aws.amazon.com/documentation/iam/

https://aws.amazon.com/documentation/iam/


Seleccione AWS service (Servicio de AWS) y, luego, Greengrass:

104


Elija Next: Permissions.

En la página Attach permissions policies (Adjuntar políticas de permisos), seleccione lassiguientes políticas: AWSGreengrassResourceAccessRolePolicy, AWSGreengrassFullAccess yAmazonDynamoDBFullAccess.

A continuación, elija Next: Review. En Role name, escriba Greengrass_DynamoDB_Role y luegoelija Create role.

105


2. Repita el paso anterior para crear el rol para el servicio AWS Lambda (en lugar del servicio deAWS Greengrass). Dé las mismas políticas al rol (AWSGreengrassResourceAccessRolePolicy,AWSGreengrassFullAccess y AmazonDynamoDBFullAccess). En Role name, escribaLambda_DynamoDB_Role.

3. En consola de AWS IoT, en Greengrass, elija Groups (Grupo) y su grupo de AWS Greengrass. ElijaSettings (Configuración) y después Add Role (Añadir rol):

El rol de IAM que acaba de crear debería aparecer en la lista. Si no aparece, búsquelo, selecciónelo y,a continuación, elija Save:

106

AWS Greengrass Guía para desarrolladoresCreación y configuración de la función de Lambda

Creación y configuración de la función de LambdaEn este paso, va a crear una función de Lambda que realiza el seguimiento del número de automóvilesque pasan por el semáforo. Cada vez que el estado de sombra GG_TrafficLight cambie a G, la funciónde Lambda simula el paso de un número aleatorio de vehículos (de 1 a 20). Cada tercer cambio de luz aG, la función de Lambda envía estadísticas básicas, como los valores mínimo y máximo, a una tabla deDynamoDB.

1. En el equipo, cree una carpeta denominada car_aggregator.2. En el repositorio de GitHub, descargue la función de Lambda carAggregator.py a la carpeta

car_aggregator.3. Instale el paquete boto3 (SDK de AWS para Python) y sus dependencias en la carpeta

car_aggregator ejecutando el comando siguiente en una ventana de línea de comandos (enWindows, utilice un símbolo del sistema elevado):

pip install boto3 -t path-to-car_aggregator-folder

Aparece una lista de directorios similar a la siguiente:

107

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


Las funciones de Lambda de Greengrass utilizan el SDK de AWS para obtener acceso a otro AmazonWeb Services. Para obtener más información consulte Boto 3 - The AWS SDK for Python.

4. Comprima el contenido de la carpeta car_aggregator en un archivo .zip con el nombrecar_aggregator.zip. Este es el paquete de implementación de la función de Lambda.

5. En la consola de Lambda, cree una función denominada GG_Car_Aggregator y configure loscomponentes restantes del modo siguiente:

• Runtime (Tiempo de ejecución): elija Python 2.7.• Role (Rol): seleccione Choose an existing role (Elija un rol existente).• Existing role (Rol existente): elija Lambda_DynamoDB_Role.

A continuación, elija Create function (Crear función).

108

https://github.com/boto/boto3/blob/develop/README.rst




• Code entry type (Tipo de entrada de código): elija Upload a .ZIP file (Cargar un archivo .ZIP).• Runtime (Tiempo de ejecución): elija Python 2.7.• Handler (Controlador): escriba carAggregator.function_handler.

b. Elija Upload (Cargar) y, a continuación, elija car_aggregator.zip.c. Seleccione Save.

109


7. Publique la función de Lambda y, a continuación, cree un alias denominado GG_CarAggregator.Para obtener instrucciones paso a paso, consulte los pasos Publicar la función de Lambda (p. 58) yCrear un alias (p. 58) del Módulo 3 (primera parte).

8. En la consola de AWS IoT, añada la función de Lambda que acaba de crear a su grupo de AWSGreengrass, tal y como se indica a continuación:

a. En la página de configuración de grupo, elija Lambdas y, a continuación, elija Add Lambda(Añadir Lambda):

b. Elija Use existing Lambda:

c. Elija GG_Car_Aggregator y, a continuación, Next (Siguiente):

110


d. Elija Alias: GG_CarAggregator y, a continuación, Finish (Finalizar):

Note

Puede eliminar otras funciones de Lambda de módulos anteriores.9. Edite la configuración de la función de Lambda tal y como se indica a continuación:

a. Elija los puntos suspensivos (…) asociados a la función de Lambda y luego seleccione EditConfiguration:

b. En Lambda lifecycle (Ciclo de vida de Lambda), seleccione Make this function long-lived andkeep it running indefinitely (Prolongar la vida útil de esta función y mantenerla en ejecuciónindefinidamente) y, a continuación, elija Update (Actualizar):

111


Configuración de suscripcionesEn este paso, va a crear una suscripción que permite que la sombra GG_TrafficLight envíe estadosactualizados a la función de Lambda GG_Car_Aggregator. Esta suscripción se agrega a las suscripcionesque creó en el Módulo 5 (p. 95), que son necesarias para este módulo.

1. En la página de configuración de grupo, elija Subscriptions (Suscripciones) y, a continuación, elija AddSubscription (Añadir suscripción).

2. En la página Select your source and target (Seleccione el origen y el destino), configure los valoressiguientes:

• Select a source (Seleccionar un origen): elija Services (Servicios) y, a continuación, Local ShadowService (Servicio de sombra local).

• Select a target (Seleccionar un origen): elija Lambdas y, a continuación, GG_Car_Aggregator.

Seleccione Siguiente.

112


3. En la página Filter your data with a topic (Filtrar los datos con un tema), en Optional topic filter (Filtrode temas opcional), escriba $aws/things/GG_TrafficLight/shadow/update/documents.

Elija Next y, a continuación, elija Finish.

Note

En la página Subscriptions (Suscripciones), el destino muestra los nombres de la versión defunción y el alias: GG_Car_Aggregator:GG_CarAggregator.

En la siguiente tabla, se muestra la lista completa de las suscripciones que necesita este módulo.La nueva suscripción de sombra aparece en la última fila de la tabla. Creó otras suscripciones en elMódulo 5 (p. 95).

113


Fuente Objetivo Tema Notas

GG_Switch Servicio de sombralocal


GG_Switch envíauna solicitud deactualización al temade actualización.


GG_Switch $aws/things/GG_TrafficLight/shadow/update/accepted



GG_Switch $aws/things/GG_TrafficLight/shadow/update/rejected


GG_TrafficLight Servicio de sombralocal


GG_TrafficLight envíauna actualización desu estado al tema deactualización.


GG_TrafficLight $aws/things/GG_TrafficLight/shadow/update/delta

El servicio de sombraenvía una actualizaciónde recibido aGG_TrafficLight através del tema delta.


GG_TrafficLight $aws/things/GG_TrafficLight/shadow/update/accepted



GG_TrafficLight $aws/things/GG_TrafficLight/shadow/update/rejected



GG_Car_Aggregator $aws/things/GG_TrafficLight/shadow/update/documents

La sombraGG_TrafficLight envíaestados actualizados ala función de Lambda.

Note

Excepto para el Módulo 5 (p. 95), puede eliminar las suscripciones de los módulosanteriores que no estén incluidas en la tabla.


114




Prueba de las comunicaciones1. En su equipo, abra dos ventanas de la línea de comando. Al igual que en el Módulo 5 (p. 95), una

ventana se usará para el dispositivo GG_Switch y la otra para el dispositivo GG_TrafficLight.

Note

Son los mismos comandos que ejecutó en el Módulo 5.

Ejecute los siguientes comandos para el dispositivo 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

Ejecute los siguientes comandos para el dispositivo 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

Cada 20 segundos, el interruptor actualiza el estado de sombra a los valores G, Y y R, y la luz indicarásu nuevo estado.

2. Cada tercera luz verde (cada 3 minutos), se activará el controlador de funciones de Lambday se creará un nuevo registro de DynamoDB. Después de que lightController.py ytrafficLight.py se hayan ejecutado durante tres minutos, vaya a la Consola de administración deAWS, busque la consola de DynamoDB y ábrala. Asegúrese de que la región N. Virgina (us-east-1)está seleccionada y, a continuación, elija Tables y la tabla CarStats. A continuación, seleccione lapestaña Items:

Debería ver las entradas con estadísticas básicas con respecto a los vehículos que han pasado(una entrada cada 3 minutos). Es posible que necesite utilizar el botón de actualización (dos flechascirculares) para ver las actualizaciones de la tabla CarStats:

115



Note

Si es necesario, solucione los problemas utilizando los registros de núcleo de AWSGreengrass, particularmente router.log:

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

Para obtener más información, consulte Solución de problemas de aplicaciones de AWSGreengrass (p. 204).

Ha llegado al final de este tutorial. Ahora debería conocer el modelo de programación de AWS Greengrassy sus conceptos fundamentales, incluidos los núcleos de AWS Greengrass, los grupos, las suscripciones yel proceso de implementación de funciones Lambda que se ejecutan en el perímetro.

Puede eliminar la tabla de DynamoDB, eliminar las funciones de Lambda y detener las comunicacionesentre el dispositivo de núcleo de AWS Greengrass y la nube de AWS IoT. Para detener lascomunicaciones, abra un terminal en el dispositivo de núcleo de AWS Greengrass y ejecute uno de lossiguientes comandos:

• Para cerrar el dispositivo de núcleo de AWS Greengrass:

116


sudo halt

• Para detener el demonio de AWS Greengrass:

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

117


Actualizaciones de OTA del softwareAWS Greengrass Core

Esta característica está disponible para AWS Greengrass Core v1.3.0 y versiones posteriores.

El software núcleo de AWS Greengrass viene empaquetado con un agente de actualización OTAque es capaz de actualizar el software de Core o el agente de actualización OTA mismo al menos alas versiones correspondientes más recientes. Para iniciar una actualización, puede invocar la APICreateSoftwareUpdateJob o pude hacerlo desde la consola Greengrass. Actualizar el software deldispositivo Greengrass Core ofrece las siguientes ventajas:

• Corrige vulnerabilidades de seguridad.• Aborda problemas de estabilidad del software.• Implementa características nuevas o mejoradas.

Una actualización de OTA hace que todas estas ventajas estén disponibles sin tener que realizar laactualización manualmente o sin tener que tener físicamente presente el dispositivo que ejecuta elsoftware de Core. El agente de actualización OTA también realiza una restauración en caso de que fallela actualización OTA. Llevar a cabo una actualización OTA es opcional, pero puede ayudarlo a administrarlos dispositivos núcleo de AWS Greengrass. Busque anuncios de nuevas versiones del software de Coreen el foro para desarrolladores de Greengrass.

Para admitir una actualización OTA del dispositivo Greengrass Core mediante el agente de actualizaciónOTA, el dispositivo del núcleo de Greengrass debe:

• Tener disponible almacenamiento local que triplique el requisito de uso en tiempo de ejecución de Core.• No tener habilitado el arranque de confianza en la partición que contiene el software de la plataforma

de Greengrass Core. (El núcleo de AWS Greengrass se puede instalar y ejecutar en una partición conarranque de confianza habilitado, pero no puede realizarse una actualización OTA).

• Tener permisos de lectura y escritura en la partición que contiene el software de la plataforma deGreengrass Core.

• Tener una conexión a la nube de AWS.• Tener un núcleo de AWS Greengrass correctamente configurado y certificados adecuados.

Antes de lanzar una actualización OTA del software de Greengrass Core, es importante tener en cuenta elimpacto que tendrá en los dispositivos del grupo de Greengrass, tanto en el dispositivo del núcleo como enlos dispositivos cliente conectados a nivel local a ese dispositivo del núcleo:

• El dispositivo Core se apagará durante la actualización.• Las funciones de Lambda que se ejecutan en el dispositivo Core se apagarán. Si estas funciones

escriben en recursos locales, es posible que dejen esos recursos en un estado incorrecto, salvo que seapaguen correctamente.

• Durante el tiempo de inactividad del dispositivo del núcleo, se perderán todas sus conexiones con lanube, y se perderán los mensajes que dirijan los dispositivos cliente a través del dispositivo del núcleo.

• Se perderán las cachés de credenciales.• Se perderán las colas que mantienen trabajo pendiente para las funciones de Lambda.• Las funciones Lambda de larga duración perderán la información de estado dinámico y se abandonarán

todos los trabajos pendientes.

118

AWS Greengrass Guía para desarrolladoresAgente OTA de Greengrass

La siguiente información de estado se guardará durante una actualización OTA:

• Sombras locales• Registros de Greengrass• Registros de agentes de OTA

Agente OTA de GreengrassEl agente OTA de Greengrass es el componente de software en el dispositivo, que se encarga deactualizar los trabajos creados e implementados en la nube. El agente OTA de Greengrass se distribuyeen el mismo paquete de software que el software Greengrass Core. El agente se encuentra en ./greengrass/ota/ota_agent/ggc-ota y crea sus registros en /var/log/greengrass/ota/ggc_ota.txt.

Puede iniciar el agente OTA de Greengrass mediante la ejecución manual del binario o integrándolo comoparte de un script init, por ejemplo, un archivo servicio systemd. El binario debe ejecutarse como raíz.Una vez iniciado, el agente OTA de Greengrass comenzará a escuchar los trabajos de actualización deGreengrass desde la nube y a ejecutarlos de forma secuencial. El agente OTA de Greengrass ignorartodos los demás tipos de trabajo de IoT.

No inicie varias instancias del agente OTA, ya que esto puede provocar conflictos.

Si Greengrass Core o el agente OTA de Greengrass se administran en un sistema init, consulte IntegrationWith Init Systems (p. 121) para ver las configuraciones relacionadas.

API CreateSoftwareUpdateJob

La API CreateSoftwareUpdateJob crea una actualización de software para un dispositivo del núcleo o paravarios. Esta API se puede utilizar para actualizar el agente OTA, así como el software Greengrass Core.Aprovecha la característica Jobs de AWS IoT, que proporciona comandos adicionales para administrar untrabajo de actualización del software de Greengrass Core. Consulte Jobs para obtener más informaciónsobre cómo administrar una actualización de Greengrass.

El siguiente ejemplo muestra cómo crear un trabajo de actualización de software Greengrass Coremediante la CLI:

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

El comando create-software-update-job devuelve un objeto JSON que contiene el ID de trabajo y el ARNde trabajo:

{ "IotJobId": "Greengrass-OTA-c3bd7f36-ee80-4d42-8321-a1da0e5b1303", "IotJobArn": "arn:aws:iot:us-east-1:123456789012:job/Greengrass-OTA-c3bd7f36-ee80-4d42-8321-a1da0e5b1303"}

El comando create-software-update-job tiene los parámetros siguientes:

119

https://docs.aws.amazon.com/iot/latest/developerguide/iot-jobs.html

AWS Greengrass Guía para desarrolladoresAgente OTA de Greengrass

--update-targets-architecture

La arquitectura del dispositivo del núcleo. Debe ser uno de los siguientes: armv7l, x86_64 oaarch64.

--update-targets

Una lista de los destinos a los que debe aplicarse la actualización OTA. La lista puede contener losARN de cosas que son núcleos, y los ARN de grupos de cosas cuyos miembros son núcleos. ConsulteIoT thing groups para obtener más información sobre cómo colocar dispositivos del núcleo en ungrupo de cosas de IoT.

--update-targets-operating-system

El sistema operativo del dispositivo del núcleo. Debe ser uno de los siguientes: ubuntu,amazon_linux o raspbian.

--software-to-update

Especifica si el software del dispositivo del núcleo o el software del agente OTA deberían actualizarse.Debe ser uno de los siguientes: core o ota_agent.

--s3-url-signer-role

El rol de IAM que se utiliza para prefirmar la URL de S3 que se enlaza con la actualización de softwarede Greengrass. Debe proporcionar un rol que tenga adjunta la política adecuada. A continuación semuestra un documento de políticas de ejemplo con los permisos mínimos necesarios:

{ "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/*" ] } ]}

A continuación se muestra un documento de políticas Assume Role de ejemplo con las entidades deconfianza mínimas necesarias:

{ "Version": "2012-10-17", "Statement": [ { "Action": "sts:AssumeRole", "Principal": { "Service": "iot.amazonaws.com" }, "Effect": "Allow", "Sid": "AllowIotToAssumeRole" } ]}

120

https://docs.aws.amazon.com/iot/latest/developerguide/thing-groups.html

AWS Greengrass Guía para desarrolladoresIntegración con sistemas Init

--amzn-client-token

[Opcional] Un token de cliente utilizado para realizar solicitudes idempotentes. Proporcione un tokenexclusivo para evitar que se creen actualizaciones duplicadas debido a reintentos internos.

--update-agent-log-level

[Opcional] El nivel de registro para las declaraciones de registro generadas por el agente OTA. Debeser uno de los siguientes: NONE, TRACE, DEBUG, VERBOSE, INFO, WARN, ERROR o FATAL. El valorpredeterminado es ERROR.

A continuación se muestra una política IAM de ejemplo con los permisos mínimos necesarios para llamar ala 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

Dado que Greengrass solo es compatible con un subconjunto de las combinaciones posibles dearquitectura y sistema operativo con este comando, CreateSoftwareUpdateJob rechazará lassolicitudes, excepto para las siguientes plataformas compatibles:

• ubuntu/x86_64• ubuntu/aarch64• amazon_linux/x86_64• raspbian/armv7l

Integración con sistemas InitDurante una actualización OTA, los binarios, algunos de los cuales puede que estén en ejecución, seactualizarán y reiniciarán. Esto puede provocar conflictos si un sistema init supervisa el estado del softwarede núcleo de AWS Greengrass o del agente OTA de Greengrass durante la actualización. Para ayudarlo

121

AWS Greengrass Guía para desarrolladoresActualización OTA automática con managedRespawn

a integrar el mecanismo de actualización OTA con sus estrategias de supervisión, Greengrass ofrece laoportunidad de ejecutar scripts shell definidos por el usuario antes y después de una actualización. Paraindicar al agente OTA que ejecute estos scripts shell, debe incluir la marca managedRespawn = true enel archivo ./greengrass/config/config.json. Por ejemplo:

{

"coreThing": { … }, "runtime": { … }, "managedRespawn": true

}

Cuando la marca managedRespawn esté establecida, los scripts deben existir en el directorio o, en casocontrario, el agente OTA no podrá ejecutar la actualización. El árbol del directorio debería verse de lasiguiente manera:

<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

Actualización OTA automática con managedRespawnA medida que el agente OTA se prepara para realizar una actualización automática, si la marcamanagedRespawn esté establecida en true, el agente OTA buscará en el directorio ./greengrass/usr/scripts el script ota_pre_update.sh y lo ejecutará.

Después de que el agente OTA complete la actualización, intentará ejecutar el scriptota_post_update.sh desde el directorio ./greengrass/usr/scripts.

Actualización de AWS Greengrass Core conregeneración administradaA medida que el agente OTA se prepara para realizar una actualización de núcleo de AWS Greengrass,si la marca managedRespawn está establecida en true, el agente OTA busca en el directorio ./greengrass/usr/scripts el script ggc_pre_update.sh y lo ejecuta.

Después de que el agente OTA complete la actualización, intentará ejecutar el scriptggc_post_update.sh desde el directorio ./greengrass/usr/scripts.

Nota:

• Los scripts definidos por el usuario en ./greengrass/usr/scripts deben ser propiedad de raíz ydebe ser ejecutables por raíz únicamente.

122

AWS Greengrass Guía para desarrolladoresActualización automática del agente OTA

• Si managedRespawn está establecido en true, los scripts deben existir y devolver un código dedevolución correcto.

• Si managedRespawn está establecido en false, los scripts no se ejecutarán, incluso si se encuentranen el dispositivo.

• Es imprescindible que un dispositivo que sea el destino de una actualización no ejecute dos agentesOTA para la misma cosa de AWS IoT. Ello provocaría que dos agentes OTA procesaran los mismostrabajos, lo que dará lugar a conflictos.

Actualización automática del agente OTAPara realizar una actualización automática del agente OTA, siga estos pasos:

1. Asegúrese de que núcleo de AWS Greengrass esté aprovisionado correctamente con entradas válidasdel archivo config.json y los certificados necesarios.

2. Si un sistema init administra el agente OTA, asegúrese de que managedRespawn = true en elarchivo config.json y los scripts ota_pre_update.sh y ota_post_update.sh estén presentesen el directorio ./greengrass/usr/scripts.

3. Para iniciar el agente ggc-ota, ejecute ./greengrass/ota/ota_agent/ggc-ota.4. Cree un trabajo de actualización automática OTA en la nube con la API CreateSoftwareUpdateJob (aws

greengrass create-software-update-job) y asegúrese de que el parámetro --software-to-update esté establecido en ota_agent.

5. El agente OTA realizará una actualización automática.

Actualización del software Greengrass CorePara actualizar el software de núcleo de AWS Greengrass, siga estos pasos:

1. Asegúrese de que núcleo de AWS Greengrass esté aprovisionado correctamente con entradas válidasdel archivo config.json y los certificados necesarios.

2. Si un sistema init administra el software núcleo de AWS Greengrass, asegúrese de quemanagedRespawn = true en el archivo config.json y los scripts ggc_pre_update.sh yggc_post_update.sh estén presentes en el directorio ./greengrass/usr/scripts.

3. Para iniciar el agente ggc-ota, ejecute ./greengrass/ota/ota_agent/ggc-ota.4. Cree un trabajo de actualización automática OTA en la nube con la API CreateSoftwareUpdateJob (aws

greengrass create-software-update-job) y asegúrese de que el parámetro --software-to-update esté establecido en core.

5. El agente OTA realizará una actualización del software núcleo de AWS Greengrass.

123


Restablecimiento deimplementaciones


Es posible que desee restablecer la implementación de un grupo para:

• Eliminar el grupo (por ejemplo, cuando cambia la imagen del núcleo del grupo)• Mover el núcleo del grupo a otro grupo• Revertir el grupo al estado que tenía antes de la implementación• Eliminar la configuración de la implementación del dispositivo del núcleo• Eliminar datos confidenciales del dispositivo del núcleo o de la nube• Implementar una nueva configuración del grupo en un núcleo sin tener que reemplazar el núcleo por otro

del grupo actual

Note

La característica de restablecimiento de implementaciones no está disponible en el software AWSGreengrass Core v1.0.0. Además, tenga en cuenta que no es posible eliminar un grupo que se haimplementado mediante la versión v1.0.0.

El comando ResetDeployments borrará toda la información de la implementación que se almacena enla nube para un determinado grupo. A continuación, indicará al dispositivo del núcleo del grupo que borretoda la información relacionada con la implementación (funciones de Lambda, logs de usuario, base dedatos de sombras y certificado del servidor, pero no el archivo config.json definido por el usuario ni loscertificados del núcleo de Greengrass). No puede iniciar un restablecimiento de las implementaciones deun grupo si el grupo tiene una implementación con el estado Pending o Building.

aws greengrass reset-deployments --group-id <GroupId> [--force]

Argumentos del comando de la CLI reset-deployments:

--group-id

El ID del grupo.--force

[Opcional] Utilice este parámetro si el dispositivo del núcleo del grupo se ha perdido, robado odestruido. Esta opción hace que el proceso de restablecimiento de la implementación notifique seha realizado correctamente una vez que se ha borrado toda la información de implementación de lanube, sin tener que esperar a que responda el dispositivo del núcleo. Sin embargo, si el dispositivo delnúcleo está activo o se activa en algún momento, realizará también sus operaciones de limpieza.

El resultado del comando de la CLI reset-deployments tendrá este aspecto:

{ "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"

124


}

Puede comprobar el estado del restablecimiento de la implementación con el comando de la CLI get-deployment-status:

aws greengrass get-deployment-status --deployment-id DeploymentId --group-id GroupId

Argumentos del comando de la CLI get-deployment-status:

--deployment-id

El ID de implementación.--group-id

El ID del grupo.

El resultado del comando de la CLI get-deployment-status tendrá este aspecto:

{ "DeploymentStatus": "Success", "UpdatedAt": "2017-04-04T00:00:00.000Z"}

El estado de DeploymentStatus se establece en Building cuando se está preparando elrestablecimiento de la implementación. Cuando el restablecimiento de la implementación está lista, peronúcleo de AWS Greengrass aún no lo ha aplicado, el estado de DeploymentStatus es InProgress.

125


Ejecutar funciones de Lambda enAWS Greengrass Core

AWS Greengrass ofrece un entorno de tiempo de ejecución de Lambda en contenedores para códigodefinido por el usuario. Las funciones de Lambda que se implementa en un núcleo de AWS Greengrass seejecutan en el tiempo de ejecución de Lambda local del núcleo. Las funciones de Lambda locales puedenser activadas por eventos locales, mensajes de la nube y otros orígenes, lo que lleva la funcionalidad decomputación local a los dispositivos conectados. Por ejemplo, puede utilizar funciones de para filtrar losdatos del dispositivo antes de transmitir los datos a la nube.

Para implementar una función de Lambda en un núcleo, añada la función a un grupo de Greengrass(haciendo referencia a la función de Lambda existente), defina una configuración específica del grupo y,a continuación, implemente el grupo. Si la función accede a servicios de AWS, también debe añadir lospermisos necesarios para el rol del grupo.

SDK para funciones deAWS proporciona dos SDK que se utilizan en las funciones de .


Habilita funciones de Lambda locales para interactuar con servicios locales en el núcleo de AWSGreengrass. Este SDK es obligatorio en todas las funciones de . Las versiones de SDK estándisponibles para los lenguajes de programación y las plataformas más comunes.

En la siguiente tabla se muestra cada uno de los lenguajes o plataformas admitidos y las versiones delsoftware de núcleo de AWS Greengrass en las que se pueden ejecutar.

Lenguaje o plataforma Versión de GGC

Python 2.7

Java 8

Node.js 6.10

C, C++

• Descargue el SDK de AWS Greengrass Core para Python, Java o Node.js desde la página Softwarede consola de AWS IoT.

• Descargue el desde GitHub. Los ??? (p. 130) utilizan este SDK.SDK de AWS

Habilita funciones de Lambda locales para hacer llamadas directas a los servicios de AWS, comoAmazon S3, DynamoDB, AWS IoT y AWS Greengrass. Para utilizar el SDK de AWS en una funciónde , debe incluirlo en el paquete de implementación. Si se utiliza el SDK de AWS Greengrass Core y elSDK de AWS en el mismo paquete, asegúrese de que las funciones de Lambda usan los espacios denombres correctos. Las funciones de no pueden comunicarse con los servicios en la nube cuando elnúcleo está desconectado.

126

AWS Greengrass Guía para desarrolladoresMigración de funciones de Lambda basadas en la nube

• Descargue el SDK de AWS del Centro de recursos introductorios.

Para obtener más información acerca de la creación de un paquete de implementación, consulte thesection called “Creación y empaquetado de una función de Lambda” (p. 52) en el tutorial de introducción oCreación de un paquete de implementación en la AWS Lambda Developer Guide.

Migración de funciones de Lambda basadas en lanubeEl SDK de AWS Greengrass Core sigue el modelo de programación del SDK de AWS, lo que facilita eltraslado de las funciones de Lambda que se desarrollan para la nube a funciones de Lambda que seejecutan en un núcleo de AWS Greengrass.

Por ejemplo, la siguiente función de Lambda usa el SDK de AWS para Python para publicar un mensajesen el tema /some/topic en la nube:


Para trasladar la función para un núcleo de AWS Greengrass, en la declaración import y la inicializaciónclient, cambie el nombre del módulo boto3 a greengrasssdk, como se muestra en el siguienteejemplo:

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

Note


Esto permite probar las funciones de Lambda en la nube y migrarlas más adelante a AWS Greengrass conel mínimo esfuerzo. Los no se ejecutan en la nube, por lo que no puede utilizar el SDK de AWS para hacerpruebas en la nube antes de la implementación.

Referencia a funciones de Lambda por alias oversión

Los alias de Los grupos de Greengrass pueden hacer referencia a una función de Lambda por alias(recomendado) o por versión. Si se utiliza un alias, resulta más fácil administrar las actualizacionesdel código, ya que no es necesario modificar la tabla de suscripciones ni la definición de grupo cuandose actualiza el código de la función. En su lugar, solo tiene que hacer que el alias apunte a la nueva

127

https://aws.amazon.com/getting-started/tools-sdks/

https://docs.aws.amazon.com/lambda/latest/dg/deployment-package-v2.html

AWS Greengrass Guía para desarrolladoresConfiguración específica del grupo

versión de la función. se resuelven en números de versión durante la implementación del grupo. Cuandoutiliza alias, la versión resuelta se actualiza a la versión a la que apunta el alias en el momento de laimplementación.

Las versiones $LATEST de AWS Greengrass no admite alias de Lambda para versiones de $LATEST.no están vinculadas a versiones de función publicadas, inmutables y se pueden cambiar en cualquiermomento, lo cual va en contra del principio de inmutabilidad de AWS Greengrass.

Una práctica habitual para mantener las funciones de actualizadas con cambios en el código es utilizarun alias denominado PRODUCTION en su grupo y suscripciones de Greengrass. A medida que promuevenuevas versiones de su función de Lambda a producción, apunte el alias a la versión estable más recientey, a continuación, vuelva a implementar el grupo. También puede usar este método para revertir a unaversión anterior.

Configuración específica del grupo para funcionesde

AWS Greengrass permite la administración basada en la nube de funciones de . Aunque el código y lasdependencias de la función se administran por medio de AWS Lambda, AWS Greengrass admite lassiguientes opciones de configuración específicas del grupo:

Límite de memoria

Asignación de memoria para la función. El valor predeterminado es 16 MB.Tiempo de espera

La cantidad de tiempo antes de que se termine la función o solicitud. El valor predeterminado es de3 segundos.

Ciclo de vida

El ciclo de vida de una función de Lambda puede ser bajo demanda o de larga duración. El valorpredeterminado es bajo demanda.

Una función de Lambda bajo demanda se inicia en un contenedor nuevo o reutilizado cuando seinvoca. Las solicitudes a la función puede ser procesados por cualquier contenedor disponible. Unafunción de Lambda de larga duración (o anclada) se inicia automáticamente después de que se iniciaAWS Greengrass, y se mantiene en ejecución en su propio contenedor (o entorno de pruebas). Todaslas solicitudes a la función se procesan en el mismo contenedor. Para obtener más información,consulte the section called “Configuración del ciclo de vida” (p. 130).

Acceso de lectura al directorio /sys

Si la función puede obtener acceso o no a la carpeta /sys del host. Utilícelo cuando la función tengaque leer información del dispositivo desde /sys. El valor predeterminado es false.

Tipo de datos de carga de entrada

El tipo de codificación esperado de la carga de entrada de la función, JSON o binaria. Los??? (p. 130) solo admiten el tipo de codificación binaria (no JSON).

Note

Aceptar datos de entrada binarios puede ser útil para funciones que interactúan con datosde los dispositivos, ya que las limitadas capacidades de hardware de estos a menudo hacenque sea difícil o imposible construir un tipo de datos JSON. Se admite el tipo de codificaciónbinaria a partir del software de AWS Greengrass Core v1.5.0 y el SDK de AWS GreengrassCore v1.1.0.

128

AWS Greengrass Guía para desarrolladoresFlujos de comunicación

Variables de entorno

Pares clave-valor que pueden pasar ajustes de forma dinámica al código y bibliotecas de la función.Las variables de entorno local funcionan de la misma forma que las variables de entorno de lasfunciones de AWS Lambda, pero están disponibles en el entorno de núcleo.

Políticas de acceso a recursos

Una lista de hasta 10 recursos locales (p. 133) y recursos de aprendizaje automático (p. 158) alos que puede acceder la función de Lambda y los correspondientes permisos read-only o read-write. En la consola, estos recursos asociados se enumeran en la página Resources (Recursos) dela función.

Flujos de comunicación para las funciones deLas funciones de puede interactuar con otros miembros de grupo de AWS Greengrass, servicios locales yservicios en la nube (incluidos los servicios de AWS).

Mensajes MQTTLas funciones de pueden intercambiar mensajes MQTT con las siguientes entidades:

• Dispositivos en el grupo.• Funciones de Lambda en el grupo.• AWS IoT.• Servicio de sombra del dispositivo local.

Este flujo de comunicación utiliza un patrón de publicación-suscripción que se controla mediantesuscripciones. Una suscripción define el origen del mensaje, el destino del mensaje y el filtro deltema. Los mensajes que se publican en un destino de función de Lambda se transfieren al controladorregistrado de la función. Las suscripciones permiten más seguridad y proporcionan interaccionespredecibles. Para obtener más información, consulte the section called “Flujo de trabajo de mensajería deGreengrass” (p. 196).

Note

Las funciones de puede intercambiar mensajes con dispositivos, otras funciones y sombraslocales cuando el núcleo está desconectado, pero los mensajes para AWS IoT se ponen a la cola.Para obtener más información, consulte the section called “Cola de mensajes MQTT” (p. 26).

Otros flujos de comunicación• Para interactuar con los modelos de aprendizaje automático y recursos locales en un dispositivo de

núcleo, las funciones de utilizan las interfaces del sistema operativo específico de la plataforma. Porejemplo, puede utilizar el método open en el módulo os en funciones de Python 2.7. Para permitir queuna función acceda a un recurso, la función debe estar asociada con el recurso y tener el permisoread-only o read-write. Para obtener más información, incluida la disponibilidad de las versionesde núcleo de AWS Greengrass, consulte Obtener acceso a recursos locales con funciones deLambda (p. 133) y Cómo realizar la inferencia de aprendizaje automático (p. 158).

• Las funciones de pueden usar el SDK de AWS para comunicarse con los servicios de AWS. Paraobtener más información, consulte SDK de AWS (p. 126).

• Las funciones de pueden usar interfaces de terceros para comunicarse con servicios en la nubeexternos, de modo similar a las funciones de Lambda basadas en la nube.

129

https://docs.aws.amazon.com/lambda/latest/dg/env_variables.html

https://docs.aws.amazon.com/lambda/latest/dg/env_variables.html

https://docs.python.org/2/library/os.html

AWS Greengrass Guía para desarrolladoresConfiguración del ciclo de vida

Note

Las funciones de no pueden comunicarse con AWS u otros servicios en la nube cuando el núcleoestá desconectado.

Configuración del ciclo de vida de las funciones deEl ciclo de vida de la función de determina cuándo se inicia una función y cómo crea y utiliza contenedores.El ciclo de vida también determina cómo se conservan las variables y la lógica de procesamiento previoque está fuera del controlador de la función.

AWS Greengrass admite ciclos de vida bajo demanda (predeterminado) o de larga duración:

• Las funciones bajo demanda se inician cuando se invocan y se detienen cuando no quedan tareas queejecutar. Una invocación de la función crea un contenedor independiente (o entorno de pruebas) paraprocesar invocaciones, a menos que haya un contenedor disponible que se pueda reutilizar. Los datosque se envíe a la función pueden extraerse de cualquiera de los contenedores.

Es posible ejecutar en paralelo varias invocaciones de una función bajo demanda.

No se conserva ninguna variable ni lógica de procesamiento previo que se defina fuera del controladorde la función cuando se crean nuevos contenedores.

• Las funciones de larga duración (o adjuntas) se inician automáticamente cuando se inicia núcleo deAWS Greengrass y se ejecutan en un solo contenedor. Todos los datos que se envían a la función losextrae el mismo contenedor.

Hay varias invocaciones en la cola hasta que se ejecuten las invocaciones anteriores.

Las variables y lógica de procesamiento previo que se definen fuera del controlador de la función seconservan para cada invocación del controlador.

Las funciones de Lambda de larga duración resultan útiles cuando necesita empezar a trabajarsin ninguna entrada inicial. Por ejemplo, una función de larga duración puede cargar e iniciar elprocesamiento de un modelo de ML para que esté listo para cuando la función empiece a recibir losdatos del dispositivo.

Note

Recuerde que las funciones de larga duración tienen tiempos de espera que están asociadoscon invocaciones de su controlador. Si desea ejecutar de forma indefinida el código enejecución, debe iniciarlo fuera del controlador. Asegúrese de que no haya código de bloqueofuera del controlador que pudiera impedir la inicialización de la función.

Para obtener más información acerca de la reutilización de contenedores, consulte Entender la reutilizaciónde contenedores en AWS Lambda en el blog de informática de AWS.

Ejecutables LambdaUn es un tipo de función de que puede utilizar para ejecutar código binario en el entorno del núcleo. Lepermite ejecutar la funcionalidad específica del dispositivo de manera nativa y se beneficia de una menorhuella de código compilado. Los pueden ser invocados por eventos, pueden invocar otras funciones ypueden acceder a recursos locales.

130

https://aws.amazon.com/blogs/compute/container-reuse-in-lambda/

https://aws.amazon.com/blogs/compute/container-reuse-in-lambda/

AWS Greengrass Guía para desarrolladoresCrear un ejecutable Lambda

Los solo admiten el tipo de codificación binaria (no JSON) pero, por lo demás, puede administrarlos en sugrupo de Greengrass e implementarlos como otras funciones de . Sin embargo, el proceso de creación dees diferente de la creación de funciones de Lambda Python, Java y Node.js:

• No puede utilizar la consola de AWS Lambda para crear (o administrar) un . Solo puede crear unmediante la API de AWS Lambda.

• Puede cargar el código de la función a AWS Lambda como un ejecutable compilado que incluye elhttps://github.com/aws/aws-greengrass-core-sdk-c.

• Especificará el nombre del ejecutable como el controlador de la función.

Los deben implementar determinadas llamadas y patrones de programación en su código de la función.Por ejemplo, el método main debe:

• Llamar a gg_global_init para inicializar variables globales internas de Greengrass. Esta funcióndebe llamarse antes de crear subprocesos y antes de llamar a cualquier otra función de SDK de AWSGreengrass Core.

• Llamar a gg_runtime_start para registrar el controlador de la función con el tiempo de ejecución deLambda de Greengrass. Esta función debe llamarse durante la inicialización. Al llamar a esta función eltiempo de ejecución utiliza el subproceso actual. El parámetro GG_RT_OPT_ASYNC opcional indica a estafunción que no bloquee, sino que cree un nuevo subproceso para el tiempo de ejecución. Esta funciónutiliza un controlador SIGTERM.

El siguiente fragmento es el método main del ejemplo de código simple_handler.c en 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;}

Para obtener más información acerca de los requisitos exigidos, las restricciones y otros detalles deimplementación, consulte .

Crear un ejecutable LambdaDespués de compilar el código junto con el SDK, utilice la API de AWS Lambda para crear una función deLambda y cargar un ejecutable compilado.

Note

La función deberá elaborarse con un compilador C89 compatible.

En el siguiente ejemplo se utiliza el comando de CLI create-function para crear un . El comando especifica:

• El nombre del ejecutable para el controlador. Debe ser el nombre exacto del ejecutable compilado.• La ruta del archivo .zip que contiene el ejecutable compilado.• arn:aws:greengrass:::runtime/function/executable para el tiempo de ejecución. Este es el

tiempo de ejecución para todos los .

131

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

https://docs.aws.amazon.com/cli/latest/reference/lambda/create-function.html

AWS Greengrass Guía para desarrolladoresCrear un ejecutable Lambda

Note

Para role, puede especificar el ARN de cualquier rol de ejecución de Lambda. AWS Greengrassno utiliza este rol pero el parámetro es necesario para crear la función. Para obtener másinformación acerca de los roles de ejecución de Lambda, consulte Modelo de permisos de AWSLambda en la 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

A continuación, utilice la API de AWS Lambda para publicar una versión y crear un alias.

• Utilice publish-version para publicar una versión de la función.

aws lambda publish-version \--function-name function-name \--region aws-region

• Utilice create-alias para crear un alias que apunte a la versión que acaba de publicar. Recomendamosque el alias haga referencia a funciones de Lambda cuando las añade a un grupo de Greengrass.

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

Note

La consola de AWS Lambda no muestra los ejecutables Lambda. Para actualizar el código de lafunción, también debe utilizar la API de Lambda.

A continuación, añada el a un grupo de Greengrass, configúrelo para aceptar los datos de entrada binariosen su configuración específica del grupo e implemente el grupo. Puede hacerlo con la consola de AWSGreengrass o con la API de AWS Greengrass.

132

https://docs.aws.amazon.com/lambda/latest/dg/intro-permission-model.html

https://docs.aws.amazon.com/lambda/latest/dg/intro-permission-model.html

https://docs.aws.amazon.com/cli/latest/reference/lambda/publish-version.html

https://docs.aws.amazon.com/cli/latest/reference/lambda/create-alias.html

AWS Greengrass Guía para desarrolladoresTipos de recursos admitidos

Obtener acceso a recursos localescon funciones de Lambda


Los desarrolladores que utilizan AWS Greengrass pueden crear funciones de AWS Lambda en la nubee implementarlas en dispositivos del núcleo para una ejecución local. En los núcleos Greengrass que seejecuten con Linux, las funciones de Lambda implementadas de forma local pueden obtener acceso arecursos locales que estén físicamente presentes en el dispositivo del núcleo Greengrass. Por ejemplo,para comunicarse con dispositivos que estén conectados a través de Modbus o CANbus, puede habilitarla función de Lambda para obtener acceso al puerto serie del dispositivo del núcleo. Para configurarun acceso seguro a los recursos locales, debe garantizar la seguridad del hardware físico y el sistemaoperativo del dispositivo del núcleo de Greengrass.

Para empezar a obtener acceso a recursos locales, consulte los siguientes tutoriales:

• Cómo configurar el acceso a recursos locales mediante la interfaz de la línea de comando deAWS (p. 135)

• Cómo configurar el acceso a recursos locales mediante la Consola de administración de AWS (p. 140)

Tipos de recursos admitidosPuede obtener acceso a dos tipos de recursos locales: recursos de volumen y recursos de dispositivo.

Recursos de volumen

Archivos o directorios del sistema de archivos raíz (excepto de /sys, /dev o /var). Entre ellas seincluyen:• Carpetas o archivos que se utilizan para leer o escribir información en funciones de Lambda de

Greengrass (por ejemplo, /usr/lib/python2.x/site-packages/local).• Carpetas o archivos en el sistema de archivos /proc del host (por ejemplo, /proc/net o /proc/stat). Compatibles con v solo. Para informarse de los requisitos adicionales, consulte the sectioncalled “Recursos de volumen en el directorio /proc” (p. 134).

Tip

Para configurar los directorios /var, /var/run y /var/lib como recursos de volumen,primero monte el directorio en otra carpeta y, a continuación, configure la carpeta como unrecurso de volumen.

Recursos de dispositivo

Archivos en /dev. Solo tienen permiso para obtener acceso a los recursos de dispositivo losdispositivos de caracteres o los dispositivos de bloques en /dev. Entre ellas se incluyen:• Puertos de serie que se utilizan para comunicarse con dispositivos conectados a través de puertos

de serie (por ejemplo, /dev/ttyS0, /dev/ttyS1).

133


• USB utilizados para conectar periféricos USB (por ejemplo, /dev/ttyUSB0 o /dev/bus/usb).• GPIO que se utilizan para sensores y actuadores a través de GPIO (por ejemplo, /dev/gpiomem).• GPU que se utilizan para acelerar el aprendizaje automático mediante GPU a bordo (por ejemplo, /dev/nvidia0).

• Cámaras que se utilizan para capturar imágenes y vídeos (por ejemplo, /dev/video0).

Note

/dev/shm es una excepción. Se puede configurar solo como un recurso de volumen. Sedebe conceder permiso rw a los recursos de /dev/shm.

AWS Greengrass también admite tipos de recursos que se utilizan para llevar a cabo la inferencia deaprendizaje automático. Para obtener más información, consulte Cómo realizar la inferencia de aprendizajeautomático (p. 158).

RequisitosLos siguientes requisitos se aplican para configurar el acceso seguro a los recursos locales:

• Debe utilizar el software AWS Greengrass Core v1.3.0 or greater. Para crear recursos para el directorio /proc del host, debe utilizar v.

• Los recursos locales (incluidos los controladores y las bibliotecas necesarias) deben estar correctamenteinstalados en el dispositivo del núcleo de Greengrass y disponibles durante su uso.

• La operación deseada del recurso y el acceso al mismo no debe requerir privilegios raíz.• Solo están disponibles los permisos read o read and write. Las funciones de Lambda no pueden

realizar operaciones privilegiadas en los recursos.• Debe proporcionar la ruta completa del recurso local en el sistema operativo del dispositivo del núcleo de

Greengrass.• Un nombre o ID de recursos debe tener un máximo de 128 caracteres y utilizar el patrón [a-zA-Z0-9:_-]+.

Recursos de volumen en el directorio /procLas siguientes consideraciones se aplican a los recursos de volumen que se encuentran bajo el directorio /proc del host.

• Debe utilizar el software AWS Greengrass Core v.• Puede permitir acceso de solo lectura a las funciones de Lambda, pero no acceso de lectura y escritura.

AWS Greengrass administra este nivel de acceso.• Es posible que también necesite conceder permisos de grupo de SO para habilitar el acceso de lectura

en el sistema de archivos. Por ejemplo, suponga que su directorio o archivo de origen tiene un permisode archivo 660, lo que significa que solo el propietario o usuario del grupo tiene acceso de lectura (yescritura). En este caso, debe añadir permisos de propietario del grupo de SO al recurso. Para obtenermás información, consulte the section called “Permiso de acceso a los archivos del propietario delgrupo” (p. 135).

• Tanto el entorno de host como el espacio de nombres de Lambda contienen un directorio /proc, así queasegúrese de evitar conflictos de nomenclatura cuando especifique la ruta de destino. Por ejemplo, si /proc es la ruta de origen, puede especificar /host-proc como la ruta de destino (o cualquier nombre deruta que no sea "/proc").

134

AWS Greengrass Guía para desarrolladoresPermiso de acceso a los archivos del propietario del grupo

Permiso de acceso a los archivos del propietario delgrupo

Un proceso de la función de Lambda AWS Greengrass se suele ejecutar como ggc_user y ggc_group.Sin embargo, puede dar permisos de acceso a archivos adicionales al proceso de la función de Lambda enla definición de recursos locales, tal y como se indica a continuación:

• Para añadir los permisos del grupo de Linux que posee el recurso, utilice el parámetroGroupOwnerSetting#AutoAddGroupOwner o la opción de la consola Automatically add OS grouppermissions of the Linux group that owns the resource (Añadir automáticamente los permisos de grupode SO del grupo de Linux que posea el recurso).

• Para añadir los permisos de otro grupo de Linux, utilice el parámetroGroupOwnerSetting#GroupOwner o la opción de la consola Specify another OS group to addpermission (Especificar otro grupo de SO para añadir el permiso). El valor GroupOwner se omite siGroupOwnerSetting#AutoAddGroupOwner es true.

Un proceso de la función de Lambda de AWS Greengrass hereda todos los permisos del sistema dearchivos de ggc_user, ggc_group y el grupo de Linux (si se ha añadido). Para que esta función deLambda tenga acceso a un recurso, el proceso de función de Lambda debe tener los permisos necesariospara el recurso. Puede utilizar el comando chmod(1) para cambiar el permiso del recurso, si es necesario.

Véase también• Límites de Greengrass AWS en la Referencia general de AWS

Cómo configurar el acceso a recursos localesmediante la interfaz de la línea de comando deAWS


Para utilizar un recurso local, debe añadir una definición del recurso a la definición del grupo que se haimplementado en su dispositivo del núcleo de Greengrass. La definición del grupo también debe contenerla definición de una función de Lambda en la que se conceden permisos de acceso para recursos localesa las funciones de Lambda. Para obtener más información, incluidos los requisitos y las restricciones,consulte Obtener acceso a recursos locales con funciones de Lambda (p. 133).

En este tutorial, se describe el proceso para crear un recurso local y configurar el acceso a él mediante lainterfaz de la línea de comandos (CLI) de AWS. Para seguir los pasos del tutorial, debe haber creado ungrupo de Greengrass como se describe en Introducción a AWS Greengrass (p. 30).

Para ver un tutorial que utilice la Consola de administración de AWS, consulte Cómo configurar el acceso arecursos locales mediante la Consola de administración de AWS (p. 140).

Creación de recursos localesEn primer lugar, utilice el comando CreateResourceDefinition para crear una definición derecurso que especifique los recursos a los que se accederá. En este ejemplo, se crean dos recursos,TestDirectory y TestCamera:

135

https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html#limits_greengrass

https://docs.aws.amazon.com/greengrass/latest/apireference/createresourcedefinition-post.html

AWS Greengrass Guía para desarrolladoresCreación de recursos locales

aws greengrass create-resource-definition --cli-input-json '{ "Name": "MyLocalVolumeResource", "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": "" } } } } ] }}'

Recursos: una lista de objetos Resource del grupo de Greengrass. Un grupo de Greengrass puede tenerhasta 50 recursos.

Resource#Id: el identificador único del recurso. El ID se utiliza para consultar un recurso en laconfiguración de la función de Lambda. Longitud máxima 128 caracteres. Patrón: [a-zA-Z0-9:_-]+.

Nombre del recurso: el nombre del recurso. El nombre del recurso se muestra en la consola deGreengrass. Longitud máxima 128 caracteres. Patrón: [a-zA-Z0-9:_-]+.

LocalVolumeResourceData#SourcePath: la ruta local completa del recurso de volumen del dispositivo delnúcleo de Greengrass. La ruta de origen de un tipo de recurso de volumen no puede empezar con /sys.

LocalDeviceResourceData#SourcePath: la ruta local completa del dispositivo del recurso. La ruta de origende un recurso de dispositivo solo puede consultar un dispositivo de carácter o dispositivo de bloques bajo /dev.

LocalVolumeResourceData#DestinationPath: la ruta completa del recurso de volumen en el entornoLambda.

GroupOwnerSetting: le permite configurar privilegios de grupo adicionales para el proceso Lambda.Este campo es opcional. Para obtener más información, consulte Permiso de acceso a los archivos delpropietario del grupo (p. 135).

GroupOwnerSetting#AutoAddGroupOwner: si está marcado como "true", Greengrass añadeautomáticamente el propietario del grupo del sistema operativo Linux especificado, propietario del recurso

136

AWS Greengrass Guía para desarrolladoresCreación de la función de Greengrass

a los privilegios del proceso Lambda. El proceso Lambda tiene los permisos de acceso a los archivos delgrupo de Linux añadido.

GroupOwnerSetting#GroupOwner: especifica el nombre del grupo del sistema operativo Linux cuyosprivilegios se añaden al proceso Lambda. Este campo es opcional.

CreateResourceDefinition devuelve un ARN de la versión de la definición del recurso. El ARN debeutilizarse al actualizar la definición de un grupo. Por ejemplo:

{ "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"}

Creación de la función de GreengrassDespués de crear los recursos, utilice el comando CreateFunctionDefinition para crear la función deGreengrass y conceder a la función acceso al recurso:

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: contiene el resourceId y permission que concede el acceso a Lambda alrecurso. Una función de Lambda puede tener un máximo de 10 recursos.

137


https://docs.aws.amazon.com/greengrass/latest/apireference/createfunctiondefinition-post.html

AWS Greengrass Guía para desarrolladoresAdición de la función de Lambda al grupo

ResourceAccessPolicy#Permiso: especifica los permisos que tiene Lambda en el recurso. Las opcionesdisponibles son rw (lectura/escritura) o ro (solo lectura).

AccessSysfs: si es "true", el proceso Lambda puede tener acceso de lectura a la carpeta /sys deldispositivo del núcleo de Greengrass. Esto se utiliza en casos en los que el Lambda Greengrass debe leerinformación del dispositivo de /sys.

De nuevo, CreateFunctionDefinition devuelve un ARN de versión de la definición de la función. ElARN se debe utilizar en la versión de la definición del grupo.

{ "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"}

Adición de la función de Lambda al grupoPor último, utilice CreateGroupVersion para añadir la función al grupo. Por ejemplo:

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"

Se devuelve una nueva versión del grupo:

{ "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"}

Ahora el grupo de Greengrass contiene una función de Lambda lraTest que tiene acceso a dos recursos:TestDirectory y TestCamera.

Este ejemplo de función de Lambda lraTest.py, escrito en Python, escribe en el recurso del volumenlocal:

# lraTest.py# Demonstrates a simple use case of local resource access.

138

https://docs.aws.amazon.com/greengrass/latest/apireference/createfunctiondefinition-post.html

https://docs.aws.amazon.com/greengrass/latest/apireference/creategroupversion-post.html

AWS Greengrass Guía para desarrolladoresSolución de problemas

# 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

Estos comandos los proporciona la API de Greengrass para crear y gestionar definiciones del recurso yversiones de definiciones del recurso:

• CreateResourceDefinition• CreateResourceDefinitionVersion• DeleteResourceDefinition• GetResourceDefinition• GetResourceDefinitionVersion• ListResourceDefinitions• ListResourceDefinitionVersions• UpdateResourceDefinition

Solución de problemas• P: ¿Por qué la implementación de mi grupo de Greengrass falla con un error similar a:

group config is invalid: ggc_user or [ggc_group root tty] don't have ro permission on the file: /dev/tty0

R: Este error indica que el proceso Lambda no tiene permiso para acceder a los recursos especificados.La solución es cambiar el permiso a los archivos del recurso para que Lambda pueda acceder aél. (Consulte Permiso de acceso a los archivos del propietario del grupo (p. 135) para obtenerinformación).

• P: Cuando configuro /var/run como un recurso de volumen, ¿por qué la función de Lambda falla aliniciar con un mensaje de error en runtime.log?

[ERROR]-container_process.go:39,Runtime execution error: unable to start lambda container.

139


https://docs.aws.amazon.com/greengrass/latest/apireference/createresourcedefinitionversion-post.html

https://docs.aws.amazon.com/greengrass/latest/apireference/deleteresourcedefinition-delete.html

https://docs.aws.amazon.com/greengrass/latest/apireference/getresourcedefinition-get.html

https://docs.aws.amazon.com/greengrass/latest/apireference/getresourcedefinitionversion-get.html

https://docs.aws.amazon.com/greengrass/latest/apireference/listresourcedefinitions-get.html

https://docs.aws.amazon.com/greengrass/latest/apireference/listresourcedefinitionversions-get.html

https://docs.aws.amazon.com/greengrass/latest/apireference/updateresourcedefinition-put.html

AWS Greengrass Guía para desarrolladoresMediante la consola

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: Actualmente, núcleo de AWS Greengrass no es compatible con la configuración de /var, /var/runy /var/lib como recursos de volumen. Una alternativa es montar /var, /var/run o /var/lib enotra carpeta primero y, a continuación, configurar la carpeta como un recurso de volumen.

• P: Cuando configuro /dev/shm como un recurso de volumen con un permiso de solo lectura, ¿por quéla función de Lambda no se inicia y da un error en 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 \\\"/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 solo se puede configurar como de lectura o escritura. Cambie el permiso en el nivel derecursos a rw para resolver el problema.

Cómo configurar el acceso a recursos localesmediante la Consola de administración de AWS


Puede configurar funciones de Lambda para obtener acceso seguro a los recursos locales en el dispositivodel núcleo de Greengrass. Local resources hace referencia a buses y periféricos que se encuentranfísicamente en el mismo host o volúmenes del sistema de archivos del sistema operativo del host. Paraobtener más información, incluidos los requisitos y las restricciones, consulte Obtener acceso a recursoslocales con funciones de Lambda (p. 133).

Este tutorial describe cómo utilizar la Consola de administración de AWS para configurar el acceso alos recursos locales que se encuentran en un dispositivo de núcleo de AWS Greengrass. Contiene lossiguientes pasos de alto nivel:

1. Creación de un paquete de implementación de la función de Lambda (p. 141)2. Cree y publique una función de Lambda (p. 143)3. Adición de la función de Lambda al grupo (p. 147)4. Añadir un recurso local al grupo (p. 150)5. Añada suscripciones al grupo (p. 151)6. Implemente el grupo (p. 153)

Para ver un tutorial que utiliza la interfaz de línea de comandos (CLI) de AWS, consulte Cómo configurar elacceso a recursos locales mediante la interfaz de la línea de comando de AWS (p. 135).

Requisitos previosPara completar este tutorial, se necesita lo siguiente:

140

AWS Greengrass Guía para desarrolladoresCreación de un paquete de

implementación de la función de Lambda

• Un grupo de Greengrass y un núcleo de Greengrass (v1.3.0 or greater). Para obtener informaciónsobre cómo crear un grupo o dispositivo del núcleo de Greengrass, consulte Introducción a AWSGreengrass (p. 30).

• Los siguientes directorios se han creado en el dispositivo del núcleo de Greengrass:• /src/LRAtest• /dest/LRAtest

El grupo propietario de estos directorios debe tener acceso de lectura y escritura a los directorios. Porejemplo, puede utilizar el siguiente comando para conceder el acceso:

sudo chmod 0775 /src/LRAtest

Paso 1: Crear un paquete de implementación de lafunción de LambdaEn este paso, va a crear un paquete de implementación de la función de Lambda, que es un archivo ZIPque contiene el código de la función y dependencias. También puede descargar AWS Greengrass CoreSDK para que se incluya en el paquete como una dependencia.

1. En su equipo, copie el siguiente script de Python en un archivo local denominado lraTest.py.Contiene la lógica de la aplicación para la función de 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. Descargue el SDK de AWS Greengrass Core para Python 2.7 versión 1.1.0, como se indica acontinuación:

a. En el panel izquierdo de la consola de AWS IoT, elija Software.

141

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

AWS Greengrass Guía para desarrolladoresCreación de un paquete de

implementación de la función de Lambda

b. En SDKs (SDK), en AWS Greengrass Core SDK (SDK de AWS Greengrass Core), elija Configuredownload (Configurar descarga).

142

AWS Greengrass Guía para desarrolladoresCree y publique una función de Lambda

c. Elija Python 2.7 version 1.1.0 (Python 2.7 versión 1.1.0) y, a continuación, elija DownloadGreengrass Core SDK (Descargar SDK de Greengrass Core).

3. Descomprima el archivo greengrass-core-python-sdk-1.1.0.tar.gz.

Note

Para ver el modo de hacerlo en diferentes plataformas, consulte este paso (p. 52) en lasección Introducción. Por ejemplo, puede utilizar el siguiente comando tar:

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

4. Abra la carpeta aws_greengrass_core_sdk/sdk extraída y descomprima el archivopython_sdk_1_1_0.zip.

5. Comprima los siguientes elementos en un archivo denominado lraTestLambda.zip:

• lraTest.py. Lógica de la aplicación.• greengrasssdk. Biblioteca necesaria para todas las funciones de Lambda de Python.• Greengrass AWS SW License (IoT additiona) vr6.txt. Contrato de licencia del software Greengrass

Core necesario.

El archivo lraTestLambda.zip es el paquete de implementación de la función de Lambda. Ya estálisto para crear una función de Lambda y cargar el paquete de implementación.

Paso 2: Crear y publicar una función de LambdaEn este paso, va a utilizar la consola de AWS Lambda para crear una función de Lambda y va aconfigurarla para utilizar el paquete de implementación. A continuación, publicará una versión de la funcióny creará un alias.

Primero, cree una función de Lambda.

1. En la Consola de administración de AWS, elija Services (Servicios) y abra la consola de AWSLambda.

143


2. Elija Create function.3. Elija Author from scratch.4. En la sección Author from scratch, utilice los siguientes valores:

Propiedad Valor

Nombre TestLRA

Tiempo de ejecución Python 2.7

Rol Create new role from template(s)

Nombre de rol

(AWS Greengrass no utiliza este rol).

Greengrass_role_does_not_matter

5. En la parte inferior de la página, elija Create function.

144


Ahora, cargue el paquete de implementación de la función de Lambda y registre el controlador.

1. En la pestaña Configuration de la función TestLRA, en Function code, utilice los siguientes valores:

Propiedad Valor

Code entry type Upload a .ZIP file


Controlador lraTest.function_handler

2. Seleccione Upload.

145


3. Elija el paquete de implementación lraTestLambda.zip.4. En la parte superior de la página, elija Save.

Tip

Puede ver el código en la sección Function code (Código de función), eligiendo Edit codeinline (Editar código insertado) en el menú Code entry type (Tipo de entrada de código).

A continuación, publique la primera versión de la función de Lambda. A continuación, cree un alias para laversión.

Note

Los grupos de Greengrass pueden hacer referencia a una función de Lambda por alias(recomendado) o por versión. Si se utiliza un alias, resulta más fácil administrar lasactualizaciones del código, ya que no es necesario modificar la tabla de suscripciones ni ladefinición de grupo cuando se actualiza el código de la función. En su lugar, solo tiene que hacerque el alias apunte a la nueva versión de la función.

1. En el menú Actions, elija Publish new version.

2. En Version description, escriba First version y, a continuación, elija Publish.3. En la página de configuración de TestLRA: 1, en el menú Actions, elija Create alias.

4. En la página Create a new alias, utilice los valores siguientes:

146




Propiedad Valor

Nombre test

Version 1

Note

AWS Greengrass no admite alias de Lambda para versiones de $LATEST.5. Seleccione Create.

Ahora puede añadir la función de Lambda al grupo de Greengrass.

Paso 3: Añadir la función de Lambda al grupo deGreengrassEn este paso, va a añadir la función TestLRA al grupo y va a configurar el ciclo de vida de la función.

Primero, añada función de Lambda al grupo de Greengrass.

1. En la consola de AWS IoT, elija Greengrass y, a continuación, elija Groups (Grupos).

147


2. Elija el grupo de Greengrass en el que desea añadir la función de Lambda.3. En la página de configuración de grupo, elija Lambdas y, a continuación, elija Add Lambda (Añadir

Lambda).

4. En la página Add a Lambda to your Greengrass Group, elija Use existing Lambda.

148


5. En la página Use existing Lambda, elija TestLRA y, a continuación, elija Next.6. En la página Select a Lambda version, elija Alias:test y, a continuación, elija Finish.

A continuación, configure el ciclo de vida de la función de Lambda.

1. En la página Lambdas, elija la función de Lambda TestLRA.

2. En la página de configuración de TestLRA, elija Edit.3. En la página Group-specific Lambda configuration, utilice los siguientes valores:

Propiedad Valor

Tiempo de espera 30 segundos

Lambda lifecycle Make this function long-lived and keep it runningindefinitely

Para obtener más información, consulte the section called “Configuración del ciclo de vida” (p. 130).

4. En la parte inferior de la página, elija Update.

149

AWS Greengrass Guía para desarrolladoresAñadir un recurso local al grupo

Paso 4: Añadir un recurso local al grupo deGreengrassEn este paso, va a añadir un recurso de volumen local a un grupo de Greengrass y va a conceder a lafunción acceso de lectura y escritura al recurso. Un recurso local tiene un ámbito de nivel de grupo paraque sea accesible a todas las funciones de Lambda del grupo.

1. En la página de configuración del grupo, elija Resources (Recursos).

2. En la pestaña Local Resources (Recursos locales), elija Add local resource (Añadir recurso local).3. En la página Create a local resource, utilice los siguientes valores:

Propiedad Valor

Nombre del recurso testDirectory

Tipo de recurso Volumen

Ruta de origen

(Esta ruta debe existir en el sistema operativodel host).

/src/LRAtest

Destination path

(Esta ruta debe existir en el sistema operativodel host).

/dest/LRAtest

Group owner file access permission (Permiso deacceso a los archivos del propietario del grupo)

Automatically add OS group permissions ofthe Linux group that owns the resource (Añadirautomáticamente los permisos de grupo de SOdel grupo de Linux que posea el recurso)

El valor de Source path (Ruta de origen) es la ruta local completa del recurso en el sistema dearchivos del dispositivo del núcleo. Esta ruta no puede comenzar con /sys.

150

AWS Greengrass Guía para desarrolladoresAñada suscripciones al grupo

El valor de Destination path (Ruta de destino) es la ruta completa del recurso en el espacio denombres de Lambda.

La opción Group owner file access permission (Permiso de acceso a los archivos del propietariodel grupo) le permite conceder al proceso de Lambda permisos de acceso a archivos adicionales.Para obtener más información, consulte Permiso de acceso a los archivos del propietario delgrupo (p. 135).

4. En Lambda function affiliations (Afiliaciones de funciones de Lambda), elija Select (Seleccionar).5. Elija TestLRA, elija Read and write access (Acceso de lectura y escritura) y, a continuación, elija Done

(Listo).

6. En la parte inferior de la página, elija Save. La página Resources muestra el nuevo recursotestDirectory.

Paso 5: Añadir suscripciones al grupo de GreengrassEn este paso, va a añadir dos suscripciones al grupo de Greengrass. Estas suscripciones permiten lacomunicación bidireccional entre la función de Lambda e AWS IoT.

En primer lugar, cree una suscripción para que la función de Lambda envíe mensajes a AWS Greengrass.


151

AWS Greengrass Guía para desarrolladoresAñada suscripciones al grupo

2. En la página Select your source and target, configure el origen y el destino, de la siguiente manera:

a. En Select a source (Seleccionar un origen), elija Lambdas (Funciones de Lambda) y, acontinuación, elija TestLRA.

b. En Select a target (Seleccionar un destino), elija Services (Servicios) y, a continuación, elija IoTCloud.

c. Seleccione Siguiente.

3. En la página Filter your data with a topic (Filtrar los datos con un tema), en el campo Optional topicfilter (Filtro de temas opcional), escriba LRA/test y, a continuación, elija Next (Siguiente).

4. Elija Finalizar. La página Subscriptions muestra la nueva suscripción.

152

AWS Greengrass Guía para desarrolladoresImplemente el grupo

A continuación, configure una suscripción que invoque la función desde AWS IoT.

1. En la página Subscriptions, elija Add Subscription.2. En la página Select your source and target, configure el origen y el destino, de la siguiente manera:

a. En Select a source (Seleccionar un origen), elija Services (Servicios) y, a continuación, elija IoTCloud.

b. En Select a target (Seleccionar un destino), elija Lambdas (Funciones de Lambda) y, acontinuación, elija TestLRA.


3. En la página Filter your data with a topic (Filtrar los datos con un tema), en el campo Optionaltopic filter (Filtro de temas opcional), escriba invoke/LRAFunction y, a continuación, elija Next(Siguiente).

4. Elija Finalizar. La página Subscriptions muestra ambas suscripciones.

Paso 6: Implementar el grupo de AWS GreengrassEn este paso, va a implementar la versión actual de la definición del grupo.

1. Asegúrese de que el núcleo de AWS Greengrass se está ejecutando. Ejecute los siguientes comandosen el terminal de Raspberry Pi según sea necesario.

153





Note

La versión que figura en la ruta depende de la versión del software AWS GreengrassCore que esté instalada en el dispositivo del núcleo.



2. En la página de configuración de grupo, elija Deployments (Implementaciones) y, en el menú Actions(Acciones), elija Deploy (Implementar).

3. En la página Configure how devices discover your core, elija Automatic detection.

Esto permite a los dispositivos adquirir automáticamente la información de conexión del dispositivoprincipal, como la dirección IP, el DNS y el número de puerto. Se recomienda la detección automática,pero AWS Greengrass también es compatible con puntos de enlace especificados manualmente. Solose le solicitará el método de detección la primera vez que se implemente el grupo.

Note

Si se le solicita, conceda permiso para crear el rol de servicio de AWS Greengrass en sunombre, que le permite a AWS Greengrass tener acceso a otros servicios de AWS. Solo esnecesario hacerlo una vez para cada cuenta.

154

AWS Greengrass Guía para desarrolladoresPrueba de acceso al recurso local

En la página Deployments (Implementaciones), se muestra la marca temporal, el ID de versión yel estado de la implementación. Una vez terminada, la implementación debería mostrar el estadoSuccessfully completed.


Prueba de acceso al recurso localAhora puede verificar si el acceso al recurso local se ha configurado correctamente. Para probarlo,suscríbase al tema LRA/test y publique en el tema invoke/LRAFunction. La prueba se realizacorrectamente si la función de Lambda envía la carga esperada a AWS IoT.

1. En la página inicial de consola de AWS IoT, en el panel izquierdo, elija Test.

2. En la sección Subscriptions, utilice los siguientes valores:

Propiedad Valor

Subscription topic LRA/test

MQTT payload display Display payloads as strings

3. Elija Subscribe to topic. La función de Lambda realiza la publicación en el tema LRA/test.

155


4. En la sección Publish, escriba invoke/LRAFunction y, a continuación, elija Publish to topic parainvocar a la función de Lambda. La prueba se realiza correctamente si la página muestra las trescargas de mensajes de la función.

156


Puede ver el archivo de prueba que Lambda crea en el directorio Greengrass /src/LRAtest del dispositivodel núcleo de Greengrass. A pesar de que Lambda escribe en un archivo del directorio /dest/LRAtest,dicho archivo es visible solo en el espacio de nombres Lambda; no se puede ver en espacios de nombresde Linux normales. Sin embargo, cualquier cambio que se realice en la ruta de destino se refleja en ruta deorigen del sistema de archivos real.

Para obtener ayuda para solucionar cualquier problema que encuentre, consulte Solución de problemas deaplicaciones de AWS Greengrass (p. 204).

157

AWS Greengrass Guía para desarrolladoresFuncionamiento de la inferencia de

aprendizaje automático de AWS Greengrass

Cómo realizar la inferencia deaprendizaje automático

Esta característica solo está disponible para AWS Greengrass Core v1.5.0.

AWS Greengrass le permite realizar la inferencia de aprendizaje automático (ML) en el borde con datosgenerados localmente utilizando modelos entrenados en la nube. Esto le permite beneficiarse de la bajalatencia y el ahorro de costos que supone la ejecución de inferencias locales, aprovechando al mismotiempo la potencia de cómputo de la nube para el entrenamiento de modelos y el procesamiento complejo.

Para comenzar a realizar la inferencia local, consulte the section called “Cómo configurar la inferencia deaprendizaje automático” (p. 163).

Funcionamiento de la inferencia de aprendizajeautomático de AWS Greengrass

Puede entrenar sus modelos de inferencia en cualquier lugar, implementarlos localmente como recursosde aprendizaje automático en un grupo de Greengrass y, a continuación, obtener acceso a ellos desdefunciones de Lambda de Greengrass. Por ejemplo, puede crear y entrenar modelos de aprendizajeprofundo en Amazon SageMaker e implementarlos en el núcleo de Greengrass. A continuación, lasfunciones de Lambda pueden utilizar los modelos locales para realizar inferencias con los dispositivosconectados y enviar datos de entrenamiento nuevos de vuelta a la nube.

En el siguiente diagrama se muestra el flujo de trabajo de la inferencia de aprendizaje automático de AWSGreengrass.

La inferencia de aprendizaje automático de AWS Greengrass simplifica todos los pasos del flujo de trabajode aprendizaje automático, incluidos:

158

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

AWS Greengrass Guía para desarrolladoresRecursos de aprendizaje automático

• La creación e implementación de prototipos de marco de trabajo de aprendizaje automático.• El acceso a modelos entrenados en la nube y su implementación en dispositivos del núcleo de

Greengrass.• La creación de aplicaciones de inferencia que pueden obtener acceso a aceleradores de hardware

(como GPU y FPGA) como recursos locales (p. 133).

Recursos de aprendizaje automáticoLos recursos de aprendizaje automático representan modelos de inferencia entrenados en la nube que seimplementan en un núcleo de AWS Greengrass. Para implementar recursos de aprendizaje automático,primero debe añadirlos a un grupo de Greengrass y, a continuación, definir cómo podrán obtener accesoa ellos las funciones de Lambda de dicho grupo. Durante la implementación del grupo, AWS Greengrassrecupera los paquetes de modelos de origen de la nube y los extrae en directorios dentro del espacio denombres del tiempo de ejecución de Lambda. A continuación, las funciones de Lambda de Greengrassutilizan los modelos implementados localmente para llevar a cabo la inferencia.

Para actualizar un modelo implementado localmente, primero debe actualizar el modelo de origen (enla nube) correspondiente al recurso de aprendizaje automático y, a continuación, implementar el grupo.Durante la implementación, AWS Greengrass comprueba si existen cambios en el origen. Si se detectancambios, AWS Greengrass actualiza el modelo local.

Orígenes de modelos admitidosAWS Greengrass admite orígenes de modelos de Amazon SageMaker y Amazon S3 para los recursos deaprendizaje automático.

Los siguientes requisitos se aplican a los orígenes de modelos:

• Los buckets de S3 que almacenan los orígenes de modelos de Amazon SageMaker y Amazon S3no deben estar cifrados mediante SSE-C. En los buckets que utilizan cifrado del lado del servidor, lainferencia de aprendizaje automático de AWS Greengrass solo admite actualmente opciones de cifradoSSE-S3 o SSE-KMS. Para obtener más información sobre las opciones de cifrado del lado del servidor,consulte Protección de datos con el cifrado del lado del servidor en la Guía para desarrolladores deAmazon Simple Storage Service.

• Los nombres de los buckets de S3 que almacenan los orígenes de modelos de Amazon SageMaker yAmazon S3 no deben incluir puntos ("."). Para obtener más información, consulte la regla sobre el usode buckets de estilo alojado virtuales con SSL en Reglas para la nomenclatura de buckets en la Guíapara desarrolladores de Amazon Simple Storage Service.

• La compatibilidad de regiones de nivel de servicio debe estar disponible, como se indica a continuación:• Los orígenes de modelos de Amazon SageMaker se admiten únicamente en las regiones compatibles

con AWS Greengrass y compatibles con Amazon SageMaker.• Los orígenes de modelos Amazon S3 se admiten únicamente en las regiones compatibles con AWS

Greengrass y compatibles con Amazon S3.• AWS Greengrass debe tener permisos read en el origen de modelos, como se describe en las

secciones siguientes.

Amazon SageMaker

AWS Greengrass es compatible con los modelos que se guardan como trabajos de entrenamiento deAmazon SageMaker.

Si ha configurado el entorno de Amazon SageMaker creando un bucket cuyo nombrecontiene sagemaker, AWS Greengrass tiene permisos suficientes para obtener acceso

159

https://docs.aws.amazon.com/AmazonS3/latest/dev/serv-side-encryption.html

https://docs.aws.amazon.com/AmazonS3/latest/dev/BucketRestrictions.html#bucketnamingrules



https://docs.aws.amazon.com/general/latest/gr/rande.html#sagemaker_region



https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region

https://docs.aws.amazon.com/sagemaker/latest/dg/gs-config-permissions.html

AWS Greengrass Guía para desarrolladoresOrígenes de modelos admitidos

a los trabajos de entrenamiento de Amazon SageMaker. La política administradaAWSGreengrassResourceAccessRolePolicy permite obtener acceso a los buckets cuyo nombrecontenga la cadena sagemaker. Esta política está asociada al rol de servicio de Greengrass.

En caso contrario, debe conceder a AWS Greengrass permisos read en el bucket en el que sealmacena el trabajo de entrenamiento. Para ello, incruste la siguiente política insertada en el rol deservicio de Greengrass. Puede incluir varios ARN de bucket.

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "s3:GetObject" ], "Resource": [ "arn:aws:s3:::my-bucket-name" ] } ]}

Note

Amazon SageMaker es un servicio de aprendizaje automático totalmente administradoque le permite crear y entrenar modelos mediante algoritmos integrados o personalizados.Para obtener más información, consulte ¿Qué es Amazon SageMaker? en la Guía paradesarrolladores de Amazon SageMaker.

Amazon S3

AWS Greengrass es compatible con modelos que se almacenan en Amazon S3 como archivostar.gz o .zip.

Si desea que AWS Greengrass pueda obtener acceso a los modelos que se almacenan en buckets deAmazon S3, debe concederle permisos read; para ello, realice una de las acciones siguientes:• Almacene el modelo en un bucket cuyo nombre contenga greengrass.

La política administrada AWSGreengrassResourceAccessRolePolicy permite obtener acceso alos buckets cuyo nombre contenga la cadena greengrass. Esta política está asociada al rol deservicio de Greengrass.

• Incruste una política insertada en el rol de servicio de Greengrass.

Si el nombre del bucket no contiene greengrass, añada la siguiente política insertada al rol deservicio. Puede incluir varios ARN de bucket.

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "s3:GetObject" ], "Resource": [ "arn:aws:s3:::my-bucket-name" ] }

160

https://docs.aws.amazon.com/sagemaker/latest/dg/whatis.html


]}

Para obtener más información, consulte el tema relacionado con la integración de políticasinsertadas en la Guía del usuario de IAM.

RequisitosLos siguientes requisitos se aplican para crear y utilizar recursos de aprendizaje automático:

• Debe utilizar el software AWS Greengrass Core v1.5.0.• El acceso al directorio de destino local donde se almacena el recurso no debe requerir privilegios raíz.• Las funciones de Lambda no pueden realizar operaciones privilegiadas en el recurso. Solo están

disponibles los permisos read o read and write.• Debe proporcionar la ruta completa del recurso en el sistema operativo del dispositivo del núcleo.• Un nombre o ID de recursos debe tener un máximo de 128 caracteres y utilizar el patrón [a-zA-Z0-9:_-]+.

Bibliotecas precompiladas para marcos de trabajode ML

Para ayudarle a empezar rápidamente a experimentar con la inferencia de aprendizaje automático, AWSGreengrass facilita bibliotecas precompiladas para los siguientes marcos de trabajo de aprendizajeautomático con la licencia de Apache 2.0:

• Apache MXNet (licencia de Apache 2.0)• TensorFlow (licencia de Apache 2.0)• Chainer (licencia MIT)

Las bibliotecas precompiladas de MXNet y TensorFlow se pueden instalar en plataformas NVIDIA JetsonTX2, Intel Atom y Raspberry Pi. La bibliotecas están disponibles en la página Software de la consola deAWS IoT. Puede instalarlas directamente en el núcleo o incluirlas como parte del software en el grupo deGreengrass.

Asegúrese de leer la siguiente información sobre la compatibilidad y las limitaciones.

Control de versiones de MXNetApache MXNet no garantiza actualmente la compatibilidad con versiones posteriores, por lo que esposible que los modelos que entrene utilizando versiones posteriores del marco de trabajo no funcionencorrectamente en versiones anteriores de dicho marco de trabajo. Para evitar conflictos entre elentrenamiento de modelos y las etapas de distribución de modelos, así como para proporcionar unaexperiencia integral uniforme, utilice la misma versión del marco de trabajo MXNet en ambas etapas.

Note

Recomendamos utilizar MXNet v0.11 para la inferencia de ML de AWS Greengrass. Si deseaconfigurar Amazon SageMaker para entrenar modelos con la versión recomendada, consulteCómo configurar Amazon SageMaker para usar MXNet v0.11 (p. 162).

161

https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html#embed-inline-policy-console

https://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 Guía para desarrolladoresLimitaciones de la distribución de

modelos de TensorFlow en Raspberry Pi

Limitaciones de la distribución de modelos deTensorFlow en Raspberry PiTensorFlow solo admite oficialmente la instalación en sistemas operativos de escritorio o de portátil de64 bits. Por lo tanto, las bibliotecas precompiladas de TensorFlow que AWS Greengrass proporcionapara plataformas ARM de 32 bits (como Raspberry Pi) tienen limitaciones inherentes y se han diseñadoexclusivamente para fines experimentales.

Las siguientes recomendaciones para mejorar los resultados de la inferencia se basan en nuestraspruebas con las bibliotecas precompiladas de ARM de 32 bits en la plataforma Raspberry Pi. Estasrecomendaciones van dirigidas a usuarios avanzados únicamente a modo de referencia, sin garantías deningún tipo.

• Los modelos que se entrenan con el formato de punto de comprobación deberían "congelarse" en elformato del búfer del protocolo antes de su distribución. Para ver un ejemplo, consulte la biblioteca demodelos de clasificación de imágenes de TensorFlow-Slim.

• No utilice las bibliotecas TF-Estimator y TF-Slim en el código de inferencia o de entrenamiento. En sulugar, utilice el patrón de archivo de carga de modelos .pb que se muestra en el ejemplo siguiente.

graph = tf.Graph() graph_def = tf.GraphDef()graph_def.ParseFromString(pb_file.read()) with graph.as_default(): tf.import_graph_def(graph_def)

Note

Para obtener más información sobre las plataformas compatibles con TensorFlow, consulteInstalling TensorFlow en la documentación de TensorFlow.

Cómo configurar Amazon SageMaker para usarMXNet v0.11

En esta sección se describe cómo configurar Amazon SageMaker para entrenar modelos con MXNetv0.11. Esta es la versión recomendada para la inferencia de ML de AWS Greengrass.

1. Cree un bucket de Amazon S3 mediante el procedimiento ¿Cómo puedo crear un bucket de S3? de laGuía del usuario de la consola de Amazon Simple Storage Service.

Asegúrese de incluir sagemaker en el nombre (por ejemplo, sagemaker-fecha_y_hora).2. Cree una instancia del bloc de notas de Amazon SageMaker mediante el procedimiento para crear

una instancia del bloc de notas de Amazon SageMaker de la Guía para desarrolladores de AmazonSageMaker.

3. Cuando el estado de la instancia del bloc de notas sea InService, elija la acción Open (Abrir) paradicha instancia.

4. Elija New (Nuevo) y, a continuación, conda_mxnet_p27 en la lista de kernels de Jupyter. Esto abre unentorno de MXNet para Python 2.7.

5. Anule el campo sagemaker.mxnet.MXNet.train_image predeterminado del código con una imagen delcontenedor de MXNet v0.11, como se indica a continuación:

a. En el siguiente código, reemplace el valor del marcador de posición container-image por laimagen del contenedor de MXNet v0.11 que desea utilizar:

162

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

https://docs.aws.amazon.com/AmazonS3/latest/user-guide/create-bucket.html

https://docs.aws.amazon.com/sagemaker/latest/dg/gs-setup-working-env.html

https://docs.aws.amazon.com/sagemaker/latest/dg/gs-setup-working-env.html

AWS Greengrass Guía para desarrolladoresCómo configurar la inferencia de aprendizaje automático

• Para MXNet v0.11 en Python 2.7 con CPU, especifique sagemaker-mxnet-py2-cpu.• Para MXNet v0.11 en Python 2.7 con GPU, especifique sagemaker-mxnet-py2-gpu.• Para MXNet v0.11 en Python 3.6 con CPU, especifique sagemaker-mxnet-py3-cpu.• Para MXNet v0.11 en Python 3.6 con GPU, especifique 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. Inserte el código antes de la llamada a sagemaker.mxnet.MXNet.fit, lo que envía unasolicitud CreateTrainingJob a Amazon SageMaker utilizando la imagen del contenedor deMXNet v0.11. Esto remplaza la imagen predeterminada de la versión 0.12 por la imagen de laversión 0.11.

A continuación se muestra un fragmento de código de entrenamiento de MXNet de ejemplo con elcódigo nuevo resaltado.

Ahora puede continuar entrenando el modelo tal y como se describe en la documentación AmazonSageMaker.

Cómo configurar la inferencia de aprendizajeautomático mediante la Consola de administraciónde AWS

Esta característica solo está disponible para AWS Greengrass Core v1.5.0.

163

AWS Greengrass Guía para desarrolladoresRequisitos previos

Puede realizar la inferencia de aprendizaje automático (ML) localmente en un dispositivo del núcleo deGreengrass utilizando los datos de los dispositivos conectados. Para obtener información, incluidos losrequisitos y las restricciones, consulte Cómo realizar la inferencia de aprendizaje automático (p. 158).

En este tutorial se describe cómo utilizar la Consola de administración de AWS para configurar un grupode Greengrass para ejecutar una aplicación de inferencias de Lambda que reconoce imágenes de unacámara localmente, sin enviar datos a la nube. La aplicación de inferencias obtiene acceso al módulo de lacámara de un dispositivo Raspberry Pi y ejecuta la inferencia mediante el modelo SqueezeNet de códigoabierto.

El tutorial contiene los siguientes pasos generales:

1. Configurar el Raspberry Pi (p. 164)2. Instalar el marco de trabajo MXNet (p. 165)3. Crear un paquete de modelo (p. 167)4. Cree y publique una función de Lambda (p. 167)5. Adición de la función de Lambda al grupo (p. 172)6. Añadir recursos al grupo (p. 174)7. Añadir una suscripción al grupo (p. 177)8. Implemente el grupo (p. 179)

Requisitos previosPara completar este tutorial, se necesita lo siguiente:

• Raspberry Pi 3 Modelo B.• Módulo de cámara Raspberry Pi V2 de 8 megapíxeles, 1080p. Para obtener información sobre cómo

configurar la cámara, consulte Connecting the camera en la documentación de Raspberry Pi.• Un grupo de Greengrass y un núcleo de Greengrass. Para obtener información sobre cómo crear un

grupo o dispositivo del núcleo de Greengrass, consulte Introducción a AWS Greengrass (p. 30). Lasección de introducción también incluye pasos para instalar el software AWS Greengrass Core en unRaspberry Pi.

Note

Este tutorial utiliza un Raspberry Pi, pero AWS Greengrass es compatible con otras plataformas,como Intel Atom y NVIDIA Jetson TX2 (p. 184).

Paso 1: Configurar el Raspberry PiEn este paso, va a actualizar el sistema operativo Rasbian, instalar el software del módulo de cámara ylas dependencias de Python, y habilitar la interfaz de la cámara. Ejecute los siguientes comandos en elterminal de Raspberry Pi.

1. Actualice Raspbian Jessie.

sudo apt-get updatesudo apt-get dist-upgrade

2. Instale la interfaz picamera del módulo de cámara y las demás bibliotecas de Python necesarias paraeste tutorial.

164

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 Guía para desarrolladoresInstalar el marco de trabajo MXNet

sudo apt-get install -y python-dev python-setuptools python-pip python-picamera

3. Reinicie el Raspberry Pi.

sudo reboot

4. Abra la herramienta de configuración de Raspberry Pi.

sudo raspi-config

5. Utilice las teclas de flecha para abrir Interfacing Options (Opciones de interfaz) y habilitar la interfaz dela cámara. Si se le solicita, permita que el dispositivo se reinicie.

6. Utilice el siguiente comando para probar la configuración de la cámara.

raspistill -v -o test.jpg

Se abre una ventana de vista previa en el Raspberry Pi, se guarda una imagen denominadatest.jpg en el directorio /home/pi, y se muestra información sobre la cámara en el terminal deRaspberry Pi.

Paso 2: Instalar el marco de trabajo MXNetEn este paso, va a descargar las bibliotecas precompiladas de Apache MXNet y va a instalarlas en elRaspberry Pi.

Note

Este tutorial utiliza bibliotecas para el marco de trabajo de aprendizaje automático de MXNet,pero también existen bibliotecas para TensorFlow. Para obtener más información, incluidas laslimitaciones, consulte the section called “Bibliotecas precompiladas para marcos de trabajo deML” (p. 161).

1. Abra la consola de AWS IoT en su equipo.2. En el panel izquierdo, elija Software.

165

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

AWS Greengrass Guía para desarrolladoresInstalar el marco de trabajo MXNet

3. En la sección Machine learning libraries (Bibliotecas de aprendizaje automático), para MXNet/TensorFlow precompiled libraries (Bibliotecas precompiladas de MXNet/TensorFlow), elija Configuredownload (Configurar descarga).

4. En la página Machine learning libraries (Bibliotecas de aprendizaje automático), en Softwareconfigurations (Configuraciones de software), para MXNet Raspberry Pi versión 0.11.0, elija Download(Descargar).

Note

Al descargar este software, acepta la licencia de Apache 2.0.5. Transfiera el archivo ggc-mxnet-v0.11.0-python-raspi.tar.gz descargado desde su equipo

al Raspberry Pi.

Note

Para ver el modo de hacerlo en diferentes plataformas, consulte este paso (p. 49) en lasección Introducción. Por ejemplo, puede utilizar el siguiente comando scp:

scp ggc-mxnet-v0.11.0-python-raspi.tar.gz pi@IP-address:/home/pi

6. En el terminal de Raspberry Pi, descomprima el archivo transferido.

tar -xzf ggc-mxnet-v0.11.0-python-raspi.tar.gz

7. Instalar el marco de trabajo MDXNet.

166

https://www.apache.org/licenses/LICENSE-2.0

AWS Greengrass Guía para desarrolladoresCrear un paquete de modelo

./mxnet_installer.sh

Note

Puede continuar en el the section called “Crear un paquete de modelo” (p. 167) mientras seinstala el marco de trabajo, pero debe esperar a que finalice la instalación antes de continuarcon el the section called “Cree y publique una función de Lambda” (p. 167).Si lo desea, puede ejecutar pruebas de unidad para verificar la instalación. Para ello, añadala opción -u al comando anterior. Si se ejecuta correctamente, cada prueba registra unalínea en el terminal que termina con ok. Si todas las pruebas se realizan correctamente, lainstrucción de registro final contiene OK. Tenga en cuenta que la ejecución de la pruebas deunidad aumenta el tiempo de instalación.

El script también crea un paquete de implementación de funciones de Lambda denominadogreengrassObjectClassification.zip. Este paquete contiene el código de las funciones ylas dependencias, incluido el módulo mxnet de Python, que las funciones de Lambda de Greengrassnecesitan para trabajar con los modelos de MXNet. Cargará este paquete de implementación mástarde.

8. Cuando finalice la instalación, transfiera greengrassObjectClassification.zip a su equipo. Enfunción de su entorno, puede utilizar el comando scp o una utilidad como WinSCP.

Paso 3: Crear un paquete de modelo de MXNetEn este paso, va a descargar los archivos de un modelo de ejemplo de MXNet entrenado previamente y,a continuación, va a guardarlos en un archivo .zip. AWS Greengrass puede utilizar modelos de AmazonS3, siempre que utilicen el formato tar.gz o .zip.

1. Descargue los siguientes archivos en su equipo:

• squeezenet_v1.1-0000.params. Un archivo de parámetros en el que se describen las ponderacionesde la conectividad.

• squeezenet_v1.1-symbol.json. Un archivo de símbolos en el que se describe la estructura de la redneuronal.

• synset.txt. Un archivo synset que mapea los ID de clase reconocidos a nombres de clase enlenguaje natural.

Note

Todos los paquetes de modelos de MXNet utilizan estos tres tipos de archivo, pero elcontenido de los paquetes de modelos de TensorFlow puede variar.

2. Comprima los tres archivos y asigne al archivo comprimido el nombre squeezenet.zip. Cargaráeste paquete de modelo en Amazon S3 en el the section called “Añadir recursos al grupo” (p. 174).

Paso 4: Crear y publicar una función de LambdaEn este paso, va a crear una función de Lambda y la configurará para utilizar el paquete deimplementación que se creó en el Paso 2: Instalar el marco de trabajo MXNet (p. 165). A continuación,publicará una versión de la función y creará un alias.

El paquete de implementación de la función de Lambda se denominagreengrassObjectClassification.zip. Contiene una aplicación de inferencias que realiza tareas

167

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


comunes, como la carga de modelos, la importación de Apache MXNet y la realización de acciones a partirde las predicciones. La aplicación contiene los siguientes componentes principales:

• Lógica de la aplicación:• load_model.py. Carga los modelos de MXNet.• greengrassObjectClassification.py. Ejecuta predicciones sobre las imágenes que se transmiten desde

la cámara.• Dependencias:

• greengrasssdk. Biblioteca necesaria para todas las funciones de Lambda de Python.• mxnet. Biblioteca necesaria para las funciones de Lambda de Python que ejecutan la inferencia local

utilizando MXNet.• Licencia:

• license. Contiene el contrato de licencia del software Greengrass Core necesario.

Note

Puede volver a utilizar estas dependencias y esta licencia para crear funciones de Lambda deinferencia de MXNet.

Primero, cree una función de Lambda.

1. En el panel de la izquierda de la consola de AWS IoT, elija Greengrass y, a continuación, elija Groups(Grupos).

2. Elija el grupo de Greengrass en el que desea añadir la función de Lambda.

168


3. En la página de configuración de grupo, elija Lambdas y, a continuación, elija Add Lambda (AñadirLambda).

4. En la página Add a Lambda to your Greengrass Group (Añadir una función de Lambda a su grupo deGreengrass), elija Create new Lambda (Crear nueva función de Lambda). Esto le lleva a la consola deAWS Lambda.

5. Elija Author from scratch.6. En la sección Author from scratch, utilice los siguientes valores:

Propiedad Valor

Nombre greengrassObjectClassification


Rol Create new role from template(s)

Nombre de rol

(AWS Greengrass no utiliza este rol).

Greengrass_role_does_not_matter

7. En la parte inferior de la página, elija Create function.

169


Ahora, cargue el paquete de implementación de la función de Lambda y registre el controlador.

1. En la pestaña Configuration (Configuración) de la función greengrassObjectClassification, utilice lossiguientes valores para Function code (Código de la función):

Propiedad Valor

Code entry type Upload a .ZIP file


Controlador greengrassObjectClassification.function_handler

2. Seleccione Upload.

3. Elija el paquete de implementación greengrassObjectClassification.zip.

170


4. En la parte superior de la página, elija Save.

A continuación, publique la primera versión de la función de Lambda. A continuación, cree un alias para laversión.

Note

Los grupos de Greengrass pueden hacer referencia a una función de Lambda por alias(recomendado) o por versión. Si se utiliza un alias, resulta más fácil administrar lasactualizaciones del código, ya que no es necesario modificar la tabla de suscripciones ni ladefinición de grupo cuando se actualiza el código de la función. En su lugar, solo tiene que hacerque el alias apunte a la nueva versión de la función.

1. En el menú Actions, elija Publish new version.

2. En Version description, escriba First version y, a continuación, elija Publish.3. En la página de configuración de greengrassObjectClassification: 1, en el menú Actions (Acciones),

elija Create alias (Crear alias).

4. En la página Create a new alias, utilice los valores siguientes:

Propiedad Valor

Nombre mlTest

Version 1

Note

AWS Greengrass no admite alias de Lambda para versiones de $LATEST.5. Seleccione Create.

171




Ahora, añada función de Lambda al grupo de Greengrass.

Paso 5: Añadir la función de Lambda al grupo deGreengrassEn este paso, va a añadir la función de Lambda al grupo y, a continuación, va a configurar su ciclo de vida.

Primero, añada la función de Lambda al grupo de Greengrass.

1. En la consola de AWS IoT, abra la página de configuración de grupo.2. Elija Lambdas (Funciones de Lambda) y, a continuación, elija Add Lambda (Añadir Lambda).

3. En la página Add a Lambda to your Greengrass Group, elija Use existing Lambda.

172


4. En la página Use existing Lambda (Usar función de Lambda existente), elijagreengrassObjectClassification y, a continuación, elija Next (Siguiente).

5. En la página Select a Lambda version (Seleccionar una versión Lambda) elija Alias:mlTest y, acontinuación, elija Finish (Finalizar).

A continuación, configure el ciclo de vida de la función de Lambda.

1. En la página Lambdas (Funciones de Lambda), elija la función de LambdagreengrassObjectClassification.

2. En la página de configuración de greengrassObjectClassification, elija Edit (Editar).3. En la página Group-specific Lambda configuration, utilice los siguientes valores:

Propiedad Valor

Límite de memoria 96 MB

Tiempo de espera 10 segundos

Lambda lifecycle (Ciclo de vida de Lambda) Make this function long-lived and keep it runningindefinitely

Acceso de lectura al directorio /sys Enable

Para obtener más información, consulte the section called “Configuración del ciclo de vida” (p. 130).

173

AWS Greengrass Guía para desarrolladoresAñadir recursos al grupo

4. En la parte inferior de la página, elija Update.

Paso 6: Añadir recursos al grupo de GreengrassEn este paso, va a crear recursos para el módulo de cámara y el modelo de inferencia de aprendizajeautomático. También se asocian los recursos a la función de Lambda, lo que permite a esta obteneracceso a los recursos en el dispositivo del núcleo.

En primer lugar, cree dos recursos de dispositivos locales para la cámara: uno para la memoria compartiday otro para la interfaz del dispositivo. Para obtener más información sobre el acceso a los recursos locales,consulte Obtener acceso a recursos locales con funciones de Lambda (p. 133).

1. En la página de configuración del grupo, elija Resources (Recursos).

2. En la pestaña Local Resources (Recursos locales), elija Add local resource (Añadir recurso local).3. En la página Create a local resource, utilice los siguientes valores:

174


Propiedad Valor

Nombre del recurso videoCoreSharedMemory

Tipo de recurso Dispositivo

Ruta del dispositivo /dev/vcsm



La Device path (Ruta del dispositivo) es la ruta local completa del recurso del dispositivo. Esta ruta deorigen solo puede hacer referencia a un dispositivo de carácter o un dispositivo de bloques situadobajo /dev.

La opción Group owner file access permission (Permiso de acceso a los archivos del propietario delgrupo) le permite conceder al proceso Lambda permisos de acceso a archivos adicionales. Paraobtener más información, consulte Permiso de acceso a los archivos del propietario del grupo (p. 135).

4. En Lambda function affiliations (Afiliaciones de funciones de Lambda), elija Select (Seleccionar).5. Elija greengrassObjectClassification, elija Read and write access (Acceso de lectura y escritura) y, a

continuación, elija Done (Listo).

A continuación, añada un recurso de dispositivo local para la interfaz de la cámara.

175


6. En la parte inferior de la página, elija Add another resource (Añadir otro recurso).7. En la página Create a local resource, utilice los siguientes valores:

Propiedad Valor

Nombre del recurso videoCoreInterface

Tipo de recurso Dispositivo

Ruta del dispositivo /dev/vchiq



8. En Lambda function affiliations (Afiliaciones de funciones de Lambda), elija Select (Seleccionar).9. Elija greengrassObjectClassification, elija Read and write access (Acceso de lectura y escritura) y, a

continuación, elija Done (Listo).10. En la parte inferior de la página, elija Save.

Ahora, añada el modelo de inferencia como recurso de aprendizaje automático. Este paso incluye cargar elpaquete de modelo squeezenet.zip en Amazon S3.

1. En la pestaña Machine Learning (Aprendizaje automático), elija Add machine learning resource(Añadir recurso de aprendizaje automático).

2. En la página Create a machine learning resource (Crear un recurso de aprendizaje automático), enResource name (Nombre del recurso), escriba squeezenet_model.

3. En Model source (Origen del modelo), elija Locate or upload a model in S3 (Buscar o cargar unmodelo en S3).

4. En Model from S3 (Modelo de S3), elija Select (Seleccionar) y, a continuación, elija Create S3 bucket(Crear bucket de S3).

176

AWS Greengrass Guía para desarrolladoresAñadir una suscripción al grupo

5. En Bucket name (Nombre del bucket), escriba un nombre que contenga la cadena greengrass(como greengrass-fecha_y_hora) y, a continuación, elija Create (Crear).

Note

No utilice un punto (".") en el nombre del bucket.6. Elija Upload a model (Cargar un modelo) y, a continuación, elija el paquete squeezenet.zip que ha

creado en el the section called “Crear un paquete de modelo” (p. 167).7. En Local path (Ruta local), escriba /greengrass-machine-learning/mxnet/squeezenet.

Este es el destino para el modelo local en el espacio de nombres del tiempo de ejecución de Lambda.Cuando se implementa el grupo, AWS Greengrass recupera el paquete del modelo de origen y, acontinuación, extrae el contenido en el directorio especificado. La función de Lambda de ejemplo deeste tutorial ya está configurada para utilizar esta ruta (en la variable model_path).

8. En Lambda function affiliations (Afiliaciones de funciones de Lambda), elija Select (Seleccionar).9. Elija greengrassObjectClassification, elija Read-only access (Acceso de solo lectura) y, a continuación,

elija Done (Listo).10. En la parte inferior de la página, elija Save.

Uso de modelos entrenados con Amazon SageMakerEste tutorial utiliza un modelo que está almacenado en Amazon S3, pero también se pueden utilizarfácilmente modelos de Amazon SageMaker. La consola de Greengrass incluye la capacidad de integracióncon Amazon SageMaker, por lo que no es necesario cargar manualmente estos modelos en Amazon S3.Para conocer los requisitos y las restricciones del uso de modelos de Amazon SageMaker, consulte thesection called “Orígenes de modelos admitidos” (p. 159).

Para utilizar un modelo de Amazon SageMaker:

• En Model source (Origen del modelo), elija Use an existing SageMaker model (Usar un modelo deSageMaker existente) y, a continuación, elija el nombre del trabajo de entrenamiento del modelo.

• En Local path (Ruta local), escriba la ruta del directorio en el que la función de Lambda busca el modelo.

Paso 7: Añadir una suscripción al grupo deGreengrassEn este paso, va a añadir una suscripción al grupo. Esta suscripción permite a la función de Lambda enviarlos resultados de predicción a AWS IoT mediante la publicación en un tema MQTT.

177

AWS Greengrass Guía para desarrolladoresAñadir una suscripción al grupo


2. En la página Select your source and target, configure el origen y el destino, de la siguiente manera:

a. En Select a source (Seleccionar un origen), elija Lambdas (Funciones de Lambda) y, acontinuación, elija greengrassObjectClassification.

b. En Select a target (Seleccionar un destino), elija Services (Servicios) y, a continuación, elija IoTCloud.


3. En la página Filter your data with a topic (Filtrar los datos con un tema), en el campo Optional topicfilter (Filtro de temas opcional), escriba hello/world y, a continuación, elija Next (Siguiente).

4. Elija Finalizar.

178


Paso 8: Implementar el grupo de GreengrassEn este paso, va a implementar la versión actual de la definición del grupo en el dispositivo del núcleode Greengrass. La definición contiene la función de Lambda, los recursos y las configuraciones desuscripciones que ha añadido.

1. Asegúrese de que el núcleo de AWS Greengrass se está ejecutando. Ejecute los siguientes comandosen el terminal de Raspberry Pi según sea necesario.




Note

La versión que figura en la ruta depende de la versión del software AWS GreengrassCore que esté instalada en el dispositivo del núcleo.



2. En la página de configuración de grupo, elija Deployments (Implementaciones) y, en el menú Actions(Acciones), elija Deploy (Implementar).

3. En la página Configure how devices discover your core, elija Automatic detection.

Esto permite a los dispositivos adquirir automáticamente la información de conexión del dispositivoprincipal, como la dirección IP, el DNS y el número de puerto. Se recomienda la detección automática,pero AWS Greengrass también es compatible con puntos de enlace especificados manualmente. Solose le solicitará el método de detección la primera vez que se implemente el grupo.

179

AWS Greengrass Guía para desarrolladoresPrueba de la aplicación

Note

Si se le solicita, conceda permiso para crear el rol de servicio de AWS Greengrass en sunombre, que le permite a AWS Greengrass tener acceso a otros servicios de AWS. Solo esnecesario hacerlo una vez para cada cuenta.

En la página Deployments (Implementaciones), se muestra la marca temporal, el ID de versión yel estado de la implementación. Una vez terminada, la implementación debería mostrar el estadoSuccessfully completed.


Prueba de la aplicación de inferenciasAhora puede verificar si la implementación se ha configurado correctamente. Para ello, suscríbase al temahello/world y vea los resultados de la predicción que publica la función de Lambda.

Note

Si se conecta un monitor al Raspberry Pi, la imagen en directo de la cámara se muestra en unaventana de vista previa.

1. En la página de inicio de la consola de AWS IoT, elija Test (Pruebas).

180


2. En Subscriptions (Suscripciones), utilice los siguientes valores:

Propiedad Valor

Subscription topic hello/world

MQTT payload display Display payloads as strings

3. Elija Subscribe to topic.

Si la prueba se realiza correctamente, los mensajes de la función de Lambda aparecen en la parteinferior de la página. Cada mensaje contiene los cinco primeros resultados de predicción de la imagen,con este formato: probabilidad, ID de la clase predicha y nombre de la clase correspondiente.

181


Solución de problemas de inferencia de aprendizaje automáticode AWS GreengrassSi la prueba no se realiza correctamente, puede seguir estos pasos de solución de problemas. Ejecute loscomandos en el terminal de Raspberry Pi.

Compruebe los logs de errores

1. Cambie al usuario raíz.

sudo su

2. Vaya al directorio /log.

cd /greengrass/ggc/var/log

3. Examine runtime.log o python_runtime.log.

Para obtener más información, consulte the section called “Solución de problemas con logs” (p. 207).

Error de "desempaquetado" en runtime.log

Si runtime.log contiene un error similar al siguiente, asegúrese de que el archivo tar.gz del paquetedel modelo de origen tiene un directorio principal.

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 el paquete no tiene un directorio principal que contiene los archivos del modelo, pruebe a volver aempaquetar el modelo con el siguiente comando:

tar -zcvf model.tar.gz ./model

Por ejemplo:

#$ tar -zcvf test.tar.gz ./test./test./test/some.file./test/some.file2./test/some.file3

Note

No incluya caracteres /* en este comando.

Compruebe que la función de Lambda se ha implementado correctamente.

1. Muestre el contenido de la función de Lambda implementada en el directorio /lambda. Sustituya losvalores de los marcadores de posición antes de ejecutar el comando.

182

AWS Greengrass Guía para desarrolladoresPasos siguientes

cd /greengrass/ggc/deployment/lambda/arn:aws:lambda:region:account:function:function-name:function-versionls -la

2. Compruebe que el directorio contiene el mismo contenido que el paquete de implementacióngreengrassObjectClassification.zip que cargó en el Paso 4: Crear y publicar una función deLambda (p. 167).

Asegúrese también de que los archivos .py y las dependencias se encuentran en la raíz deldirectorio.

Compruebe que el modelo de inferencia se ha implementado correctamente

1. Busque el número de identificación de proceso (PID) del proceso de tiempo de ejecución de Lambda:

ps aux | grep lambda-function-name

En el resultado, el PID aparece en la segunda columna de la línea correspondiente al proceso detiempo de ejecución de Lambda.

2. Entre en el espacio de nombres del tiempo de ejecución de Lambda. Asegúrese de que sustituye elvalor del marcador de posición pid antes de ejecutar el comando.

Note

Este directorio y su contenido se encuentran en el espacio de nombres del tiempo deejecución de Lambda, por lo que no son visibles en un espacio de nombres de Linux normal.

sudo nsenter -t pid -m /bin/bash

3. Muestre el contenido del directorio local que ha especificado para el recurso de aprendizajeautomático.

cd /greengrass-machine-learning/mxnet/squeezenet/ls -ls

Debería ver los siguientes archivos:

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

Pasos siguientesA continuación, explore otras aplicaciones de inferencias. AWS Greengrass proporciona otras funciones deLambda que puede utilizar para probar la inferencia local. Puede encontrar el paquete con los ejemplos enla carpeta de bibliotecas precompiladas que descargó en el the section called “Instalar el marco de trabajoMXNet” (p. 165).

183

AWS Greengrass Guía para desarrolladoresConfiguración de un dispositivo NVIDIA Jetson TX2

Configuración de un dispositivo NVIDIA Jetson TX2Para ejecutar este tutorial en la GPU de un dispositivo NVIDIA Jetson TX2, debe añadir recursos dedispositivos locales adicionales y configurar el acceso para la función de Lambda.

Note

El Jetson debe configurarse antes de instalar el software AWS Greengrass Core. Para obtenermás información, consulte Configuración de NVIDIA Jetson TX2 para AWS Greengrass (p. 41).

1. Añada los siguientes recursos de dispositivos locales. Siga el procedimiento indicado en Añadirrecursos al grupo (p. 174).

Para cada recurso:

• En Resource type (Tipo de recurso), elija Device (Dispositivo).• En Group owner file access permission (Permiso de acceso a los archivos del propietario del grupo),

elija Automatically add OS group permissions of the Linux group that owns the resource (Añadirautomáticamente los permisos de grupo de SO del grupo de Linux que posea el recurso).

• En Lambda function affiliations (Afiliaciones de funciones de Lambda), conceda Read and writeaccess (Acceso de lectura y escritura) a la función de Lambda.

Nombre Ruta del dispositivo

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. Edite la configuración de la función de Lambda para aumentar Memory limit (Límite de memoria) a1 000 MB. Siga el procedimiento indicado en Adición de la función de Lambda al grupo (p. 172).

184

AWS Greengrass Guía para desarrolladoresSolicitud

API RESTful de detección deGreengrass

Todos los dispositivos que se comunican con un núcleo de AWS Greengrass deben ser miembros de ungrupo de Greengrass. Cada grupo debe tener un núcleo de AWS Greengrass. La API de detección permitea los dispositivos recuperar la información necesaria para conectarse a un núcleo de AWS Greengrass queesté en el mismo grupo de Greengrass que el dispositivo. Cuando un dispositivo está online por primeravez, se puede conectar al servicio de nube de AWS Greengrass y usar la API de detección para encontrar:

• El grupo al que pertenece.• La dirección IP y el puerto del núcleo de AWS Greengrass en el grupo.• El certificado de CA raíz del grupo, que se puede utilizar para autenticar el dispositivo del núcleo de

AWS Greengrass.

Para utilizar esta API, envíe solicitudes HTTP al siguiente URI:

https://greengrass.iot.aws-region.amazonaws.com/greengrass/discover/thing/thing-name

Utilice el puerto 8443 al conectarse. Para ver una lista de todas las regiones y puntos de enlace admitidosen la API de detección de AWS Greengrass, consulte Regiones y puntos de enlace de AWS en laReferencia general de AWS. Se trata de una API solo del plano de datos. Los puntos de enlace para laadministración del grupo y las operaciones de AWS IoT son diferentes de los puntos de enlace de la APIde detección.

SolicitudLa solicitud contiene los encabezados HTTP estándar y se envía al punto de enlace de detección deGreengrass:

HTTP GET https://greengrass.iot.aws-region.amazonaws.com/greengrass/discover/thing/thing-name

RespuestaRespuesta

En caso de éxito, la respuesta incluye encabezados HTTP estándar, así como el código y el cuerposiguientes:

HTTP 200BODY: response document

Para obtener más información, consulte, Documentos de respuesta de detección de ejemplo (p. 186).

185


AWS Greengrass Guía para desarrolladoresAutorización

AutorizaciónPara recuperar la información de conectividad se necesita una política que permita al intermediario ejecutarla acción greengrass:Discover. La autenticación mutua TLS con un certificado de cliente es la únicaforma de autenticación aceptada. A continuación, se muestra una política de ejemplo que permite a unintermediario realizar esta acción:

{ "Version": "2012-10-17", "Statement": [{ "Effect": "Allow", "Action": "greengrass:Discover", "Resource": ["arn:aws:iot:aws-region:aws-account:thing/thing-name"] }]}

Documentos de respuesta de detección de ejemploEn el siguiente documento se muestra la respuesta para un dispositivo que es miembro de un grupo conun núcleo de AWS Greengrass, un punto de enlace y una CA de grupo:

{ "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-----" ] } ]}

En el siguiente documento se muestra la respuesta para un dispositivo que es miembro de dos grupos conun núcleo de AWS Greengrass, varios puntos de enlace y varias CA de grupo:

{ "GGGroups": [ { "GGGroupId": "gg-group-01-id", "Cores": [ { "thingArn": "core-01-thing-arn", "Connectivity": [ { "id": "core-01-connection-id",

186

AWS Greengrass Guía para desarrolladoresDocumentos de respuesta de detección de ejemplo

"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 grupo de AWS Greengrass debe definir exactamente un núcleo de AWS Greengrass.Cualquier respuesta del servicio de nube de AWS Greengrass que contiene una lista de AWSGreengrass solo contiene un núcleo de AWS Greengrass.

187

AWS Greengrass Guía para desarrolladoresInformación general sobre la arquitectura

Utilice OPC-UA en Greengrass paracomunicarse con equipo industrial

Greengrass admite OPC-UA, un estándar de intercambio de información la comunicación industrial. OPC-UA le permite recibir y procesar los mensajes de los equipos industriales y entregarlos a los dispositivos ensu grupo de Greengrass o a la nube en función de las reglas que defina.

La implementación de OPC-UA en Greengrass admite la autenticación basada en certificados. Se basaen una implementación de código abierto y puede personalizarse por completo. También puede aplicar supropia implementación de OPC-UA, e implementar su propio soporte para otros protocolos de mensajeríapersonalizados, heredados y propios.

En esta sección, se explicarán los siguientes pasos:

• Conectarse a un servidor OPC-UA existente.• Supervisar un nodo OPC-UA existente dentro de dicho servidor.• Hacer que le devuelvan una llamada cuando cambie el valor del nodo supervisado.

Información general sobre la arquitecturaGreengrass implementa OPC-UA como función de Lambda en NodeJS. Habida cuenta de que lasfunciones de Lambda que se ejecutan en dispositivos Greengrass Core tienen acceso a los recursos dered, puede crear funciones de Lambda que entreguen información de los servidores OPC-UA existentes através de TCP a otras funciones o servicios en su grupo de Greengrass.

Puede configurar Greengrass para tener una conexión de larga duración en los servidores OPC-UA y,al usar suscripciones OPC-UA, puede hacer que la función de Lambda OPCUA_Adapter supervise loscambios en los nodos predefinidos. Todo cambio en esos nodos activa un evento Publish desde el servidorOPC-UA, que se recibirá en la función de Lambda y se republicará en los nombres de tema predefinidos.

La estructura de temas se construye de la siguiente manera:

188

AWS Greengrass Guía para desarrolladoresConfigurar un servidor OPC-UA de prueba

Configurar un servidor OPC-UA de pruebaUtilice los siguientes comandos para configurar un servidor OPC-UA de prueba. O bien, si ya dispone deun servidor OPC-UA que desee utilizar en su lugar, puede omitir este paso.

git clone git://github.com/node-opcua/node-opcua.gitcd node-opcuagit checkout v0.0.64npm installnode bin/simple_server

El servidor produce la siguiente salida:

[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

189

AWS Greengrass Guía para desarrolladoresAsegurarse de que el grupo de Greengrass está listo

Asegurarse de que el grupo de Greengrass estálisto

• Crear un grupo de Greengrass (encuentre más detalles en Configuración de AWS Greengrass en AWSIoT (p. 44)).

• Configure un dispositivo Greengrass Core en una de las plataformas admitidas (por ejemplo (p. 31),Raspberry-pi).

• Configure (p. 12) el dispositivo Greengrass Core para poder ejecutar funciones de Lambda nodejs6.x.

Utilizar OPC-UA en Greengrass para interactuarcon los servidores OPC-UA

1. Prepare la función de Lambda.

Obtenga el código para una función de Lambda de adaptador OPC-UA desde GitHub:

git clone https://github.com/aws-samples/aws-greengrass-samples.gitcd aws-greengrass-samples/greengrass-opcua-adapter-nodejsnpm install

Nota:Esta función de Lambda utiliza la biblioteca node-opcua (v0.0.64), que intenta volver a generaralgunos archivos modelo en tiempo de ejecución. Eso no funciona cuando se ejecuta como función deLambda en Greengrass, porque las funciones de Lambda comienzan con un sistema de archivos desolo lectura, por lo que no funcionaría ningún código que intentase generar otro código. El siguientepaso corrige esto.

2. Cambie el archivo en node_modules/node-opcua/lib/misc/factories.js: línea 109 a losiguiente:

var generated_source_is_outdated = (!generated_source_exists);

Ejecute este comando para realiza ese cambio:

sed -i '109s/.*/ var generated_source_is_outdated = (!generated_source_exists);/' node_modules/node-opcua/lib/misc/factories.js

3. Configure el servidor y supervise los nodos.

Cambie la variable configSet en el archivo index.js de la función de Lambda OPC-UA paracontener la dirección IP y el puerto del servidor al que desea conectarse, así como los identificadoresde nodo que desea supervisar. De forma predeterminada, viene con la configuración de ejemplosiguiente:

const configSet = { server: { name: 'server', url: 'opc.tcp://localhost:26543', }, subscriptions: [ { name: 'MyPumpSpeed',

190

AWS Greengrass Guía para desarrolladoresUtilizar OPC-UA en Greengrass para

interactuar con los servidores OPC-UA

nodeId: 'ns=1;s=PumpSpeed', }, ], };

En este caso, vamos a conectarnos a un servidor OPC-UA que se ejecuta en el mismo host quenuestro dispositivo Greengrass Core, en el puerto 26543, y supervisar un nodo que tiene un ID deOPC-UA 'ns=1;s=PumpSpeed'.

4. Configure el modo de autenticación.

La biblioteca OPC-UA que se utilizan en este ejemplo admite tres modos de autenticación en elservidor OPC-UA. El método más seguro es la autenticación basada en certificados, pero la bibliotecatambién le permite especificar el nombre de usuario y la contraseña o la ausencia de autenticación.

A continuación se muestra cómo configurar la autenticación basada en certificados:

• Empaquete el certificado y la clave privada con la función de Lambda, por ejemplo en un directoriodenominado certs/.

• Cambie la variable clientOptions para contener las opciones certificateFile, privateKeyFile,securityModes y 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. Cargue la función de Lambda.

Cree una función de Lambda de Greengrass. En Configuración de la función de Lambda para AWSGreengrass (p. 59), puede encontrar más detalles sobre cómo hacerlo. En resumen, cree un archivode código de la función de Lambda con lo siguiente:

# 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

Agregue esta Lambda a su grupo de Greengrass. Nuevamente, los detalles se encuentran enConfiguración de la función de Lambda para AWS Greengrass (p. 59).

6. Configure e implemente la función de Lambda en su grupo de Greengrass.

191

https://github.com/node-opcua/node-opcua

AWS Greengrass Guía para desarrolladoresCompruebe que la función de Lambda recibe

Publish de OPC-UA y los publica en Greengrass

Después de crear la función de AWS Lambda, agréguela al grupo de Greengrass. Siga lasinstrucciones que aparecen en la misma sección anterior.

• Asegúrese de especificar la función de Lambda como Long-Running.• Asígnele un tamaño de memoria de al menos 64 MB.

Ahora puede crear una implementación con la última configuración. Puede encontrar detalles enImplementación de configuraciones de nube en un dispositivo del núcleo de AWS Greengrass (p. 65).

Compruebe que la función de Lambda recibePublish de OPC-UA y los publica en Greengrass

Como se describe en la sección de arquitectura (p. 188), la función de Lambda debe empezar a recibirmensajes desde el servidor OPC-UA. Si utiliza su propio servidor UA-OPC personalizado, asegúrese deactivar un cambio en el identificador de nodo OPC-UA que especificó, de modo que vea el cambio querecibe la función de Lambda. Si utiliza el servidor de ejemplo anterior, el nodo PumpSpeed se configurapara simular una serie de actualizaciones consecutivas, por lo que ha de esperar que la función deLambda reciba varios mensajes por segundo.

Para ver los mensajes recibidos por la función de Lambda, tiene dos formas:

• Ver los registros de la función de Lambda

Para ver los registros de la función de Lambda, puede ejecutar el siguiente comando:

sudo cat ggc/var/log/user/us-west-2/your_account_id/your_function_name.log

Los registros deben ser parecidos a lo siguiente:

[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}}"

• Configurar Greengrass para reenviar los mensajes de la función de Lambda a IoT Cloud.

Siga los pasos descritos en Verificación de la ejecución de función de Lambda en el dispositivo (p. 67)para recibir mensajes en la consola de AWS IoT.

Nota:

• Asegúrese de que existe una suscripción de su función de Lambda que vaya a IoT Cloud. Los detallesse encuentran en Configuración de la función de Lambda para AWS Greengrass (p. 59).

• Dado que los mensajes se reenvíen a la nube, asegúrese de terminar el servidor de ejemplo queconfiguró anteriormente, o detenga el dispositivo del núcleo de Greengrass, para evitar publicar una grancantidad de mensajes en la nube de IoT y que se le cobre por ello.

192

AWS Greengrass Guía para desarrolladoresPasos siguientes

Pasos siguientesCon Greengrass, puede usar esta misma arquitectura para crear su propia implementación de OPC-UA,y también implementar su propio soporte para otros protocolos de mensajería personalizados, heredadosy propios. Dado que las funciones de Lambda que se ejecutan en dispositivos Greengrass Core tienenacceso a recursos de red, puede usarlas para implementar el soporte para cualquier protocolo quefuncione por TCP-IP. Además, puede aprovechar Greengrass Local Resource Access para implementar elsoporte para los protocolos que tienen que acceder a adaptadores y controladores de hardware.

193


Seguridad de AWS GreengrassAWS Greengrass utiliza certificados X.509, suscripciones administradas, políticas de AWS IoT y políticasy roles de IAM para garantizar que las aplicaciones Greengrass son seguras. Los dispositivos del núcleode AWS Greengrass requieren un objeto AWS IoT, un certificado de dispositivo y una política de AWS IoTpara comunicarse con el servicio de nube de Greengrass.

Esto permite a los dispositivos del núcleo de AWS Greengrass conectarse de forma segura a los serviciosde nube de AWS IoT. También permite que el servicio de nube de Greengrass implemente informaciónde configuración, funciones de Lambda y suscripciones administradas a dispositivos del núcleo de AWSGreengrass.

Los dispositivos AWS IoT requieren un objeto AWS IoT, un certificado de dispositivo y una política de AWSIoT para conectar con el servicio de Greengrass. Esto permite a los dispositivos AWS IoT utilizar el serviciode detección de Greengrass para encontrar un dispositivo del núcleo de AWS Greengrass y conectarsea él. Los dispositivos AWS IoT usan el mismo certificado de dispositivo utilizado para conectarse a lagateway de AWS IoT y a los dispositivos del núcleo de AWS Greengrass. En el siguiente diagrama semuestran los componentes del modelo de seguridad de AWS Greengrass:

A: rol de servicio de Greengrass

Un rol de IAM creado por el cliente que permite a AWS Greengrass obtener acceso a los recursos deAWS IoT y Lambda.

B: certificado del dispositivo del núcleo

Un certificado X.509 que se usa para autenticar un núcleo de AWS Greengrass.C: certificado de dispositivo

Un certificado X.509 que se usa para autenticar un dispositivo AWS IoT.

194

AWS Greengrass Guía para desarrolladoresConfiguración de la seguridad de Greengrass

D: rol de grupo

Una función que asume AWS Greengrass al llamar a la nube desde una función de Lambda en unnúcleo de AWS Greengrass.

E: CA de grupo

Un certificado de CA raíz que usan los dispositivos AWS Greengrass para validar el certificadopresentado por un dispositivo del núcleo de AWS Greengrass durante la autenticación mutua de TLS.

Configuración de la seguridad de GreengrassPara configurar la seguridad de su aplicación Greengrass:

1. Cree un objeto de AWS IoT para su dispositivo del núcleo de AWS Greengrass.2. Genere un par de claves y un certificado de dispositivo para su dispositivo del núcleo de AWS

Greengrass.3. Cree y adjunte una política de AWS IoT al certificado de dispositivo. El certificado y la política permiten

que el dispositivo del núcleo de AWS Greengrass obtenga acceso a los servicios de nube de AWS IoTy Greengrass.

4. Cree un rol de servicio de Greengrass. El rol de IAM concede a AWS Greengrass acceso a susrecursos de Greengrass y AWS IoT. Solo tiene que crear un rol de servicio una vez por cuenta deAWS.

5. (Opcional) Cree un rol de grupo de Greengrass. Este rol concede permiso a las funciones de Lambdaque se ejecutan en un núcleo de AWS Greengrass para llamar a otros servicios de AWS (en la nube).Debe hacerlo para cada grupo de Greengrass que cree.

6. Cree un objeto AWS IoT para cada dispositivo que se conectará a su núcleo de AWS Greengrass.7. Cree certificados de dispositivo, pares de claves y políticas de AWS IoT para cada dispositivo que se

conectará a su núcleo de AWS Greengrass.

Note

También puede utilizar los objetos y los certificados de AWS IoT existentes.

Flujo de trabajo de conexión de dispositivosEn esta sección se describe cómo los dispositivos se conectan al servicio de nube de AWS Greengrass y alos dispositivos del núcleo de AWS Greengrass.

• Un dispositivo del núcleo de AWS Greengrass usa su certificado de dispositivo, la clave privada y elcertificado de CA raíz de AWS IoT para conectar al servicio de nube de Greengrass.

• El dispositivo del núcleo de AWS Greengrass descarga la información de miembros de grupo del serviciode Greengrass.

• Cuando se realiza una implementación en el dispositivo del núcleo de AWS Greengrass, el administradorde certificados de dispositivo (DCM) se encarga de la administración de certificados para el dispositivodel núcleo de AWS Greengrass.

• Un dispositivo AWS IoT se conecta al servicio de nube de Greengrass con su certificado de dispositivo,clave privada y CA raíz de AWS IoT. Después de realizar la conexión, el dispositivo AWS IoT utiliza elservicio de detección de Greengrass para encontrar la dirección IP de su dispositivo del núcleo de AWSGreengrass. El dispositivo también puede descargar el certificado de CA raíz del grupo, que se puedeutilizar para autenticar el dispositivo del núcleo de Greengrass.

195

AWS Greengrass Guía para desarrolladoresFlujo de trabajo de mensajería de Greengrass

• Un dispositivo AWS IoT intenta conectarse al núcleo de AWS Greengrass, pasándole su certificadode dispositivo e ID de cliente. Si el ID de cliente coincide con el nombre de objeto del dispositivo y elcertificado es válido, se establece la conexión. De lo contrario, se termina la conexión.

Flujo de trabajo de mensajería de GreengrassSe usa una tabla de suscripciones para definir cómo se intercambian los mensajes en un grupo deGreengrass (entre dispositivos del núcleo de AWS Greengrass, dispositivos de AWS IoT y funciones deLambda). Cada entrada de la tabla de suscripciones especifica un origen, un destino y un tema de MQTTa través del que se envían y reciben los mensajes. Los mensajes solo pueden intercambiarse si existeuna entrada en la tabla de suscripciones que especifique el origen (remitente del mensaje), el destino (eldestinatario del mensaje) y el tema de MQTT. Las entradas de la tabla de suscripciones especifican latransferencia de mensajes en una dirección, del origen al destino. Si desea transferencia de mensajesbidireccional, cree dos entradas de tabla de suscripciones, una por cada dirección.

Rotación de certificados de servidor del núcleo deMQTT

El certificado de servidor del núcleo de MQTT vence, de forma predeterminada, en 7 días. Puedeconfigurar el vencimiento en cualquier valor entre 7 y 30 días. Cuando el certificado de servidor del núcleode MQTT vence, se produce un error en cualquier intento de validar el certificado. El dispositivo debepoder detectar el error y terminar la conexión. Las conexiones existentes no se ven afectadas. Cuandovence el certificado, el dispositivo del núcleo de AWS Greengrass intenta conectarse al servicio de nubede Greengrass para obtener un nuevo certificado. Si la conexión se realiza correctamente, el dispositivodel núcleo de AWS Greengrass descarga un nuevo certificado de servidor del núcleo de MQTT y reinicia elservicio de MQTT local. En este momento, se desconectan todos los dispositivos de AWS IoT conectadosal núcleo.

Si no hay conexión a Internet cuando el núcleo de AWS Greengrass intenta obtener un nuevo certificadode servidor del núcleo de MQTT, los dispositivos de AWS IoT no pueden conectarse al núcleo de AWSGreengrass hasta que se restaure la conexión al servicio de nube de Greengrass y se pueda descargar unnuevo certificado de servidor del núcleo de MQTT.

Cuando AWS IoT dispositivos se desconectan de un núcleo, tienen que esperar un breve periodo detiempo y, a continuación, intentar volver a conectarse al dispositivo del núcleo de AWS Greengrass.

AWS Greengrass Cipher SuitesAWS Greengrass utiliza el modelo de seguridad de transporte de AWS IoT para cifrar la comunicacióncon la nube mediante conjuntos de cifrado de TLS. Además, los datos de AWS Greengrass se cifranmientras están en reposo (en la nube). Para obtener más información acerca de la seguridad y transportey el conjunto de cifrado de AWS IoT, consulte Seguridad de transporte en la Guía para desarrolladores deAWS IoT.

A diferencia de la nube de AWS IoT, núcleo de AWS Greengrass admite los siguientes conjuntos decifrado de TLS de red local:

Versión de TLS Cifrado

TLSv1.0 TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA

196

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

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

https://docs.aws.amazon.com/iot/latest/developerguide/iot-security-identity.html#transport-security

AWS Greengrass Guía para desarrolladoresAWS Greengrass Cipher Suites

Versión de TLS Cifrado

TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA

TLS_RSA_WITH_AES_128_CBC_SHA





TLSv1.1




TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384


TLS_RSA_WITH_AES_128_GCM_SHA256


TLSv1.2

TLS_RSA_WITH_AES_256_GCM_SHA384

197

AWS Greengrass Guía para desarrolladoresCloudWatch Logs

Monitorización con logs de AWSGreengrass

AWS Greengrass consta del servicio de nube y el software núcleo de AWS Greengrass. El software básicopuede escribir logs en CloudWatch y en el sistema de archivos local del dispositivo del núcleo. El registroestá configurado en el nivel de grupo.

Todas las entradas de log de AWS Greengrass incluyen una marca temporal, un nivel de log e informaciónsobre el evento.

CloudWatch LogsSi configura el registro en CloudWatch, puede ver los logs en la página Logs (Registros) de la consola deAmazon CloudWatch. Los grupos de logs de AWS Greengrass utilizan las siguientes convenciones denomenclatura:

/aws/greengrass/GreengrassSystem/greengrass-system-component-name/aws/greengrass/Lambda/aws-region/account-id/lambda-function-name

En cada grupo de logs verá flujos de logs con la siguiente estructura:

date/account-id/greengrass-group-id/name-of-core-that-generated-log

Tenga en cuenta las siguientes consideraciones cuando utilice CloudWatch Logs:

•Para habilitar el registro en CloudWatch Logs, se deben permitir las siguientes acciones en el rol degrupo de AWS Greengrass:• logs:PutLogEvents• logs:CreateLogGroup• logs:CreateLogStream• logs:DescribeLogStreams

• Los logs se envían a CloudWatch Logs con un número limitado de reintentos en caso de que no hayaconexión a Internet. Cuando se agotan los reintentos, el evento se elimina.

• Se aplican limitaciones de transacciones y de memoria, entre otras. Para obtener más información,consulte the section called “Limitaciones de registro” (p. 202).

Logs del sistema de archivosSi configura el registro en el sistema de archivos, los archivos de log se almacenan en greengrass-root/ggc/var/log en el dispositivo del núcleo, con la siguiente estructura de directorios de alto nivel:

greengrass-root/ggc/var/log - crash.log - system - log files for each Greengrass system component

198

AWS Greengrass Guía para desarrolladoresConfiguración de registro predeterminada

- user - log files generated by each user-defined Lambda function

Note

De forma predeterminada, greengrass-root es el directorio /greengrass. Si se configura undirectorio de escritura (p. 24), entonces los registros están en ese directorio.

Tenga en cuenta las siguientes consideraciones cuando utilice los logs del sistema de archivos:

• La lectura de los logs de AWS Greengrass en el sistema de archivos requiere privilegios raíz.• AWS Greengrass admite la rotación basada en tamaño y la limpieza automática cuando la cantidad de

datos de log se acerca al límite configurado.• El archivo crash.log solo está disponible en los logs del sistema de archivos. Este log no se escribe

en CloudWatch Logs.• Se aplican limitaciones de uso de disco. Para obtener más información, consulte the section called

“Limitaciones de registro” (p. 202).

Note

Los logs de AWS Greengrass Core Software v1.0.0 se almacenan en el directorio greengrass-root/var/log.

Configuración de registro predeterminadaSi las opciones de registro no se configuran de forma explícita, AWS Greengrass utiliza la siguienteconfiguración de registro predeterminada después de la implementación del primer grupo.

Componentes del sistema de AWS Greengrass• Escriba - FileSystem• Componente - GreengrassSystem• Nivel - INFO• Espacio - 128 KB

Funciones de Lambda definidas por el usuario• Escriba - FileSystem• Componente - Lambda• Nivel - INFO• Espacio - 128 KB

Note

Antes de la primera implementación, únicamente los componentes del sistema escriben logs enel sistema de archivos, ya que no se han implementado funciones de Lambda definidas por elusuario.

Configuración del registro para AWS GreengrassPuede utilizar la consola de AWS IoT o las API de AWS Greengrass (p. 200) para configurar el registroen AWS Greengrass.

199

AWS Greengrass Guía para desarrolladoresConfiguración del registro (consola)

Note

Para permitir que AWS Greengrass escriba logs en CloudWatch Logs, el rol de grupo debepermitir las acciones de CloudWatch Logs necesarias (p. 198).

Configuración del registro (consola)Puede configurar el registro en la página Configuración del grupo.

1. En la consola de AWS IoT, elija Greengrass y, a continuación, elija Groups (Grupos).2. Elija el grupo en el que desea configurar el registro.3. En la página de configuración de grupo, elija Settings (Configuración).4. Elija la ubicación de registro de la siguiente manera:

• Para configurar el registro en CloudWatch, en CloudWatch logs configuration (Configuración de logsde CloudWatch), elija Edit (Editar).

• Para configurar el registro en el sistema de archivos, en Local logs configuration (Configuración delogs locales), elija Edit (Editar).

Puede configurar el registro para una ubicación o para ambas.5. En la página Configure Group logging (Configurar registro del grupo), elija Add another log type

(Añadir otro tipo de log).6. Elija el origen de eventos de la siguiente manera:

• Para registrar eventos de funciones de Lambda definidas por el usuario, elija User Lambdas(Funciones de Lambda del usuario).

• Para registrar eventos de los componentes del sistema de AWS Greengrass, elija Greengrasssystem (Sistema de Greengrass).

Puede elegir un componente o ambos.7. Elija Update.8. Elija el nivel de eventos más bajo que desea registrar. Los eventos por debajo de este umbral se filtran

y no se almacenan.9. Para los logs del sistema de archivos, especifique un límite de espacio en disco.10. Seleccione Save.

Configuración del registro (API)Puede utilizar API de registrador de AWS Greengrass para configurar el registro mediante programación.Por ejemplo, utilice la acción CreateLoggerDefinition para crear una definición de registradoresbasada en una carga LoggerDefinitionVersion, que utiliza la sintaxis siguiente:

{ "Loggers": [ { "Id": "string", "Type": "FileSystem|AWSCloudWatch", "Component": "GreengrassSystem|Lambda", "Level": "DEBUG|INFO|WARN|ERROR|FATAL", "Space": "integer" }, { "Id": "string",

200

https://docs.aws.amazon.com/greengrass/latest/apireference/createloggerdefinition-post.html

https://docs.aws.amazon.com/greengrass/latest/apireference/definitions-loggerdefinitionversion.html

AWS Greengrass Guía para desarrolladoresEjemplo de configuración

... } ]}

LoggerDefinitionVersion es una matriz de uno o varios objetos Logger que tienen las propiedadessiguientes:

Id

Un identificador para el registrador.Type

El mecanismo de almacenamiento de eventos de registro. Cuando se utiliza AWSCloudWatch, loseventos de log se envían a CloudWatch Logs. Cuando se utiliza FileSystem, los eventos de registrose almacenan en el sistema de archivos local.

Valores válidos: AWSCloudWatch, FileSystemComponent

El origen del evento de registro. Cuando se utiliza GreengrassSystem, se registran eventos decomponentes del sistema de Greengrass. Cuando se utiliza Lambda, se registran los eventos de lasfunciones de Lambda definidas por el usuario.

Valores válidos: GreengrassSystem, LambdaLevel

El umbral del nivel de registro. Los eventos de registro por debajo de este umbral se filtran y no sealmacenan.

Valores válidos: DEBUG, INFO (recomendado), WARN, ERROR, FATALSpace

La cantidad máxima de almacenamiento local, en KB, que se utilizará para almacenar registros. Estecampo se aplica únicamente cuando Type se establece en FileSystem.

Ejemplo de configuraciónEn el siguiente ejemplo de LoggerDefinitionVersion se especifica una configuración de registro que:

• Activa el registro del nivel ERROR (y superior) en el sistema de archivos para los componentes delsistema de AWS Greengrass.

• Activa el registro del nivel INFO (y superior) en el sistema de archivos para las funciones de Lambdadefinidas por el usuario.

• Activa el registro del nivel INFO (y superior) en CloudWatch para las funciones de Lambda definidas porel usuario.

{ "Name": "LoggingExample", "InitialVersion": { "Loggers": [ { "Id": "1", "Component": "GreengrassSystem", "Level": "ERROR", "Space": 10240,

201

https://docs.aws.amazon.com/greengrass/latest/apireference/definitions-logger.html

AWS Greengrass Guía para desarrolladoresLimitaciones de registro

"Type": "FileSystem" }, { "Id": "2", "Component": "Lambda", "Level": "INFO", "Space": 10240, "Type": "FileSystem" }, { "Id": "3", "Component": "Lambda", "Level": "INFO", "Type": "AWSCloudWatch" } ] }}

Una vez que se haya creado una versión de la definición de registradores, se podrá utilizar su ARN de laversión para crear una versión del grupo antes de implementar este.

Limitaciones de registroAWS Greengrass tiene las siguientes limitaciones de registro.

Transacciones por segundoCuando esté activada la opción de registro en CloudWatch, el componente de registro crea lotes deeventos de registro en el nivel local antes de enviarlos a CloudWatch para poder realizar el registro a unavelocidad superior a cinco solicitudes por segundo por flujo de log.

MemoriaSi se ha configurado AWS Greengrass para que envíe los logs a CloudWatch y una función de Lambdaregistra más de 5 MB/segundo durante un periodo de tiempo prolongado, la canalización de procesamientointerno acaba por llenarse. El peor caso teórico es 6 MB por función de Lambda.

Sesgo del relojCuando se activa la opción de registro en CloudWatch, el componente de registro firma solicitudespara CloudWatch utilizando el proceso de firma Signature Version 4 normal. Si la hora del sistema deldispositivo núcleo de AWS Greengrass no está sincronizada en más de 15 minutos, las solicitudes serechazan.

Consumo de discoUtilice la siguiente fórmula para calcular la cantidad máxima total de consumo de disco para la actividad deregistro.

greengrass-system-component-space * 8 // 7 if automatic IP detection is disabled + 128KB // the internal log for the local logging component + lambda-space * lambda-count // different versions of a Lambda function are treated as one

202

https://docs.aws.amazon.com/AmazonS3/latest/API/sig-v4-authenticating-requests.html

AWS Greengrass Guía para desarrolladoresPérdida de logs

Donde:

greengrass-system-component-space

La cantidad máxima de almacenamiento local para los logs de los componentes del sistema de AWSGreengrass.

lambda-space

La cantidad máxima de almacenamiento local para logs de Lambda.lambda-count

El número de funciones de Lambda implementadas.

Pérdida de logsSi el dispositivo núcleo de AWS Greengrass está configurado para iniciar sesión únicamente enCloudWatch y no hay conexión a Internet, no hay manera de recuperar los logs que se encuentren en lamemoria.

Cuando las funciones de Lambda se terminan (por ejemplo, durante la implementación), hay unossegundos de los logs que no se escriben en CloudWatch.

203


Solución de problemas deaplicaciones de AWS Greengrass

Utilice la siguiente información como ayuda para solucionar problemas en AWS Greengrass.

Problemas

Síntoma Solución

Aparece el error 403 Forbidden en laimplementación en los logs.

Asegúrese de que la política del núcleo de AWSGreengrass en la nube incluya "greengrass:*"como una acción permitida.

La sombra del dispositivo no se sincroniza con lanube.

Compruebe que el núcleo de AWSGreengrass tiene permisos para las acciones"iot:UpdateThingShadow" e "iot:GetThingShadow".

Consulte también Solución de problemas detiempo de espera de sincronización de sombrasagotado (p. 211).

El software núcleo de AWS Greengrass no seejecuta en Raspberry Pi porque el espacio denombres de usuario no está habilitado.

Ejecute rpi-update para actualizar. Raspbian halanzado un nuevo kernel 4.9 que tiene el espaciode nombres de usuario habilitado.

Se produce un error ConcurrentDeployment alejecutar create-deployment por primera vez.

Es posible que haya una implementación en curso.Puede ejecutar get-deployment-history paraver si se ha creado una implementación. En casocontrario, intente volver a crear la implementación.

El software núcleo de AWS Greengrass no seinicia correctamente.

• Compruebe que están utilizando los binariosadecuados para la arquitectura.

• Compruebe si existen mensajes de error enruntime.log. Para obtener más información,consulte Solución de problemas conlogs (p. 207).

• Compruebe que el dispositivo núcleo deAWS Greengrass tiene almacenamiento localdisponible.

El software de núcleo de AWS Greengrass nose inicia en un Raspberry Pi y recibe el siguienteerror: 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: { }.

Esto puede ocurrir si la versión del sistemaoperativo es Raspbian Stretch. Puede ejecutarel siguiente comando en el terminal para ver laversión del sistema operativo que está instalada enel Raspberry Pi:

cat /etc/os-release

Recomendamos que utilice la plataformacompatible (p. 12) (actualmente RaspianJessie, 2017-03-02). Sin embargo, si decideejecutar el software de núcleo de AWSGreengrass en Raspbian Stretch, añada

204




Síntoma Solucióncgroup_enable=memory al archivo /boot/cmdline.txt y, a continuación, reinicie eldispositivo.

Note

Es posible que encuentre otros problemassi ejecuta el software AWS GreengrassCore en una plataforma no compatible.

El software de núcleo de AWS Greengrass nose inicia y recibe el siguiente error: Unableto create server due to: failedto 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 ha implementado un ??? (p. 130) en elnúcleo, compruebe la propiedad Handler de lafunción en el archivo group.json (localizadoen /greengrass-root/ggc/implementación/grupo). Si el controlador no es el nombre exactodel ejecutable compilado, reemplace el contenidodel archivo group.json con un objeto JSON vacío({}) e inicie Greengrass; ejecute los siguientescomandos:


A continuación, utilice la API de AWS Lambdapara actualizar el parámetro handler de laconfiguración de la función, publique la nuevafunción y actualice el alias. Para obtener másinformación, consulte Control de versiones y aliasde las funciones de AWS Lambda.

Suponiendo que haya añadido la función a sugrupo de Greengrass por alias (recomendado),ahora puede volver a implementar su grupo. (Sino, debe apuntar a la nueva versión o alias de lafunción en su definición y suscripciones del grupoantes de implementar el grupo).

El software de núcleo de AWS Greengrass nose inicia y recibe el siguiente error: Spool sizeshould be at least 262144 bytes.

Abra el archivo group.json (localizadoen /greengrass-root/ggc/implementación/grupo), reemplace el contenido del archivo conun objeto JSON vacío ({}) e inicie Greengrass;ejecute los siguientes comandos:


A continuación, siga el procedimientothe section called “Para almacenar losmensajes en caché en el almacenamientolocal” (p. 27) y asegúrese de especificar un valorGG_CONFIG_MAX_SIZE_BYTES mayor o igual a262144 para la función GGCloudSpooler.

205

https://docs.aws.amazon.com/cli/latest/reference/lambda/




Síntoma Solución

El script greengrassd muestra: unable toaccept TCP connection. accept tcp[::]:8000: accept4: too many openfiles.

El límite del descriptor de archivos para el softwarenúcleo de AWS Greengrass ha alcanzado elumbral máximo y debe incrementarse.

Para ello, use el siguiente comando:

ulimit -n 2048

y reinicie el software núcleo de AWS Greengrass.

Note

En este ejemplo, el límite se aumenta a2048. Elija un valor adecuado para sucaso de uso.

Se muestra el error siguiente: Runtimeexecution 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\\\"\""

Instale AWS Greengrass directamente debajo deldirectorio raíz, o asegúrese de que el directorio /greengrass y sus directorios principales tienenpermisos execute para todos los usuarios.

La implementación falla con el siguiente mensajede error: Greengrass is not authorizedto assume the Service Role associatedwith this account.

Utilice la AWS CLI para comprobar si se haasociado un rol de servicio apropiado a su cuentamediante GetServiceRoleForAccount y asegúresede que dicho rol dispone al menos del permisoAWSGreengrassResourceAccessRolePolicy.Si necesita asociar un rol de serviciode Greengrass a su cuenta, utiliceAssociateServiceRoleToAccount.

206

https://docs.aws.amazon.com/greengrass/latest/apireference/getserviceroleforaccount-get.html

https://docs.aws.amazon.com/greengrass/latest/apireference/associateserviceroletoaccount-put.html

AWS Greengrass Guía para desarrolladoresSolución de problemas con logs

Síntoma Solución

La implementación no finaliza. Asegúrese de que el demonio de AWS Greengrassse está ejecutando en su dispositivo del núcleo.Ejecute los siguientes comandos en el terminal deldispositivo del núcleo para comprobar si se estáejecutando el demonio, e iniciarlo, si es necesario.

1. Para comprobar si el demonio está enejecución:



La versión que figura en la ruta depende de laversión del software AWS Greengrass Coreque esté instalada en el dispositivo del núcleo.

2. Para comenzar el demonio:


La implementación no finaliza, y runtime.logcontiene varias entradas wait 1s forcontainer to stop.

Reinicie el demonio de AWS Greengrassejecutando los comandos siguientes en el terminaldel dispositivo del núcleo.

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

Se mostrará el error siguiente: Deployment guidof type NewDeployment for group guidfailed error: Error while processing.group config is invalid: 112 or [1190] don't have rw permission on thefile: path

Asegúrese de que el grupo propietario deldirectorio path tiene permisos de lectura yescritura en el directorio.

Si no logra encontrar o resolver el problema con esta información, puede realizar una búsqueda en el Forode AWS Greengrass o publicar un nuevo hilo. Los miembros del equipo de AWS Greengrass monitoreanactivamente el foro.

Solución de problemas con logsGGC v1.6.0

Si los logs se han configurado para almacenarse en el sistema de archivos local, empiece por buscaren las siguientes ubicaciones. La lectura de los logs en el sistema de archivos requiere privilegios raíz.

greengrass-root/ggc/var/log/crash.log

Muestra los mensajes generados cuando núcleo de AWS Greengrass se bloquea.

207




greengrass-root/ggc/var/log/system/runtime.log

Muestra mensajes sobre qué componente ha dado error.greengrass-root/ggc/var/log/system/

Contiene todos los logs de los componentes del sistema de AWS Greengrass, como CertificateManager y el Connection Manager. Utilizando los mensajes de ggc/var/log/system/ yggc/var/log/system/runtime.log, debería poder averiguar qué error se produjo en loscomponentes del sistema de AWS Greengrass.

greengrass-root/ggc/var/log/user/

Contiene todos los logs de las funciones de Lambda definidas por el usuario. Compruebe siexisten mensajes de error de las funciones de Lambda locales en esta carpeta.

Note

De forma predeterminada, greengrass-root es el directorio /greengrass. Si se configuraun directorio de escritura (p. 24), entonces los registros están en ese directorio.

Si los logs se han configurado para almacenarse en la nube, utilice CloudWatch Logs para ver losmensajes de log. Tenga en cuenta que crash.log solo se encuentra en los logs del sistema dearchivos del dispositivo de núcleo de AWS Greengrass.

Si se ha configurado AWS IoT para escribir logs en CloudWatch, compruebe esos logs para saber sise producen errores de conexión cuando los componentes del sistema intentan conectarse con AWSIoT.

Para obtener más información acerca del registro en AWS Greengrass, consulteMonitorización (p. 198).

GGC v1.5.0



Muestra los mensajes generados cuando núcleo de AWS Greengrass se bloquea.greengrass-root/ggc/var/log/system/runtime.log





Note

De forma predeterminada, greengrass-root es el directorio /greengrass.

208





GGC v1.3.0








Note





GGC v1.1.0




Muestra mensajes sobre qué componente ha dado error.

209


greengrass-root/ggc/var/log/system/




Note





GGC v1.0.0


greengrass-root/var/log/crash.log

Muestra los mensajes generados cuando núcleo de AWS Greengrass se bloquea.greengrass-root/var/log/system/runtime.log

Muestra mensajes sobre qué componente ha dado error.greengrass-root/var/log/system/

Contiene todos los logs de los componentes del sistema de AWS Greengrass, como CertificateManager y el Connection Manager. Utilizando los mensajes de var/log/system/ y var/log/system/runtime.log, debería poder averiguar qué error se produjo en los componentes delsistema de AWS Greengrass.

greengrass-root/var/log/user/


Note


Si se ha configurado AWS Greengrass para escribir logs en CloudWatch, puede ver mensajes de logen la consola de CloudWatch (p. 198). Tenga en cuenta que crash.log solo se encuentra en los logsdel sistema de archivos del dispositivo de núcleo de AWS Greengrass.


210

AWS Greengrass Guía para desarrolladoresSolución de problemas de almacenamiento

Solución de problemas de almacenamientoCuando el sistema de almacenamiento de archivos local se llene, es posible que algunos componentesempiecen a dar error:

• Las actualizaciones de sombras locales no se realizan.• Los nuevos certificados de servidor MQTT de núcleo de AWS Greengrass no se pueden descargar

localmente.• Las implementaciones producen errores.

Siempre debe conocer la cantidad de espacio libre disponible en el nivel local. Esto puede calcularse enfunción de los tamaños de las funciones de Lambda implementadas, la configuración de la actividad deregistro (consulte Solución de problemas con registros (p. 207)) y el número de sombras almacenadaslocalmente.

Solución de problemas con mensajesTodos los mensajes que se envían dentro de AWS Greengrass se envían con QoS 0. De formapredeterminada AWS Greengrass almacena los mensajes en un cola en memoria. Por lo tanto, losmensajes sin procesar se pierden cuando se reinicia núcleo de AWS Greengrass, por ejemplo, despuésde una implementación de grupo o de un reinicio del dispositivo. Sin embargo, puede configurar AWSGreengrass (v) para almacenar los mensajes en caché en el sistema de archivos de modo que persistanentre los reinicios del núcleo. También puede configurar el tamaño de la cola. Para obtener másinformación, consulte the section called “Cola de mensajes MQTT” (p. 26).

Note

Cuando se utiliza el valor predeterminado de la cola en memoria, le recomendamos queimplemente grupos o reinicie el dispositivo en un momento en el que la interrupción del serviciosea mínima.

Si configura un tamaño de cola, asegúrese de que sea mayor o igual a 262144 bytes (256 KB). De locontrario, AWS Greengrass podría no iniciarse correctamente.

Solución de problemas de tiempo de espera desincronización de sombras agotado

GGC v1.6.0

Si hay un retraso importante en la comunicación entre un dispositivo del núcleo de Greengrass y lanube, la sincronización de sombras puede producir un error debido a que se ha agotado el tiempo deespera. Puede ver algo parecido a lo siguiente en sus archivos log:

[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/

211

AWS Greengrass Guía para desarrolladoresSolución de problemas de tiempo de espera

de sincronización de sombras agotado

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 []}"

Una posible solución es configurar la cantidad de tiempo durante la que el dispositivo del núcleode Greengrass espera un respuesta del host. Abra el archivo greengrass-root/config/config.json y añada un campo system.shadowSyncTimeout con un valor de tiempo de espera ensegundos. Por ejemplo:

{ "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 no se especifica un valor de shadowSyncTimeout en el archivo config.json, el valor predeterminadoes 1 segundo.

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", "certPath": "cloud.pem.crt", "keyPath": "cloud.pem.key", "thingArn": "arn:aws:iot:us-west-2:049039099382:thing/GGTestGroup42_Core",

212



"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






213



GGC v1.1.0






GGC v1.0.0

No es compatible.

214

AWS Greengrass Guía para desarrolladoresActualizaciones anteriores

Historial de revisión de AWSGreengrass

En la siguiente tabla se describen los cambios importantes de la Guía para desarrolladores de AWSGreengrass posteriores a junio de 2018. Para obtener notificaciones sobre las actualizaciones de estadocumentación, puede suscribirse a una fuente RSS.

update-history-change update-history-description update-history-date

Lanzamiento de AWSGreengrass versión 1.6.0

Nuevas características: , cola demensajes configurable, intervalode reintento de reconexiónconfigurable, recursos devolumen bajo /proc y directorio deescritura configurable.

July 26, 2018

Actualizaciones anterioresEn la siguiente tabla se describen los cambios importantes de la Guía para desarrolladores de AWSGreengrass anteriores a julio de 2018.

Cambio Descripción Fecha

Lanzamiento deAWS Greengrassversión 1.5.0


• Inferencia del aprendizaje automático local mediante modelosentrenados en la nube. Para obtener más información, consulte Cómorealizar la inferencia de aprendizaje automático (p. 158).

• Las funciones de Lambda de Greengrass admiten datos de entradabinarios, además de JSON.

Para obtener más información, consulte Versiones de núcleo de AWSGreengrass (p. 2).

29 demarzode 2018



• El agente de actualización transparente (OTA) es capaz deadministrar trabajos de actualización de Greengrass implementadosen la nube. Para obtener más información, consulte Actualizacionesde OTA del software AWS Greengrass Core (p. 118).

• Acceso a periféricos y recursos locales desde las funciones Lambdade Greengrass. Para obtener más información, consulte Obteneracceso a recursos locales con funciones de Lambda (p. 133).

27 denoviembrede 2017


Nuevas características: 20 deseptiembrede 2017

215

https://docs.aws.amazon.com/greengrass/latest/developerguide/what-is-gg.html#ggc-versions

https://docs.aws.amazon.com/greengrass/latest/developerguide/what-is-gg.html#ggc-versions

AWS Greengrass Guía para desarrolladoresActualizaciones anteriores

Cambio Descripción Fecha• Restablecimiento de instancias implementadas de grupo de AWS

Greengrass. Para obtener más información, consulte Restablecimientode implementaciones (p. 124).

• Compatibilidad con los runtimes Lambda de Node.js 6.10 y Java 8,además de Python 2.7.


AWS Greengrass está disponible con carácter general. 7 dejunio de2017

216

aws greengrass - guía para desarrolladores · api restful de detección de greengrass ... • las...

Documents