AWS Greengrass

En esta parte del workshop se instalara el software de AWS IoT Greengrass en una instancia de EC2 Cloud9.

Configuración inicial

Para iniciar crearemos otra instancia de Cloud9

Si no recuerda los pasos, aqui estan

En Servicios escribimos “Cloud9” :

En Cloud9, seleccionamos “Create environment” Ingresamos un nombre a nuestro ambiente, puede ser “Pruebas IoT” y seleccionamos “Next Step” En la siguiente pantalla elegimos el tipo de maquina que usaremos, para estos fines la opción más pequeña sera suficiente. Dejamos las opciones como se muestra en esta imagen:

En la configuración de red, podemos seleccionar la VPC por default. Si optamos por otra es importante que sea una subred pública Y finalmente en la última página validamos que todo este correcto y seleccionamos “Create environment”

Se recomienda cambiar el fondo del IDE para diferenciar entre Cloud9 de Dispositivos y Cloud9 de Greengrass:

IMPORTANTE:

Antes de continuar, es necesario abrir el puerto 8883 para escuchar las peticiones entre los 2 Cloud9. Para ello, en la consola de AWS en Servicios tecleamos VPC

En el menu de la izquierda, bajamos hasta Security y luego Security Groups y se verá una pantalla similar a esta:

Se van a seleccionar primero el security group que inicia con aws-cloud9…

En la parte baja de la pantalla seleccionar Edit inbound rules

En la nueva pantalla clic en Add rule e ingresar los siguientes valores:

  • Type: Custom TCP
  • Port range: 8883
  • source: 0.0.0.0/0

y clic en Save Rules

Al final debe quedar algo similar:

Hacer lo mismo con el otro security group llamado aws-cloud9… que corresponde al otro Cloud9

Ahora, de regreso en Cloud9-Greengrass:

Para poder realizar la instalación de AWS IoT Greengrass en Cloud9, se ejecutaran los siguientes comandos en Terminal de Cloud9.

cd ~/environment/
wget https://s3.amazonaws.com/iot-aws.com/tools/ec2-fast.sh
chmod +x ec2-fast.sh
sudo -u ec2-user ./ec2-fast.sh

Al final del script esta el comando de reiniciar, pero es posible que no se ejecute, por ello escribir:

sudo reboot

Una vez que termine el reinicio, los elementos de Greengrass estaran instalados. Ahora regresemos a AWS IoT Core para crear el grupo de AWS IoT Greengrass.

El AWS IoT Greengrass seleccionamos Greengrass –> Grupos En el boton superior derecho clic en Crear grupo

Al ser la primera vez que se usa Greengrass solicitará permiso para crear el rol necesario. Dar clic en Conceder permiso y continuar.

En la siguiente pantalla, clic en Usar la creación predeterminada Posteriormente, ingresamos el nombre : gg_grupo_borde

Finalmente la siguiente pantalla sera similar a esta y seleccionamos Crear grupo y nucleo

Al terminar varias cosas se habrán creado:

  • Grupo de Greengrass
  • El nucleo, el cual es el dispositivo de se usara
  • Certificados para el nucleo
  • Políticas de seguridad y bitacoras

Se requiere descargar el archivo tar.gz con los certificados creados. Para ello se da clic en Dercargar estos recursos como tar.gz

El software ya fue instalado en la parte anterior, por lo que no es necesario descargarlo. Dar clic en Finalizar para terminar.

Creaciones Roles

En la consola de AWS, en Servicios teclear IAM. En la pantalla, dar clic en Roles sobre el menu de la izquierda. Y luego en el boton azul Crear un rol

Posteriormente, en la siguiente pantalla seleccionar Servicio de AWS y luego Greengrass en “Elija un caso de uso”, como se muestra a continuación y dar clic en Siguiejte: Permisos

Luego en “Filtrar políticas”, ingresar: AWSGreengrassResourceAccessRolePolicy y dar clic en el cuadro como se muestra en la imagen.

Borrar el texto en el filtro e ingresar: CloudwatchLogsFullAccess . Como se muestra en la siguiente pantalla:

Dar clic en Siguiente: Etiquetas y luego clic en Siguiente Revisar

Deben estar las 2 politicas que se agregaron y escribir el nombre GG_Borde_rol . La pantalla debe quedar como la siguiente:

Y dar clic en Crear rol

Ahora es necesario asociar este rol al grupo de Greengrass creado anteriormente. Regresar a la pantalla de IoT Core. Y en el menu de la izquierda, seleccionar Greengrass –> Grupos y en la pantalla dar clic en el grupo que se creo en los pasos anteriores.

En la nueva pantalla dar clic en Configuración en el menu de la izquierda. Y luego Añadir Rol como se muestra a continuacion

Y seleccionar el que se creo de la lista ( si hay varios). Y dar clic en Guardar

Ahora es necesario configurar el tipo de bitacora que se requiere, para lo cual en la misma pantalla de Configuración hasta abajo, dar clic en Editar en la sección “Configuración de Registros de CloudWatch” . En la nueva pantalla clic en Agregar otro tipo de registro

Marcar ambas opciones y dar clic en Actualizar :

Dejar la opciones de “Informativo” y dar clic en Guardar

Para tener la comunicación entre el dispositivo en el borde y AWS IoT Core es necesario declarar el EndPoint al cual se va a conectar. Para obtener esta información, dentro de Configuración vamos a la sección “Información de conectividad del núcleo” y cambiamos a Administrar manualmente la información de conexión y luego clic en Ver núcleos para obtener información específica del punto de enlace :

La siguiente pantalla contendrá el nombre del núcleo que se creo previamente. Damos clic en él. Luego en el menú de la izquierda seleccionar Conectividad

Antes de ingresar la dirección IP es necesario volver a Cloud9 para obtener la dirección IP de la instancia. Para ello en Terminal, se ingresa la siguiente línea:

curl http://169.254.169.254/latest/meta-data/public-ipv4

La dirección IP se copia y regreso a la pantalla de IoT Core, dar clic en Editar

Se ingresa en la siguiente pantalla en IoT Core, junto con el número de puerto 8883 :

Y damos clic en Actualizar

Instalar AWS IoT Greengrass en el dispositivo

Ya que se habia instalado el software previamente, ahora sólo hace falta configurar los certificados. En la pantalla de Cloud9, en File –> Upload Local Files y seleccionar el archivo .tar.gz que se descargó previamente.

Reemplazar el nombre en el siguiente comando:

sudo tar -zxvf [greengrass-os-architecture-version.tar.gz] –C /

Y luego se copia al directorio y al final se inicia el proceso de Greengrass.

cd /
sudo cp certs/* /greengrass/certs
sudo cp config/* /greengrass/config

cd /greengrass/certs/
sudo wget -O root.ca.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem

cd /greengrass/ggc/core/

sudo ./greengrassd start

Y para probar la conexion copiamos esta linea :

sudo tail -f /greengrass/ggc/var/log/system/runtime.log

Y estos mensajes deben observarse:

Desplegar grupo de Greengrass

Ahora que se tiene configurado el dispositivo regresamos a AWS IoT Core en la seccioón de Greengrass –> Grupos seleccionamos el nombre del grupo y dar clic en Acciones y luego Implementar :

Al ser la primera vez que se intenta el despliegue, solicitará la configuración para detectar el núcleo. Esto ya se hizo antes, solo hay que dar clic en Configurar Manual, validar que la IP es la correcta y está el puerto y dar clic en Siguiente

Esto comenzará el despliegue de información hacia el dispositivo desde AWS IoT Core. Después de unos minutos debe terminar la tarea con éxito, indicando : Completado correctamente

Felicidades, Greengrass esta corriendo correctamente!!

Crear una funcion Lambda para el borde

AWS IoT Greengrass tiene la capacidad de desplegar funciones Lambda en los dispositivos del borde para ejecutar codigo sin que este conectado a AWS o bien reenviarlo a AWS. A continuación crearemos dicha función para enviarla al dispositivo.

Para crear la función Lambda, en la consola de AWS en Servicios teclear Lambda, en la consola dar clic en Crear Funcion en el boton naranja arriba.

Agregar los siguientes valores:

Nombre función: Borde

Tiempo de ejecución: Python 2.7 OJO es version 2.7

Clic en Crear una función

La pantalla será similar a esta:

Para simplicar, se cargara una función que ya tiene la librerias necesarias, dar clic en la sección Código de la función y Acción como se muestra:

Y se ingresa la siguiente direccion:

https://s3.amazonaws.com/iot-aws.com/tools/gg_borde_to_aws_lambda.zip

El codigo que se cargó es el siguiente, pero YA NO ES NECESARIO INGRESARLO

import sys
import logging
import json
import greengrasssdk

logger = logging.getLogger(__name__)
logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)

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

def Borde_handler(event, context):
    logger.info(" Lambda en el borde is ONLINE")
    logger.info(json.dumps(event))

    # Let's publish a response back to AWS IoT
    client.publish(topic = "/borde-cloud", payload = json.dumps(event))

    return True

Bajar la pantalla y en la seccion Configuración básica dar clic en Editar y modificar el nombre en Controlador por borde_aws.Borde_handler

Y dar clic en Guardar

Subir la pantalla y dar clic en Acciones –> Publicar nueva versión y dar clic en Publicar

Luego, nuevamente clic en Acciones –> Crear un Alias y en Nombre teclear prod y seleccionar Version : 1 Y clic en Guardar

Ahora, regresar a la pantalla de AWS IoT Core, seleccionar: Greengrass –>Grupos y luego el nombre del grupo creado. En la siguiente pantalla, clic en el menu de la izquierda Funciones Lambda Y clic en Añadir Lambda

En la siguiente pantalla clic en Usar una función Lambda existente y en la próxima pantalla seleccionar la función que se creo: Borde y Clic en siguiente y seleccionar Alias:

Y clic en Finalizar

Dispositivo para pruebas

Ahora es necesario creo otro dispositivo que será agregados al grupo de Greengrass.

En el grupo de Greengrass, seleccionar Dispositivos y clic en Añadir dispositivo

En la siguiente pantalla clic en Crear un nuevo dispositivo

Como nombre teclear : gg_device Este nombre se usara luego

Y clic en Usar la configuración predeterminada

En la última pantalla clic en Descargar estos recursos como tar.gz y clic en Finalizar

Crear suscripciones

Para que AWS IoT Greengrass pueda tener información de los dispositivos, es necesario crear las suscripciones entre ellos.

Ahora nuevamente en pantalla del grupo de Greengrass, en el menu de la izquierda se selecciona Suscripciones

Y luego Añadir su primera suscripción . En la siguiente pantalla, en Seleccionar su origen: En Dispositivos seleccionar el dispositivo agregado. En la parte inferior Seleccionar un destino, en Funciones Lambda usar la creada previamente:

Y clic en Siguiente.

En la próxima pantalla ingresar el topico que se estara filtrando:

/gg_device1

Y dar clic en Finalizar

Ahora es necesario crear otra suscripción desde Lambda a IoT Core para poder ver los mensajes.

Repetir los pasos anteriores con ls siguientes opciones:

  • Como origen seleccionar Funcion Lambda y marcar nuevamente la función creada.

  • Como destino seleccionar Servicios y marcar IoT Cloud

Y en el tema ingresar /borde-cloud

Al final las 2 suscripciones se veran asi:

Desplegar la Lambda a Greengrass

Ahora que se tiene todo configurado, es posible desplegar todo a Greengrass en el borde. Para esto vamos al Grupo de Greengrass:

En IoT Core , Greengrass–>Grupos y en el centro clic en el nombre del grupo.

En la nueva pantalla, arriba a la derecha clic en Acciones–>Implementar

En lo que el despliegue termina, ahora configuraremos en Cloud9 como si fuera el dispositivo que se creo nuevo.

Una vez que el despliegue termine, para verificar que la función Lmabda fue desplegada, en la pantalla de Cloud9-Greengrass ingresar el siguiente codigo en Terminal:

sudo ls -l /greengrass/ggc/deployment/lambda

Y deberá listarse la lambda que creamos en AWS.

Configuracion de dispositivo

En el otro Cloud9-Dispositivo, es necesario hacer lo siguiente:

Crear una carpeta nueva, llamada Lab3

Cargar en esta los certificados del dispositivo creado en Greengrass:

  • Seleccionar la carpera Lab3 y Clic en File–>Upload local files
  • Seleccionar el archivo .tar.gz
  • En Terminal, moverse a la carpeta creada: cd ~/environment/Lab3
  • Descomprimirlo con: sudo tar -zxvf {NOMBRE ARCHIVO}

Pero el certificado CA que antes habiamos usado para comunicarnos a AWS IoT Core, no es posible usarlo pues se quiere la comunicación con Greengrass. Por lo tanto es necesario obtenerlo.

En Terminal ingresar los siguientes comandos:

aws greengrass list-groups

De esta parte copiar el ID del grupo e ingresarlo en el siguiente comando:

aws greengrass list-group-certificate-authorities --group-id [ID]

Nuevamente, de esta ejecucion copiar el ID y la autoridad certificadora

aws greengrass get-group-certificate-authority --certificate-authority-id [GroupCertificateAuthorityId] --group-id [YOUR-GROUP-ID] --output text --query PemEncodedCertificate > gg_grupo_borde_Core_CA.pem

Los valores similares a los que saldran son:

Al final el archivo gg_grupo_borde_Core_CA.pem tendrá el certificado.

Ahora se creará un nuevo archivo para cargar el codigo de Python que haga las llamadas a Greengrass.

En Terminal ingresar el codigo

touch gg_device.py

Doble clic en el archivo creado e ingresar el siguiente codigo y cambiar el punto de acceso de Greengrass y los nombres de los certificados del dispositivo. Salvar el archivo.

# gg_device Test Client
import sys
import ssl
from AWSIoTPythonSDK.MQTTLib import AWSIoTMQTTClient
import json
import time

mqttc = AWSIoTMQTTClient("gg_device")

# CAMBIAR EL ENDPOINT DE GREENGRASS
mqttc.configureEndpoint("[CAMBIAR EL ENDPOINT DE GREENGRASS]",8883)
mqttc.configureCredentials("./gg_grupo_borde_Core_CA.pem","./[CAMBIAR POR LLAVE].pem.key","./[CAMBIAR POR CERT ].pem.crt")

#Function to encode a payload into JSON
def json_encode(string):
    return json.dumps(string)

mqttc.json_encode=json_encode

message ={
  'message': "HOLA DESDE EL DEVICE gg_device"
}

#Encoding into JSON
message = mqttc.json_encode(message)

mqttc.connect()

print ("Conectado con Greengrass core!")

mqttc.publish("/gg_device1", message, 0)

print ("Mensaje publicado")
mqttc.disconnect()
time.sleep(10)

Antes de ejecutar el script, en AWS IoT Core vamos a escuchar cualquier mensaje que llegue. En el menu, seleccionamos Pruebas y luego en Tema de suscripción tecleamos # y clic en Suscribirse al tema

Ahora si, de regreso en Cloud9-Dispositivo ejecutamos el sript:

python gg_device.py

Al final debe conectarse correctamente al otro dispositivo de Greengrass y ejecutar la Lambda que fue desplegada. Posteriormente con la suscripción que se creó, el mensaje es reenviado desde la Lambda a AWS IoT para ser publicada.