Aviso de fin de soporte: el 7 de octubre de 2026, AWS suspenderemos el soporte para AWS IoT Greengrass Version 1. Después del 7 de octubre de 2026, ya no podrá acceder a los AWS IoT Greengrass V1 recursos. Para obtener más información, visita [Migrar desde AWS IoT Greengrass Version 1](https://docs.aws.amazon.com/greengrass/v2/developerguide/migrate-from-v1.html).
Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Cómo configurar la inferencia de aprendizaje automático optimizada mediante Consola de administración de AWS
Para seguir los pasos de este tutorial, debe utilizar AWS IoT Greengrass Core v1.10 o una versión posterior.
Puedes usar el compilador de aprendizaje profundo SageMaker AI Neo para optimizar la eficiencia de la predicción de los modelos de inferencia nativos de aprendizaje automático en Tensorflow, Apache MXNet, ONNX y los XGBoost marcos, con el fin de reducir el tamaño y aumentar el rendimiento. PyTorch A continuación, puede descargar el modelo optimizado e instalar el entorno de ejecución de aprendizaje profundo SageMaker AI Neo e implementarlo en sus AWS IoT Greengrass dispositivos para obtener inferencias más rápidas.
En este tutorial se describe cómo utilizar el Consola de administración de AWS para configurar un grupo de Greengrass para ejecutar un ejemplo de inferencia Lambda que reconozca las imágenes de una cámara de forma local, sin enviar datos a la nube. El ejemplo de inferencia obtiene acceso al módulo de cámara en un Raspberry Pi. En este tutorial, se descargará un modelo preempaquetado entrenado por Resnet-50 y optimizado en el compilador de aprendizaje profundo Neo. A continuación, utilice el modelo para realizar la clasificación local de imágenes en su dispositivo. AWS IoT Greengrass
El tutorial contiene los siguientes pasos generales:
1. [Configuración de Raspberry Pi](#config-raspberry-pi-dlc)
1. [Instalar el entorno de ejecución de aprendizaje profundo de Neo](#install-dlr)
1. [Crear una función de Lambda de inferencia.](#ml-console-dlc-create-lambda)
1. [Añadir la función de Lambda al grupo](#ml-console-dlc-config-lambda)
1. [Agregar al grupo un recurso del modelo optimizado para Neo](#ml-console-dlc-add-resources)
1. [Agregar un recurso de dispositivo de cámara al grupo](#ml-console-dlc-add-cam-resource)
1. [Agregar suscripciones al grupo](#ml-console-dlc-add-subscription)
1. [Implementar el grupo](#ml-console-dlc-deploy-group)
1. [Prueba del ejemplo](#ml-console-dlc-test-app)
## Requisitos previos
Para completar este tutorial, se necesita lo siguiente:
+ Raspberry Pi 4 Modelo B o Raspberry Pi 3 Modelo B/B\$1, configurados y configurados para su uso con. AWS IoT Greengrass Para configurar su Raspberry Pi con AWS IoT Greengrass, ejecute el script de [configuración del dispositivo Greengrass](quick-start.md) o asegúrese de haber completado el [módulo 1](https://docs.aws.amazon.com/greengrass/latest/developerguide/module1.html) y el [módulo 2](https://docs.aws.amazon.com/greengrass/latest/developerguide/module2.html) de [Empezar con AWS IoT Greengrass](gg-gs.md).
**nota**
Es posible que la Raspberry Pi requiera una [fuente de alimentación](https://www.raspberrypi.org/documentation/hardware/raspberrypi/power/) de 2,5 A para ejecutar los marcos de aprendizaje profundo que se utilizan normalmente para la clasificación de imágenes. Una fuente de alimentación con una potencia inferior podría provocar el reinicio del dispositivo.
+ [Módulo de cámara Raspberry Pi V2 de 8 megapíxeles, 1080p](https://www.amazon.com/Raspberry-Pi-Camera-Module-Megapixel/dp/B01ER2SKFS). Para obtener información sobre cómo configurar la cámara, consulte [Connecting the camera](https://www.raspberrypi.org/documentation/usage/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 [Empezar con AWS IoT Greengrass](gg-gs.md).
**nota**
Este tutorial utiliza una Raspberry Pi, pero AWS IoT Greengrass es compatible con otras plataformas, como [Intel Atom](#atom-lambda-dlc-config) y [NVIDIA](#jetson-lambda-dlc-config) Jetson. TX2 Si utiliza el ejemplo de Intel Atom, es posible que necesite instalar Python 3.6 en lugar de Python 3.7. Para obtener información sobre cómo configurar el dispositivo para poder instalar el software AWS IoT Greengrass Core, consulte[Configuración de otros dispositivos](setup-filter.other.md).
Para las plataformas de terceros que AWS IoT Greengrass no son compatibles, debe ejecutar la función Lambda en modo no contenerizado. Para ejecutarla en modo no contenerizado, debe ejecutar la función de Lambda como raíz. Para obtener más información, consulte [Consideraciones a la hora de elegir la creación de contenedores de la función de Lambda.](lambda-group-config.md#lambda-containerization-considerations) y [Configuración de la identidad de acceso predeterminada para las funciones de Lambda de un grupo](lambda-group-config.md#lambda-access-identity-groupsettings).
## Paso 1: Configurar el Raspberry Pi
En este paso, va a instalar actualizaciones del sistema operativo Raspbian, el software del módulo de cámara y las dependencias de Python, y va a habilitar la interfaz de la cámara.
Ejecute los siguientes comandos en el terminal de Raspberry Pi.
1. Instale las actualizaciones en Raspbian.
```
sudo apt-get update
sudo apt-get dist-upgrade
```
1. Instale la interfaz `picamera` del módulo de cámara y las demás bibliotecas de Python que sean necesarias para este tutorial.
```
sudo apt-get install -y python3-dev python3-setuptools python3-pip python3-picamera
```
Valide la instalación:
+ Asegúrese de que la instalación de Python 3.7 incluye pip.
```
python3 -m pip
```
Si pip no está instalado, descárguelo del [sitio web de pip](https://pip.pypa.io/en/stable/installing/) y ejecute el siguiente comando.
```
python3 get-pip.py
```
+ Asegúrese de que la versión de Python es 3.7 o superior.
```
python3 --version
```
Si en la salida aparece una versión anterior, ejecute el siguiente comando.
```
sudo apt-get install -y python3.7-dev
```
+ Asegúrese de que Setuptools y Picamera se han instalado correctamente.
```
sudo -u ggc_user bash -c 'python3 -c "import setuptools"'
sudo -u ggc_user bash -c 'python3 -c "import picamera"'
```
Si el resultado no contiene errores, la validación es correcta.
**nota**
Si el ejecutable de Python instalado en el dispositivo es `python3.7`, utilice `python3.7` en lugar de `python3` con los comandos de este tutorial. Asegúrese de que la instalación de pip corresponde a la versión `python3.7` o `python3` correcta para evitar errores de dependencia.
1. Reinicie el Raspberry Pi.
```
sudo reboot
```
1. Abra la herramienta de configuración de Raspberry Pi.
```
sudo raspi-config
```
1. Utilice las teclas de flecha para abrir **Interfacing Options** (Opciones de interfaz) y habilitar la interfaz de la cámara. Si se le solicita, permita que el dispositivo se reinicie.
1. 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 denominada `test.jpg` en el directorio actual y se muestra información sobre la cámara en el terminal de Raspberry Pi.
## Paso 2: Instalar el motor de ejecución de aprendizaje profundo Amazon SageMaker Neo
En este paso, instale el tiempo de ejecución del aprendizaje profundo Neo (DLR) en su Raspberry Pi.
**nota**
Para este tutorial, recomendamos instalar la versión 1.1.0.
1. Inicie sesión en su Raspberry Pi de forma remota.
```
ssh pi@your-device-ip-address
```
1. Abra la documentación del DLR, abra [Installing DLR](https://neo-ai-dlr.readthedocs.io/en/latest/install.html) y busque la URL del wheel para los dispositivos Raspberry Pi. A continuación, siga las instrucciones para instalar DLR en su dispositivo. Por ejemplo, puede utilizar pip:
```
pip3 install rasp3b-wheel-url
```
1. Después de instalar el DLR, valide la siguiente configuración:
+ Asegúrese de que la cuenta `ggc_user` del sistema puede usar la biblioteca del DLR.
```
sudo -u ggc_user bash -c 'python3 -c "import dlr"'
```
+ Asegúrese de que NumPy está instalado.
```
sudo -u ggc_user bash -c 'python3 -c "import numpy"'
```
## Paso 3: Creación de una función de Lambda de inferencia
En este paso, va a crear un paquete de implementación de funciones de Lambda y una función de Lambda. A continuación, publicará una versión de la función y creará un alias.
1. En su equipo, descargue el ejemplo del DLR para Raspberry Pi de [Ejemplos de aprendizaje automático](what-is-gg.md#gg-ml-samples).
1. Descomprima el archivo `dlr-py3-armv7l.tar.gz` descargado.
```
cd path-to-downloaded-sample
tar -xvzf dlr-py3-armv7l.tar.gz
```
El directorio `examples` del paquete de ejemplo extraído contiene el código de la función y las dependencias.
+ `inference.py` es el código de inferencia que se utiliza en este tutorial. Puede usar este código como plantilla para crear su propia función de inferencia.
+ `greengrasssdk` es la versión 1.5.0 del AWS IoT Greengrass Core SDK para Python.
**nota**
Si hay una nueva versión disponible, puede descargarla y actualizar la versión del SDK del paquete de implementación. Para obtener más información, consulte [AWS IoT Greengrass Core SDK for Python](https://github.com/aws/aws-greengrass-core-sdk-python/) on GitHub.
1. Comprima el contenido del directorio `examples` en un archivo llamado `optimizedImageClassification.zip`. Este es el paquete de implementación.
```
cd path-to-downloaded-sample/dlr-py3-armv7l/examples
zip -r optimizedImageClassification.zip .
```
El paquete de implementación contiene el código de la característica y las dependencias. Esto incluye el código que invoca Python, el motor de ejecución de aprendizaje profundo de Neo, APIs para realizar inferencias con los modelos de compilador de aprendizaje profundo de Neo.
**nota**
Asegúrese de que los archivos `.py` y las dependencias se encuentran en la raíz del directorio.
1. Ahora, añada función de Lambda al grupo de Greengrass.
Seleccione **Funciones** de la página de la consola de Lambda y elija **Crear función**.
1. Elija **Autor desde cero** y utilice los siguientes valores para crear su función:
+ En **Function name** (Nombre de la característica), introduzca **optimizedImageClassification**.
+ En **Runtime** (Tiempo de ejecución), elija **Python 3.7**.
En **Permisos**, mantenga la configuración predeterminada. Esto crea un rol de ejecución que otorga permisos Lambda básicos. Esta función no la utiliza. AWS IoT Greengrass
![\[La sección de información básica de la página Create function (Crear función).\]](http://docs.aws.amazon.com/es_es/greengrass/v1/developerguide/images/ml-dlc-inference/gg-dlr-lambda-creation.png)
1. Elija **Crear función**.
Ahora, cargue el paquete de implementación de la función de Lambda y registre el controlador.
1. En la pestaña **Código**, en **Código fuente**, seleccione **Cargar desde**. En el menú desplegable, seleccione un **archivo .zip.**
![\[La carga del menú desplegable con el archivo .zip resaltado.\]](http://docs.aws.amazon.com/es_es/greengrass/v1/developerguide/images/lra-console/upload-deployment-package.png)
1. Elija su paquete de implementación `optimizedImageClassification.zip` y, a continuación, seleccione **Guardar**.
1. En la pestaña **Código** de la función, en **Configuración de tiempo de ejecución**, elija **Editar** y, a continuación, introduzca los siguientes valores.
+ En **Runtime** (Tiempo de ejecución), elija **Python 3.7**.
+ En **Handler (Controlador)**, escriba **inference.handler**.
Seleccione **Save**.
![\[La sección de configuración del tiempo de ejecución con la opción Cargar resaltada.\]](http://docs.aws.amazon.com/es_es/greengrass/v1/developerguide/images/ml-dlc-inference/gg-ml2-lambda-upload.png)
A continuación, publique la primera versión de la función de Lambda. A continuación, cree un [alias para la versión](https://docs.aws.amazon.com/lambda/latest/dg/versioning-aliases.html).
**nota**
Los grupos de Greengrass pueden hacer referencia a una función de Lambda por versión o alias (recomendado). El uso de un alias facilita la gestión de las actualizaciones del código porque no tiene que cambiar la tabla de suscripción o la definición del grupo cuando se actualiza el código de la función. En su lugar, basta con apuntar el alias a la nueva versión de la función.
1. En el menú **Actions**, elija **Publish new version**.
![\[La opción Publish new version (Publicar nueva versión) del menú Actions (Acciones).\]](http://docs.aws.amazon.com/es_es/greengrass/v1/developerguide/images/ml-dlc-inference/gg-ml2-publish-new.png)
1. En **Version description (Descripción de versión)**, escriba **First version** y, a continuación, elija **Publish (Publicar)**.
1. En la página de configuración **optimizedImageClassification: 1**, en el menú **Acciones**, selecciona **Crear alias**.
![\[La opción Create alias (Crear alias) en el menú Actions (Acciones).\]](http://docs.aws.amazon.com/es_es/greengrass/v1/developerguide/images/ml-dlc-inference/gg-ml2-create-alias.png)
1. En la página **Create a new alias**, utilice los valores siguientes:
+ En **Nombre**, escriba **mlTestOpt**.
+ En **Version (Versión)**, escriba **1**.
**nota**
AWS IoT Greengrass **no admite los alias de Lambda para las versiones \$1LATEST.**
1. Seleccione **Crear**.
Ahora, añada función de Lambda al grupo de Greengrass.
## Paso 4: Adición de la función de Lambda al grupo de Greengrass
En este paso, va a agregar la función de Lambda al grupo y a configurar su ciclo de vida.
Primero, añada la función de Lambda al grupo de Greengrass.
1. En el panel de navegación de la AWS IoT consola, en **Administrar**, expanda **los dispositivos Greengrass** y, a continuación, elija **Grupos (V1)**.
1. En la página de configuración de grupos, elija la pestaña **Funciones de Lambda** y seleccione **Añadir**.
1. Elija la **función Lambda** y seleccione. **optimizedImageClassification**
1. En la **versión de la función de Lambda**, elija el alias de la versión que publicó.
A continuación, configure el ciclo de vida de la función de Lambda.
1. En la sección de **Configuración de la función de Lambda**, realice las siguientes actualizaciones.
**nota**
Le recomendamos que ejecute la función de Lambda sin creación de contenedores, a menos que su modelo de negocio lo requiera. Esto permite el acceso a la GPU y la cámara del dispositivo sin necesidad de configurar los recursos del dispositivo. Si ejecuta sin contenedorización, también debe conceder acceso root a las funciones de Lambda AWS IoT Greengrass .
1. **Para ejecutar sin creación de contenedores:**
+ En **Usuario y grupo del sistema**, elija **Another user ID/group ID**. En **ID de usuario del sistema**, introduzca **0**. Para el **ID de grupo del sistema**, introduzca **0**.
Esto permite que la función de Lambda se ejecute como raíz. Para obtener más información sobre cómo ejecutar como raíz, consulte [Configuración de la identidad de acceso predeterminada para las funciones de Lambda de un grupo](lambda-group-config.md#lambda-access-identity-groupsettings).
**sugerencia**
También debe actualizar el archivo `config.json` para conceder acceso raíz a la función de Lambda. Para el procedimiento, consulte [Ejecución de una función de Lambda como raíz](lambda-group-config.md#lambda-running-as-root).
+ Para la **Creación de contenedores de la función de Lambda**, elija **Sin contenedor**.
Para obtener más información sobre la ejecución sin creación de contenedores, consulte [Consideraciones a la hora de elegir la creación de contenedores de la función de Lambda.](lambda-group-config.md#lambda-containerization-considerations).
+ En **Tiempo de espera**, escriba **10 seconds**.
+ En **Ancladas**, elija **Verdadero**
Para obtener más información, consulte [Configuración del ciclo de vida de las funciones de Lambda de Greengrass](lambda-functions.md#lambda-lifecycle).
+ En **Parámetro adicional**, para **Acceso de lectura al directorio /sys**, elija **Activado**.
1. **Para ejecutarlo en modo contenerizado, en su lugar:**
**nota**
No recomendamos ejecutarlo en modo contenerizado a menos que su modelo de negocio lo requiera.
+ En **Usuario y grupo del sistema**, seleccione **Usar grupo predeterminado**.
+ Para la **Creación de contenedores de funciones de Lambda**, elija **Usar grupo por defecto**.
+ En **Límite de memoria**, escriba **1024 MB**.
+ En **Tiempo de espera**, escriba **10 seconds**.
+ En **Ancladas**, elija **Verdadero**
Para obtener más información, consulte [Configuración del ciclo de vida de las funciones de Lambda de Greengrass](lambda-functions.md#lambda-lifecycle).
+ En **Parámetros adicionales**, para **Acceso de lectura al directorio /sys**, elija **Activado**.
1. Elija **Añadir función de Lambda**.
## Paso 5: Añadir un recurso de modelo optimizado para SageMaker IA Neo al grupo Greengrass
En este paso, va a crear un recurso para el modelo de inferencia de ML optimizado y va a cargarlo en un bucket de Amazon S3. A continuación, localice el modelo cargado en Amazon S3 en la AWS IoT Greengrass consola y asocie el recurso recién creado a la función Lambda. Esto permite que la característica acceda a sus recursos en el dispositivo de nodo.
1. En el equipo, desplácese hasta el directorio `resnet50` del paquete de ejemplo en el que descomprimió [Paso 3: Creación de una función de Lambda de inferencia](#ml-console-dlc-create-lambda).
**nota**
Si utiliza el ejemplo de NVIDIA Jetson, debe usar el directorio `resnet18` en el paquete de ejemplo en su lugar. Para obtener más información, consulte [Configuración de una NVIDIA Jetson TX2](#jetson-lambda-dlc-config).
```
cd path-to-downloaded-sample/dlr-py3-armv7l/models/resnet50
```
Este directorio contiene artefactos de modelos compilados previamente para un modelo de clasificación de imágenes entrenado con Resnet-50.
1. Comprima los archivos que están en el directorio `resnet50` en un archivo llamado `resnet50.zip`.
```
zip -r resnet50.zip .
```
1. En la página de configuración de grupo de su AWS IoT Greengrass grupo, elija la pestaña **Recursos**. Vaya a la sección **Machine Learning** y elija **Añadir recurso de machine learning**. En la página **Crear un recurso de machine learning**, en **Nombre del recurso**, escriba **resnet50\$1model**.
1. En **Origen del modelo**, elija **Usar un modelo almacenado en S3, como un modelo optimizado mediante el Compilador de Aprendizaje Profundo**.
1. En **URI de S3**, elija **Browse S3**.
**nota**
Actualmente, los modelos de SageMaker IA optimizados se almacenan automáticamente en Amazon S3. Puede encontrar su modelo optimizado en su bucket de Amazon S3 utilizando esta opción. Para obtener más información sobre la optimización de modelos en SageMaker IA, consulte la [documentación de SageMaker AI Neo](https://docs.aws.amazon.com/sagemaker/latest/dg/neo.html).
1. Elija **Upload a model (Cargar un modelo)**.
1. En la pestaña de la consola de Amazon S3 cargue su archivo zip en un bucket de Amazon S3. Para obtener información, consulte [¿Cómo puedo cargar archivos y carpetas en un bucket de S3?](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/upload-objects.html) en la *Guía del usuario de Amazon Simple Storage Service*.
**nota**
El nombre del bucket debe contener la cadena **greengrass**. Elija un nombre único (como **greengrass-dlr-bucket-*user-id*-*epoch-time***). No utilice un punto (`.`) en el nombre del bucket.
1. En la pestaña de la AWS IoT Greengrass consola, busca y elige tu bucket de Amazon S3. Localice y cargue el archivo `resnet50.zip` y elija **Select (Seleccionar)**. Es posible que tenga que actualizar la página para actualizar la lista de buckets y archivos disponibles.
1. En **Ruta de destino**, escriba **/ml\$1model**.
![\[La ruta de destino actualizada.\]](http://docs.aws.amazon.com/es_es/greengrass/v1/developerguide/images/ml-dlc-inference/local-path.png)
Este es el destino para el modelo local en el espacio de nombres del tiempo de ejecución de Lambda. Al implementar el grupo, AWS IoT Greengrass recupera el paquete del modelo fuente y, a continuación, extrae el contenido al directorio especificado.
**nota**
Le recomendamos encarecidamente que utilice la ruta exacta proporcionada por su ruta local. El uso de una ruta de destino de modelo local distinta en este paso hace que algunos comandos de la solución de problemas ofrecidos en este tutorial sean inexactos. Si utiliza una ruta diferente, debe configurar una variable de entorno `MODEL_PATH` que utilice la ruta exacta que proporcione aquí. Para obtener información sobre las variables de entorno, consulte [Variables de entorno de AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/env_variables.html).
1. **Si se ejecuta en modo contenerizado:**
1. En **Propietario del grupo del sistema y permisos de acceso a archivos**, seleccione **Especificar grupo del sistema y permisos**.
1. Elija **Acceso de solo lectura** y, a continuación, elija **Agregar recurso**.
## Paso 6: Agregar un recurso de dispositivo de cámara al grupo de Greengrass
En este paso, va a crear un recurso para el módulo de cámara y va a asociarlo con la función de Lambda. De este modo, la función de Lambda podrá acceder al recurso del dispositivo del núcleo.
**nota**
Si se ejecuta en modo no contenerizado, AWS IoT Greengrass puede acceder a la GPU y a la cámara del dispositivo sin configurar este recurso del dispositivo.
1. En la página de configuración del grupo, elija la pestaña **Recursos**.
1. En la pestaña **Recursos locales**, elija **Añadir recurso local**.
1. En la página **Añadir un recurso local**, utilice los siguientes valores:
+ En **Nombre del recurso**, escriba **videoCoreSharedMemory**.
+ En **Tipo de recurso**, elija **Dispositivo**.
+ En **Ruta del dispositivo local**, escriba **/dev/vcsm**.
La ruta del dispositivo es la ruta local completa del recurso del dispositivo. Esta ruta solo puede hacer referencia a un dispositivo de carácter o un dispositivo de bloques situado bajo `/dev`.
+ En **Propietario del grupo del sistema y permisos de acceso a archivos**, seleccione **Añadir automáticamente permisos del sistema de archivos del grupo del sistema propietario del recurso**.
La opción **Group owner file access permission (Permiso de acceso a los archivos del propietario del grupo)** le permite conceder al proceso de Lambda permisos de acceso a archivos adicionales. Para obtener más información, consulte [Group owner file access permission (Permiso de acceso a los archivos del propietario del grupo)](access-local-resources.md#lra-group-owner).
1. En la parte inferior de la página, elija **Añadir recurso**.
1. En la pestaña **Recursos**, cree otro recurso local seleccionando **Agregar** y use los siguientes valores:
+ En **Nombre del recurso**, escriba **videoCoreInterface**.
+ En **Tipo de recurso**, elija **Dispositivo**.
+ En **Ruta del dispositivo local**, escriba **/dev/vchiq**.
+ En **Propietario del grupo del sistema y permisos de acceso a archivos**, seleccione **Añadir automáticamente permisos del sistema de archivos del grupo del sistema propietario del recurso**.
1. Seleccione **Add resource** (Añadir recurso).
## Paso 7: Agregar suscripciones al grupo de Greengrass
En este paso, va a agregar suscripciones al grupo. Estas suscripciones permiten a la función Lambda enviar los resultados de las predicciones AWS IoT publicándolos en un tema de MQTT.
1. En la página de configuración del grupo, elija la pestaña **Suscripciones** y, a continuación, elija **Añadir suscripción**.
1. En la página **Crear una suscripción**, configure el origen y el destino de la siguiente manera:
1. En **Tipo de fuente**, elija **Función Lambda** y, a continuación, elija. **optimizedImageClassification**
1. En **Tipo de destino**, elija **Servicio** y, a continuación, **Nube de IoT**.
1. En **Filtro por temas**, introduzca **/resnet-50/predictions** y, a continuación, seleccione **Crear suscripción.**
1. Añadir una segunda suscripción. Seleccione la pestaña **Suscripciones**, elija **Agregar suscripción** y configure el origen y el destino de la siguiente manera:
1. En la sección **Tipo de origen**, elija **Servicios** y luego elija **Nube de IoT**.
1. En **Tipo de destino**, elija **Función Lambda** y, a continuación, elija. **optimizedImageClassification**
1. En **Filtro por temas**, introduzca **/resnet-50/test** y, a continuación, seleccione **Crear suscripción.**
## Paso 8: Implementar el grupo de Greengrass
En este paso, va a implementar la versión actual de la definición del grupo en el dispositivo del núcleo de Greengrass. La definición contiene la función de Lambda, los recursos y las configuraciones de suscripciones que ha añadido.
1. Asegúrese de que el AWS IoT Greengrass núcleo esté funcionando. Ejecute los siguientes comandos en el terminal de Raspberry Pi según sea necesario.
1. Para comprobar si el daemon está en ejecución:
```
ps aux | grep -E 'greengrass.*daemon'
```
Si la salida contiene una entrada `root` para `/greengrass/ggc/packages/latest-core-version/bin/daemon`, el daemon está en ejecución.
1. Inicio de daemon:
```
cd /greengrass/ggc/core/
sudo ./greengrassd start
```
1. En la página de configuración de grupo, elija **Implementar**.
1. En la pestaña **Funciones de Lambda**, seleccione **Detector IP** y elija **Editar**.
1. En el cuadro de diálogo **Editar configuración del detector IP**, seleccione **Detectar y anular automáticamente los puntos de conexión del agente MQTT** y elija **Guardar**.
Esto permite a los dispositivos adquirir automáticamente la información de conexión del dispositivo principal, como la dirección IP, el DNS y el número de puerto. Se recomienda la detección automática, pero AWS IoT Greengrass también admite puntos finales especificados manualmente. Solo se le solicitará el método de detección la primera vez que se implemente el grupo.
**nota**
Si se le solicita, conceda permiso para crear el [rol de servicio de Greengrass](service-role.md) y asócielo al suyo Cuenta de AWS en el actual. Región de AWS Este rol le permite acceder AWS IoT Greengrass a sus recursos en los AWS servicios.
En la página **Deployments** (Implementaciones), se muestra la marca temporal, el ID de versión y el estado de la implementación. Una vez terminada, la implementación debería mostrar el estado **Completado**.
Para obtener más información sobre las implementaciones, consulte [Implemente AWS IoT Greengrass grupos en un AWS IoT Greengrass núcleo](deployments.md). Para obtener ayuda sobre la resolución de problemas, consulte [Solución de problemas AWS IoT Greengrass](gg-troubleshooting.md).
## Prueba del ejemplo de inferencia
Ahora puede verificar si la implementación se ha configurado correctamente. Para probarlo, suscríbase al tema `/resnet-50/predictions` y publique cualquier mensaje en el tema `/resnet-50/test`. Esto activa la función de Lambda para que tome una foto con su Raspberry Pi y realice la inferencia en la imagen que capture.
**nota**
Si utiliza el ejemplo de NVIDIA Jetson, no olvide utilizar los temas `resnet-18/predictions`y `resnet-18/test` en su lugar.
**nota**
Si se conecta un monitor al Raspberry Pi, la imagen en directo de la cámara se muestra en una ventana de vista previa.
1. En la página de inicio de la AWS IoT consola, en **Prueba**, elija el **cliente de prueba MQTT**.
1. Para **Suscripciones**, seleccione **Suscribirse a un tema**. Use los siguientes valores. No cambie los valores predeterminados de las opciones restantes.
+ Para **Subscription topic (Tema de suscripción)**, escriba **/resnet-50/predictions**.
+ En **Configuración adicional**, para la **Visualización de la carga útil MQTT**, seleccione **Visualizar las cargas útiles como cadenas**.
1. Elija **Subscribe**.
1. Elija **Publicar en un tema**, introduzca **/resnet-50/test** como **Nombre del tema** y seleccione **Publicar**.
1. Si la prueba se realiza correctamente, el mensaje publicado hace que la cámara de Raspberry Pi capture una imagen. Un mensaje de la función de Lambda aparece en la parte inferior de la página. Este mensaje contiene el resultado de predicción de la imagen, con este formato: nombre de la clase predicha, probabilidad y uso máximo de memoria.
## Configuración de Intel Atom
Para ejecutar este tutorial en un dispositivo Intel Atom, debe proporcionar imágenes de origen, configurar la función de Lambda y agregar otro recurso del dispositivo local. Para utilizar la GPU como inferencia, compruebe que el siguiente software está instalado en el dispositivo:
+ OpenCL versión 1.0 o posterior
+ Python 3.7 y pip
+ [NumPy](https://pypi.org/project/numpy/)
+ [OpenCV en Wheels](https://pypi.org/project/opencv-python/)
1. Descargue imágenes PNG o JPG estáticas para la función de Lambda que se va a utilizar para la clasificación de imágenes. El ejemplo funciona mejor con archivos de imágenes pequeños.
Guarde los archivos de imágenes en el directorio que contiene el archivo `inference.py` (o en un subdirectorio de este directorio). Se encuentra en el paquete de implementación de la función de Lambda que cargó en [Paso 3: Creación de una función de Lambda de inferencia](#ml-console-dlc-create-lambda).
**nota**
Si lo estás usando AWS DeepLens, puedes usar la cámara integrada o montar tu propia cámara para realizar inferencias a partir de imágenes capturadas en lugar de imágenes estáticas. Sin embargo, le recomendamos encarecidamente que empiece primero con imágenes estáticas.
Si utiliza una cámara, asegúrese de que el paquete `awscam` de APT esté instalado y actualizado. Para obtener más información, consulte [Actualización del dispositivo AWS DeepLens](https://docs.aws.amazon.com/deeplens/latest/dg/deeplens-manual-updates.html) en la *Guía para desarrolladores de AWS DeepLens *.
1. Edite la configuración de la función de Lambda. Siga el procedimiento indicado en [Paso 4: Adición de la función de Lambda al grupo de Greengrass](#ml-console-dlc-config-lambda).
**nota**
Le recomendamos que ejecute la función de Lambda sin creación de contenedores, a menos que su modelo de negocio lo requiera. Esto permite el acceso a la GPU y la cámara del dispositivo sin necesidad de configurar los recursos del dispositivo. Si ejecuta sin contenedorización, también debe conceder acceso root a las funciones de Lambda AWS IoT Greengrass .
1. **Para ejecutar sin creación de contenedores:**
+ En **Usuario y grupo del sistema**, elija **Another user ID/group ID**. En **ID de usuario del sistema**, introduzca **0**. Para el **ID de grupo del sistema**, introduzca **0**.
Esto permite que la función de Lambda se ejecute como raíz. Para obtener más información sobre cómo ejecutar como raíz, consulte [Configuración de la identidad de acceso predeterminada para las funciones de Lambda de un grupo](lambda-group-config.md#lambda-access-identity-groupsettings).
**sugerencia**
También debe actualizar el archivo `config.json` para conceder acceso raíz a la función de Lambda. Para el procedimiento, consulte [Ejecución de una función de Lambda como raíz](lambda-group-config.md#lambda-running-as-root).
+ Para la **Creación de contenedores de la función de Lambda**, elija **Sin contenedor**.
Para obtener más información sobre la ejecución sin creación de contenedores, consulte [Consideraciones a la hora de elegir la creación de contenedores de la función de Lambda.](lambda-group-config.md#lambda-containerization-considerations).
+ Aumente el valor de **Timeout (Tiempo de espera)** a 2 minutos. De este modo, se asegurará de que la solicitud no supere el tiempo de inactividad demasiado pronto. La configuración tarda unos minutos en ejecutar la inferencia.
+ En **Ancladas**, elija **Verdadero**
+ En **Parámetros adicionales**, para **Acceso de lectura al directorio /sys**, elija **Activado**.
1. **Para ejecutarlo en modo contenerizado, en su lugar:**
**nota**
No recomendamos ejecutarlo en modo contenerizado a menos que su modelo de negocio lo requiera.
+ Aumente el valor de **Memory limit (Límite de memoria)** a 3000 MB.
+ Aumente el valor de **Timeout (Tiempo de espera)** a 2 minutos. De este modo, se asegurará de que la solicitud no supere el tiempo de inactividad demasiado pronto. La configuración tarda unos minutos en ejecutar la inferencia.
+ En **Ancladas**, elija **Verdadero**
+ En **Parámetros adicionales**, para **Acceso de lectura al directorio /sys**, elija **Activado**.
1. Agregar al grupo un recurso del modelo optimizado para Neo Cargue los recursos del modelo en el directorio `resnet50` del paquete de ejemplo en el que descomprimió [Paso 3: Creación de una función de Lambda de inferencia](#ml-console-dlc-create-lambda). Este directorio contiene artefactos de modelos compilados previamente para un modelo de clasificación de imágenes entrenado con Resnet-50. Utilice el procedimiento que se describe en [Paso 5: Añadir un recurso de modelo optimizado para SageMaker IA Neo al grupo Greengrass](#ml-console-dlc-add-resources) con las siguientes actualizaciones.
+ Comprima los archivos que están en el directorio `resnet50` en un archivo llamado `resnet50.zip`.
+ En la página **Create a machine learning resource (Crear un recurso de aprendizaje automático)**, en **Resource name (Nombre del recurso)**, escriba **resnet50\$1model**.
+ Cargue el archivo `resnet50.zip`.
1. **Si se ejecuta en modo contenerizado**, añada el recurso de dispositivo local necesario para conceder acceso a su GPU de dispositivo.
**nota**
Si se ejecuta en modo no contenerizado, AWS IoT Greengrass podrá acceder a la GPU del dispositivo sin necesidad de configurar los recursos del dispositivo.
1. En la página de configuración del grupo, elija la pestaña **Recursos**.
1. En la sección **Recursos locales**, elija **Añadir recurso local**.
1. Defina el recurso:
+ En **Nombre del recurso**, escriba **renderD128**.
+ En **Tipo de recurso**, elija **Dispositivo**.
+ En **Ruta del dispositivo local**, escriba **/dev/dri/renderD128**.
+ En **Propietario del grupo del sistema y permisos de acceso a archivos**, seleccione **Añadir automáticamente permisos del sistema de archivos del grupo del sistema propietario del recurso**.
## Configuración de una NVIDIA Jetson TX2
Para ejecutar este tutorial en una impresora Jetson de NVIDIA TX2, proporcione las imágenes de origen, configure la función Lambda y añada más recursos del dispositivo local.
1. Asegúrese de que su dispositivo Jetson esté configurado para poder instalar el software AWS IoT Greengrass Core y utilizar la GPU para realizar inferencias. Para obtener más información sobre la configuración del proyecto, consulte [Configuración de otros dispositivos](setup-filter.other.md). Para usar la GPU como inferencia en una NVIDIA Jetson TX2, debes instalar CUDA 10.0 y cuDNN 7.0 en tu dispositivo al crear imágenes de tu placa con Jetpack 4.3.
1. Descargue imágenes PNG o JPG estáticas para la función de Lambda que se va a utilizar para la clasificación de imágenes. El ejemplo funciona mejor con archivos de imágenes pequeños.
Guarde los archivos de la imagen en la carpeta que contiene el archivo `inference.py`. También puede guardarlos en un subdirectorio de esta carpeta. Este directorio está en el paquete de implementación de funciones de Lambda que ha cargado en [Paso 3: Creación de una función de Lambda de inferencia](#ml-console-dlc-create-lambda).
**nota**
En su lugar, puede elegir instrumentar una cámara en la placa Jetson para capturar las imágenes de origen. Sin embargo, le recomendamos encarecidamente que empiece primero con imágenes estáticas.
1. Edite la configuración de la función de Lambda. Siga el procedimiento indicado en [Paso 4: Adición de la función de Lambda al grupo de Greengrass](#ml-console-dlc-config-lambda).
**nota**
Le recomendamos que ejecute la función de Lambda sin creación de contenedores, a menos que su modelo de negocio lo requiera. Esto permite el acceso a la GPU y la cámara del dispositivo sin necesidad de configurar los recursos del dispositivo. Si ejecuta sin contenedorización, también debe conceder acceso root a las funciones de Lambda AWS IoT Greengrass .
1. **Para ejecutar sin creación de contenedores:**
+ En **Ejecutar como**, elija **Another user ID/group ID**. En **UID**, escriba **0**. En **GUID**, escriba **0**.
Esto permite que la función de Lambda se ejecute como raíz. Para obtener más información sobre cómo ejecutar como raíz, consulte [Configuración de la identidad de acceso predeterminada para las funciones de Lambda de un grupo](lambda-group-config.md#lambda-access-identity-groupsettings).
**sugerencia**
También debe actualizar el archivo `config.json` para conceder acceso raíz a la función de Lambda. Para el procedimiento, consulte [Ejecución de una función de Lambda como raíz](lambda-group-config.md#lambda-running-as-root).
+ Para la **Creación de contenedores de la función de Lambda**, elija **Sin contenedor**.
Para obtener más información sobre la ejecución sin creación de contenedores, consulte [Consideraciones a la hora de elegir la creación de contenedores de la función de Lambda.](lambda-group-config.md#lambda-containerization-considerations).
+ Aumente el valor de **Timeout (Tiempo de espera)** a 5 minutos. De este modo, se asegurará de que la solicitud no supere el tiempo de inactividad demasiado pronto. La configuración tarda unos minutos en ejecutar la inferencia.
+ En **Ancladas**, elija **Verdadero**
+ En **Parámetros adicionales**, para **Acceso de lectura al directorio /sys**, elija **Activado**.
1. **Para ejecutarlo en modo contenerizado, en su lugar:**
**nota**
No recomendamos ejecutarlo en modo contenerizado a menos que su modelo de negocio lo requiera.
+ Aumente el valor de **Memory limit (Límite de memoria)**. Para utilizar el modelo proporcionado en modo de GPU, utilice 2000 MB.
+ Aumente el valor de **Timeout (Tiempo de espera)** a 5 minutos. De este modo, se asegurará de que la solicitud no supere el tiempo de inactividad demasiado pronto. La configuración tarda unos minutos en ejecutar la inferencia.
+ En **Ancladas**, elija **Verdadero**
+ En **Parámetros adicionales**, para **Acceso de lectura al directorio /sys**, elija **Activado**.
1. Agregar al grupo un recurso del modelo optimizado para Neo Cargue los recursos del modelo en el directorio `resnet18` del paquete de ejemplo en el que descomprimió [Paso 3: Creación de una función de Lambda de inferencia](#ml-console-dlc-create-lambda). Este directorio contiene artefactos precompilados de un modelo de clasificación de imágenes entrenado con Resnet-18. Utilice el procedimiento que se describe en [Paso 5: Añadir un recurso de modelo optimizado para SageMaker IA Neo al grupo Greengrass](#ml-console-dlc-add-resources) con las siguientes actualizaciones.
+ Comprima los archivos que están en el directorio `resnet18` en un archivo llamado `resnet18.zip`.
+ En la página **Create a machine learning resource (Crear un recurso de aprendizaje automático)**, en **Resource name (Nombre del recurso)**, escriba **resnet18\$1model**.
+ Cargue el archivo `resnet18.zip`.
1. **Si se ejecuta en modo contenerizado**, añada los recursos de dispositivos locales necesarios para conceder acceso a su GPU de dispositivo.
**nota**
Si se ejecuta en modo no contenerizado, AWS IoT Greengrass podrá acceder a la GPU del dispositivo sin necesidad de configurar los recursos del dispositivo.
1. En la página de configuración del grupo, elija la pestaña **Recursos**.
1. En la sección **Recursos locales**, elija **Añadir recurso local**.
1. Defina cada recurso:
+ En **Resource name** (Nombre de recurso) y **Device path** (Ruta del dispositivo), utilice los valores en la siguiente tabla. Cree un recurso de dispositivo para cada fila de la tabla.
+ En **Tipo de recurso**, elija **Dispositivo**.
+ En **Propietario del grupo del sistema y permisos de acceso a archivos**, seleccione **Añadir automáticamente permisos del sistema de archivos del grupo del sistema propietario del recurso**.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/greengrass/v1/developerguide/ml-dlc-console.html)
1. **Si se ejecuta en modo contenerizado**, añada el siguiente recurso de volumen local para conceder acceso a la cámara de su dispositivo. Siga el procedimiento indicado en [Paso 5: Añadir un recurso de modelo optimizado para SageMaker IA Neo al grupo Greengrass](#ml-console-dlc-add-resources).
**nota**
Si se ejecuta en modo no contenerizado, AWS IoT Greengrass puede acceder a la cámara de su dispositivo sin configurar los recursos del dispositivo.
+ En **Resource type (Tipo de recurso)**, elija **Device (Dispositivo)**.
+ En **Propietario del grupo del sistema y permisos de acceso a archivos**, seleccione **Añadir automáticamente permisos del sistema de archivos del grupo del sistema propietario del recurso**.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/greengrass/v1/developerguide/ml-dlc-console.html)
1. Actualice las suscripciones del grupo para utilizar el directorio correcto. Utilice el procedimiento que se describe en [Paso 7: Agregar suscripciones al grupo de Greengrass](#ml-console-dlc-add-subscription) con las siguientes actualizaciones.
+ En el primer filtro de tema, escriba **/resnet-18/predictions**.
+ En el segundo filtro de tema, escriba **/resnet-18/test**.
1. Actualice las suscripciones de prueba para utilizar el directorio correcto. Utilice el procedimiento que se describe en [Prueba del ejemplo de inferencia](#ml-console-dlc-test-app) con las siguientes actualizaciones.
+ Para **Suscripciones**, seleccione **Suscribirse a un tema**. Para **Subscription topic (Tema de suscripción)**, escriba **/resnet-18/predictions**.
+ En la página `/resnet-18/predictions`, especifique el tema `/resnet-18/test` en el que se va a publicar.
## Solución de problemas de inferencia XML AWS IoT Greengrass
Si la prueba no se realiza correctamente, puede seguir estos pasos de solución de problemas. Ejecute los comandos en el terminal de Raspberry Pi.
### Comprobación de los registros de error
1. Cambie al usuario raíz y vaya al directorio `log`. El acceso a AWS IoT Greengrass los registros requiere permisos de root.
```
sudo su
cd /greengrass/ggc/var/log
```
1. Compruebe `runtime.log` para ver si hay errores.
```
cat system/runtime.log | grep 'ERROR'
```
También puede consultar el registro de la función de Lambda definida por el usuario para ver si hay errores:
```
cat user/your-region/your-account-id/lambda-function-name.log | grep 'ERROR'
```
Para obtener más información, consulte [Solución de problemas con los registros](gg-troubleshooting.md#troubleshooting-logs).
### Verificación de que la función de Lambda se ha implementado correctamente
1. Muestre el contenido de la Lambda implementada en el directorio de `/lambda`. Reemplace los valores de los marcadores de posición antes de ejecutar el comando .
```
cd /greengrass/ggc/deployment/lambda/arn:aws:lambda:region:account:function:function-name:function-version
ls -la
```
1. Compruebe que el directorio contiene el mismo contenido que el paquete de implementación `optimizedImageClassification.zip` que cargó en el [Paso 3: Creación de una función de Lambda de inferencia](#ml-console-dlc-create-lambda).
Asegúrese también de que los archivos `.py` y las dependencias se encuentran en la raíz del directorio.
### Verificación de 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 de tiempo de ejecución de Lambda.
1. Entre en el espacio de nombres del tiempo de ejecución de Lambda. Asegúrese de reemplazar el *pid* valor del marcador de posición antes de ejecutar el comando.
**nota**
Este directorio y su contenido se encuentran en el espacio de nombres del tiempo de ejecución de Lambda, por lo que no son visibles en un espacio de nombres de Linux normal.
```
sudo nsenter -t pid -m /bin/bash
```
1. Muestre el contenido del directorio local que ha especificado para el recurso de machine learning.
**nota**
Si su ruta de recurso de machine learning es distinta de `ml_model`, debe sustituirla aquí.
```
cd /ml_model
ls -ls
```
Debería ver los siguientes archivos:
```
56 -rw-r--r-- 1 ggc_user ggc_group 56703 Oct 29 20:07 model.json
196152 -rw-r--r-- 1 ggc_user ggc_group 200855043 Oct 29 20:08 model.params
256 -rw-r--r-- 1 ggc_user ggc_group 261848 Oct 29 20:07 model.so
32 -rw-r--r-- 1 ggc_user ggc_group 30564 Oct 29 20:08 synset.txt
```
### La función de Lambda no puede encontrar `/dev/dri/renderD128`
Esto puede ocurrir si OpenCL no puede conectarse a los dispositivos de GPU que necesita. Debe crear los recursos de dispositivos para los dispositivos necesarios para su función de Lambda.
## Siguientes pasos
A continuación, explore otros modelos optimizados. Para obtener más información, consulte la [documentación de SageMaker AI Neo](https://docs.aws.amazon.com/sagemaker/latest/dg/neo.html).