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. # Exportar flujos de datos a la Nube de AWS (consola) En este tutorial, se muestra cómo usar la AWS IoT consola para configurar e implementar un AWS IoT Greengrass grupo con el administrador de transmisiones activado. El grupo contiene una función de Lambda definida por el usuario que escribe en una secuencia en el administrador de flujos, que luego se exporta automáticamente a la Nube de AWS. El administrador de flujos hace que la asimilación, el procesamiento y la exportación de flujos de datos de gran volumen sea más eficiente y fiable. En este tutorial, va a crear una función de Lambda de `TransferStream` que consume datos de IoT. La función Lambda usa el SDK AWS IoT Greengrass principal para crear una transmisión en el administrador de transmisiones y, a continuación, leer y escribir en ella. El administrador de flujos exporta la secuencia al Flujo de datos Kinesis. En el siguiente diagrama se muestra este flujo de trabajo. ![\[Diagrama del flujo de trabajo de administración de secuencias.\]](http://docs.aws.amazon.com/es_es/greengrass/v1/developerguide/images/stream-manager-scenario.png) El objetivo de este tutorial es mostrar cómo las funciones Lambda definidas por el usuario utilizan `StreamManagerClient` el objeto del SDK principal para interactuar con AWS IoT Greengrass el administrador de transmisiones. Para simplificar, la función de Lambda que va a crear en este tutorial genera datos de dispositivos simulados. ## Requisitos previos Para completar este tutorial, se necesita lo siguiente: + Un grupo de Greengrass y un núcleo de Greengrass (versión 1.10 o posterior). Para obtener información acerca de cómo crear un núcleo y un grupo de Greengrass, consulte [Empezar con AWS IoT Greengrass](gg-gs.md). El tutorial de introducción también incluye los pasos para instalar el software AWS IoT Greengrass principal. **nota** El administrador de transmisiones no es compatible con las OpenWrt distribuciones. + Java 8 Runtime (JDK 8) instalado en el dispositivo principal. + Para distribuciones basadas en Debian (incluido Raspbian) o distribuciones basadas en Ubuntu, ejecute el siguiente comando: ``` sudo apt install openjdk-8-jdk ``` + Para distribuciones basadas en Red Hat (incluido Amazon Linux), ejecute el siguiente comando: ``` sudo yum install java-1.8.0-openjdk ``` Para obtener más información, consulte [ How to download and install prebuilt OpenJDK packages (Cómo descargar e instalar paquetes OpenJDK preconfigurados)](https://openjdk.java.net/install/) en la documentación de OpenJDK. + AWS IoT Greengrass Core SDK para Python v1.5.0 o posterior. Para usar `StreamManagerClient` en el SDK de AWS IoT Greengrass Core para Python, debe: + Instalar Python 3.7 o versiones posteriores en el dispositivo principal. + Incluya el SDK y sus dependencias en su paquete de implementación de la función de Lambda. Se incluyen las instrucciones en este tutorial. **sugerencia** Puede usar `StreamManagerClient` con Java o NodeJS. Para ver código de ejemplo, consulte [AWS IoT Greengrass Core SDK for Java](https://github.com/aws/aws-greengrass-core-sdk-java/blob/master/samples/StreamManagerKinesis/src/main/java/com/amazonaws/greengrass/examples/StreamManagerKinesis.java) y [AWS IoT Greengrass Core SDK for Node.js](https://github.com/aws/aws-greengrass-core-sdk-js/blob/master/greengrassExamples/StreamManagerKinesis/index.js) en GitHub. + Una transmisión de destino denominada **MyKinesisStream** creada en Amazon Kinesis Data Streams al Región de AWS igual que su grupo de Greengrass. Para obtener más información, consulte [Crear un flujo](https://docs.aws.amazon.com/streams/latest/dev/fundamental-stream.html#create-stream) en la *Guía para desarrolladores de Amazon Kinesis*. **nota** En este tutorial, el administrador de flujos exporta datos a Kinesis Data Streams, lo que deriva en cargos a su Cuenta de AWS. Para obtener información acerca de los precios, consulte [Precios de Kinesis Data Streams](https://aws.amazon.com/kinesis/data-streams/pricing/). Para no incurrir en gastos, puede ejecutar este tutorial sin crear una secuencia de datos Kinesis. En este caso, compruebe los registros para ver si el administrador de flujos intentó exportar la secuencia al flujo de datos Kinesis. + Una política de IAM agregada al [Rol de grupo de Greengrass](group-role.md) que permita la acción de `kinesis:PutRecords` en el flujo de datos de destino, tal y como se muestra en el siguiente ejemplo: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "kinesis:PutRecords" ], "Resource": [ "arn:aws:kinesis:us-east-1:123456789012:stream/MyKinesisStream" ] } ] } ``` ------ El tutorial contiene los siguientes pasos generales: 1. [Creación de un paquete de implementación de la función de Lambda](#stream-manager-console-create-deployment-package) 1. [Crear una función de Lambda](#stream-manager-console-create-function) 1. [Agregar una función al grupo](#stream-manager-console-create-gg-function) 1. [Habilitar el administrador de secuencias](#stream-manager-console-enable-stream-manager) 1. [Configurar el registro local](#stream-manager-console-configure-logging) 1. [Implementar el grupo](#stream-manager-console-create-deployment) 1. [Pruebe la aplicación](#stream-manager-console-test-application) Completar el tutorial debería tomarle aproximadamente 20 minutos. ## Paso 1: Creación de un paquete de implementación de la función de Lambda En este paso, va a crear un paquete de implementación de funciones de Lambda que contiene código de función y dependencias de Python. Cargará este paquete más adelante cuando cree la función de Lambda en AWS Lambda. La función Lambda usa el SDK AWS IoT Greengrass principal para crear transmisiones locales e interactuar con ellas. **nota** Sus funciones de Lambda definidas por el usuario deben utilizar el [SDK de AWS IoT Greengrass Core](lambda-functions.md#lambda-sdks-core) para interactuar con el administrador de flujos. Para obtener más información sobre los requisitos del administrador de secuencias de Greengrass, consulte [Requisitos del administrador de secuencias de Greengrass](stream-manager.md#stream-manager-requirements). 1. Descargue la versión 1.5.0 o posterior del [SDK de AWS IoT Greengrass Core para Python](lambda-functions.md#lambda-sdks-core). 1. Descomprima el paquete descargado para obtener el SDK. El SDK es la carpeta `greengrasssdk`. 1. Instale dependencias de paquetes para incluirlas con el SDK en su paquete de implementación de funciones de Lambda. 1. Vaya al directorio de SDK que contiene el archivo de `requirements.txt`. Este archivo registra las dependencias. 1. Instale las dependencias del SDK. Por ejemplo, ejecute el siguiente comando de `pip` para instalarlas en el directorio actual: ``` pip install --target . -r requirements.txt ``` 1. Guarde la siguiente función de código de Python en un archivo local llamado "`transfer_stream.py`". **sugerencia** Para ver un ejemplo de código que utilice Java y Nodejs, consulte AWS IoT Greengrass Core [SDK for Java [AWS IoT Greengrass y Core SDK](https://github.com/aws/aws-greengrass-core-sdk-js/blob/master/greengrassExamples/StreamManagerKinesis/index.js) for](https://github.com/aws/aws-greengrass-core-sdk-java/blob/master/samples/StreamManagerKinesis/src/main/java/com/amazonaws/greengrass/examples/StreamManagerKinesis.java) Node.js en. GitHub ``` import asyncio import logging import random import time from greengrasssdk.stream_manager import ( ExportDefinition, KinesisConfig, MessageStreamDefinition, ReadMessagesOptions, ResourceNotFoundException, StrategyOnFull, StreamManagerClient, ) # This example creates a local stream named "SomeStream". # It starts writing data into that stream and then stream manager automatically exports # the data to a customer-created Kinesis data stream named "MyKinesisStream". # This example runs forever until the program is stopped. # The size of the local stream on disk will not exceed the default (which is 256 MB). # Any data appended after the stream reaches the size limit continues to be appended, and # stream manager deletes the oldest data until the total stream size is back under 256 MB. # The Kinesis data stream in the cloud has no such bound, so all the data from this script is # uploaded to Kinesis and you will be charged for that usage. def main(logger): try: stream_name = "SomeStream" kinesis_stream_name = "MyKinesisStream" # Create a client for the StreamManager client = StreamManagerClient() # Try deleting the stream (if it exists) so that we have a fresh start try: client.delete_message_stream(stream_name=stream_name) except ResourceNotFoundException: pass exports = ExportDefinition( kinesis=[KinesisConfig(identifier="KinesisExport" + stream_name, kinesis_stream_name=kinesis_stream_name)] ) client.create_message_stream( MessageStreamDefinition( name=stream_name, strategy_on_full=StrategyOnFull.OverwriteOldestData, export_definition=exports ) ) # Append two messages and print their sequence numbers logger.info( "Successfully appended message to stream with sequence number %d", client.append_message(stream_name, "ABCDEFGHIJKLMNO".encode("utf-8")), ) logger.info( "Successfully appended message to stream with sequence number %d", client.append_message(stream_name, "PQRSTUVWXYZ".encode("utf-8")), ) # Try reading the two messages we just appended and print them out logger.info( "Successfully read 2 messages: %s", client.read_messages(stream_name, ReadMessagesOptions(min_message_count=2, read_timeout_millis=1000)), ) logger.info("Now going to start writing random integers between 0 and 1000 to the stream") # Now start putting in random data between 0 and 1000 to emulate device sensor input while True: logger.debug("Appending new random integer to stream") client.append_message(stream_name, random.randint(0, 1000).to_bytes(length=4, signed=True, byteorder="big")) time.sleep(1) except asyncio.TimeoutError: logger.exception("Timed out while executing") except Exception: logger.exception("Exception while running") def function_handler(event, context): return logging.basicConfig(level=logging.INFO) # Start up this sample code main(logger=logging.getLogger()) ``` 1. Comprima en un archivo ZIP los siguientes elementos en un archivo denominado "`transfer_stream_python.zip`". Este es el paquete de implementación de la función de Lambda. + **transfer\$1stream.py**. Lógica de la aplicación. + **greengrasssdk**. Biblioteca necesaria para las funciones de Lambda Greengrass de Python que publican mensajes MQTT. Las [operaciones de Stream Manager](work-with-streams.md) están disponibles en la versión 1.5.0 o posterior del AWS IoT Greengrass Core SDK para Python. + Las dependencias que instalaste para el SDK AWS IoT Greengrass principal para Python (por ejemplo, los `cbor2` directorios). Al crear el archivo de `zip`, incluya solo estos elementos, no la carpeta que los contiene. ## Paso 2: creación de una función de Lambda En este paso, utilizará la AWS Lambda consola para crear una función Lambda y configurarla para que utilice su paquete de despliegue. A continuación, publicará una versión de la característica y creará un alias. 1. Primero, cree la función de Lambda. 1. En Consola de administración de AWS, elija **Servicios** y abra la AWS Lambda consola. 1. Elija **Crear función**, y, a continuación, elija **Autor desde cero**. 1. En la sección **Basic information (Información básica)**, utilice los siguientes valores: + En **Function name** (Nombre de la característica), introduzca **TransferStream**. + 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. 1. En la parte inferior de la página, elija **Create function**. 1. A continuación, registre el controlador y cargue el paquete de implementación de la función de Lambda. 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. Seleccione **Cargar** y, a continuación, elija su paquete de implementación de `transfer_stream_python.zip`. A continuación, elija **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 **transfer\$1stream.function\$1handler**. 1. Seleccione **Save**. **nota** El botón de **prueba** de la AWS Lambda consola no funciona con esta función. El SDK AWS IoT Greengrass principal no contiene los módulos necesarios para ejecutar las funciones de Greengrass Lambda de forma independiente en la consola. AWS Lambda Estos módulos (por ejemplo, `greengrass_common`) se suministran a las funciones una vez desplegados en el núcleo de Greengrass. 1. Ahora, publique la primera versión de su función de Lambda y 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**. 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 **TransferStream: 1**, en el menú **Acciones**, seleccione **Crear** alias. 1. En la página **Create a new alias**, utilice los valores siguientes: + En **Nombre**, escriba **GG\$1TransferStream**. + En **Version (Versión)**, elija **1**. **nota** AWS IoT Greengrass **no admite los alias de Lambda para las versiones \$1LATEST.** 1. Seleccione **Crear**. Ahora está preparado para añadir la función de Lambda al grupo de Greengrass. ## Paso 3: Agregar una función de Lambda al grupo de Greengrass En este paso, va a añadir la función de Lambda al grupo y a configurar el ciclo de vida y las variables de entorno. Para obtener más información, consulte [Control de la ejecución de funciones de Lambda de Greengrass utilizando la configuración específica del grupo](lambda-group-config.md). 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. Seleccione el grupo de destino. 1. En la página de configuración del grupo, elija la pestaña **Funciones de Lambda**. 1. En la sección **Mis funciones de Lambda**, seleccione **Añadir**. 1. En la página **Agregar función de Lambda**, seleccione **función de Lambda** para su función de Lambda. 1. **Para la **versión Lambda**, elija Alias:gg\$1. TransferStream** Ahora, configure las propiedades que determinan el comportamiento de la función de Lambda en el grupo de Greengrass. 1. En la sección de **configuración de la función de Lambda**, realice los siguientes cambios: + Establezca el **Memory limit (Límite de memoria)** en 32 MB. + En **Ancladas**, elija **Verdadero** **nota** Una función Lambda de *larga duración* (o *anclada*) se inicia automáticamente después AWS IoT Greengrass del inicio y sigue ejecutándose en su propio contenedor. Esto contrasta con una función de Lambda *bajo demanda*, que se inicia cuando se la invoca y se detiene cuando no quedan tareas que ejecutar. 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). 1. Elija **Añadir función de Lambda**. ## Paso 4: Habilitar el administrador de secuencias En este paso, asegúrese de que el administrador de secuencias está habilitado. 1. En la página de configuración del grupo, elija la pestaña **Funciones de Lambda**. 1. En **Funciones de Lambda del sistema**, seleccione **Administrador de flujos** y luego verifique el estado. Si está deshabilitado, elija **Edit (Editar)**. A continuación, elija **Enable (Activar)** y **Save (Guardar)**. Puede utilizar la configuración de parámetros predeterminada para este tutorial. Para obtener más información, consulte [Configurar el administrador de AWS IoT Greengrass transmisiones](configure-stream-manager.md). **nota** Cuando utiliza la consola para habilitar el administrador de flujos y desplegar el grupo, el tamaño de la memoria para el administrador de flujos se establece por defecto en 4194304 KB (4 GB). Se recomienda establecer el tamaño de la memoria en al menos 128000 KB. ## Paso 5: Configurar el registro local En este paso, configurará los componentes AWS IoT Greengrass del sistema, las funciones Lambda definidas por el usuario y los conectores del grupo para escribir registros en el sistema de archivos del dispositivo principal. Puede usar registros para solucionar cualquier problema que pueda surgir. Para obtener más información, consulte [Supervisión con AWS IoT Greengrass registros](greengrass-logs-overview.md). 1. En **Local logs configuration (Configuración de registros locales)**, compruebe si el registro local está configurado. 1. Si los registros no están configurados para componentes del sistema Greengrass o para funciones de Lambda definidas por el usuario, seleccione **Editar**. 1. Elija **el nivel de registro de funciones de Lambda del usuario** y **el nivel de registro del sistema Greengrass**. 1. Conserve los valores predeterminados para el nivel de registro y el límite de espacio en disco y, a continuación, elija **Guardar**. ## Paso 6: Implementar el grupo de Greengrass Implemente el grupo en el dispositivo del núcleo. 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/ggc-version/bin/daemon`, el daemon está en ejecución. **nota** La versión de la ruta depende de la versión del software AWS IoT Greengrass principal que esté instalada en el dispositivo principal. 1. Inicio de daemon: ``` cd /greengrass/ggc/core/ sudo ./greengrassd start ``` 1. En la página de configuración de grupo, elija **Implementar**. 1. 1. En la pestaña **Funciones de Lambda**, en la sección **Funciones de Lambda del sistema**, 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**. 1. Seleccione **Save**. 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 es compatible con los 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 ayuda sobre la resolución de problemas, consulte [Solución de problemas AWS IoT Greengrass](gg-troubleshooting.md). ## Paso 7: Probar la aplicación La función de Lambda `TransferStream` genera datos simulados del dispositivo. Escribe datos en una secuencia que el administrador de secuencias exporta a la secuencia de datos de Kinesis de destino. 1. En la consola de Amazon Kinesis, en **Kinesis data** Streams, elija. **MyKinesisStream** **nota** Si ejecutó el tutorial sin una secuencia de datos de Kinesis de destino, [compruebe el archivo de registro](stream-manager-cli.md#stream-manager-cli-logs) del administrador de secuencias (`GGStreamManager`). Si contiene `export stream MyKinesisStream doesn't exist` en un mensaje de error, la prueba se ha realizado correctamente. Este error significa que el servicio intentó exportar a la secuencia, pero que la secuencia no existe. 1. **En la **MyKinesisStream**página, elija Monitorización.** Si la prueba se realiza correctamente, debería ver los datos en los gráficos **Put Records**. En función de la conexión, es posible que tarde un minuto en mostrar los datos. **importante** Cuando haya terminado la prueba, elimine la secuencia de datos de Kinesis para evitar incurrir en más gastos. O ejecute el siguiente comando para detener el daemon de Greengrass. Así evitará que el núcleo envíe mensajes hasta que esté listo para continuar las pruebas. ``` cd /greengrass/ggc/core/ sudo ./greengrassd stop ``` 1. Elimine la función **TransferStream**Lambda del núcleo. 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 **Grupos de Greengrass**, elija su grupo. 1. **En la página **Lambdas**, elija los puntos suspensivos (**...**) para la **TransferStream**función y, a continuación, elija Eliminar función.** 1. En **Actions (Acciones)**, seleccione **Deploy (Implementar)**. Para ver la información de registro o solucionar problemas con las secuencias, compruebe los registros para las funciones `TransferStream` y `GGStreamManager`. Debe tener `root` permisos para leer los AWS IoT Greengrass registros del sistema de archivos. + `TransferStream` escribe entradas de registro en `greengrass-root/ggc/var/log/user/region/account-id/TransferStream.log`. + `GGStreamManager` escribe entradas de registro en `greengrass-root/ggc/var/log/system/GGStreamManager.log`. Si necesita más información sobre la solución de problemas, puede [Establecer el nivel de registro](#stream-manager-console-configure-logging) para **Registros de usuario de Lambda** en **Registros de depuración** y, a continuación, implementar el grupo de nuevo. ## Véase también + [Gestione los flujos de datos en el AWS IoT Greengrass núcleo](stream-manager.md) + [Configurar el administrador de AWS IoT Greengrass transmisiones](configure-stream-manager.md) + [Se usa StreamManagerClient para trabajar con transmisiones](work-with-streams.md) + [Exportación de configuraciones para Nube de AWS destinos compatibles](stream-export-configurations.md) + [Exportación de flujos de datos a la Nube de AWS (CLI)](stream-manager-cli.md)