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.
# Gestione los flujos de datos en el AWS IoT Greengrass núcleo
AWS IoT Greengrass stream manager hace que sea más fácil y confiable transferir datos de IoT de gran volumen al Nube de AWS. El administrador de flujos de datos procesa los flujos de datos de forma local y los exporta Nube de AWS automáticamente. Esta función se integra en escenarios periféricos comunes, como la inferencia de aprendizaje automático (ML), en la que los datos se procesan y analizan localmente antes de exportarlos a los Nube de AWS destinos de almacenamiento locales.
El administrador de secuencias simplifica el desarrollo de aplicaciones. Sus aplicaciones de IoT pueden utilizar un mecanismo estandarizado para procesar secuencias de gran volumen y administrar políticas de retención de datos locales en lugar de crear funciones de administración de secuencias personalizadas. Las aplicaciones de IoT pueden leer y escribir en secuencias. Pueden definir políticas para el tipo de almacenamiento, el tamaño y la retención de datos en función de cada secuencia para controlar cómo el administrador de secuencias procesa y exporta secuencias.
El administrador de secuencias está diseñado para trabajar en entornos con conectividad intermitente o limitada. Puede definir el uso del ancho de banda, el comportamiento del tiempo de espera y cómo se administran los datos de secuencias cuando el núcleo está conectado o desconectado. Para los datos críticos, puede establecer prioridades para controlar el orden en que se exportan las secuencias a la Nube de AWS.
Puede configurar las exportaciones automáticas al almacenamiento o Nube de AWS para su posterior procesamiento y análisis. Stream Manager admite la exportación a los siguientes Nube de AWS destinos.
+ Canales entrantes AWS IoT Analytics. AWS IoT Analytics le permite realizar análisis avanzados de sus datos para ayudarle a tomar decisiones empresariales y mejorar los modelos de aprendizaje automático. Para obtener más información, consulte [¿Qué es AWS IoT Analytics?](https://docs.aws.amazon.com/iotanalytics/latest/userguide/welcome.html) en la *Guía AWS IoT Analytics del usuario*.
+ Flujos en Kinesis Data Streams Kinesis Data Streams se suele utilizar para agregar grandes volúmenes de datos y cargarlos en un almacenamiento de datos o en un clúster de map-reduce. Para obtener más información, consulte [Qué son los Amazon Kinesis Data Streams](https://docs.aws.amazon.com/streams/latest/dev/what-is-this-service.html) en la *Guía para desarrolladores de Amazon Kinesis*.
+ Propiedades de activos en AWS IoT SiteWise. AWS IoT SiteWise le permite recopilar, organizar y analizar datos de equipos industriales a escala. Para obtener más información, consulte [¿Qué es AWS IoT SiteWise?](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/what-is-sitewise.html) en la *Guía AWS IoT SiteWise del usuario*.
+ Objetos en Amazon S3. Puede utilizar Amazon S3 para almacenar y recuperar grandes cantidades de datos. Para obtener más información, consulte [¿Qué es Amazon S3?](https://docs.aws.amazon.com/AmazonS3/latest/dev/Welcome.html) en la *Guía para desarrolladores de Amazon Simple Storage Service*.
## Flujo de trabajo de la administración de secuencias
Sus aplicaciones de IoT interactúan con Stream Manager a través del AWS IoT Greengrass Core SDK. En un flujo de trabajo simple, una función de Lambda definida por el usuario que se ejecuta en el núcleo de Greengrass consume los datos de IoT, como las métricas de temperatura y presión de serie temporal. La función Lambda puede filtrar o comprimir los datos y, a continuación, llamar al AWS IoT Greengrass Core SDK para escribir los datos en una transmisión en el administrador de transmisiones. El administrador de flujos puede exportar la secuencia a la Nube de AWS automáticamente, en función de las políticas definidas para la secuencia. Las funciones de Lambda definidas por el usuario también pueden enviar datos directamente a bases de datos locales o repositorios de almacenamiento.
Sus aplicaciones de IoT pueden incluir múltiples funciones de Lambda definidas por el usuario que leen o escriben en secuencias. Estas funciones de Lambda locales pueden leer y escribir en secuencias para filtrar, añadir y analizar datos localmente. Esto permite responder rápidamente a eventos locales y extraer información valiosa antes de que los datos se transfieran desde el núcleo a la nube o destinos locales.
En el siguiente diagrama se muestra un flujo de trabajo de ejemplo.
![\[Diagrama del flujo de trabajo del administrador de secuencias.\]](http://docs.aws.amazon.com/es_es/greengrass/v1/developerguide/images/stream-manager-architecture.png)
Para usar el administrador de flujos, comience por configurar los parámetros del administrador de flujos para definir los ajustes de tiempo de ejecución a nivel de grupo que se apliquen a todas las secuencias del núcleo de Greengrass. Esta configuración personalizable le permite controlar cómo el administrador de flujos almacena, procesa y exporta secuencias en función de las necesidades de su negocio y las restricciones del entorno. Para obtener más información, consulte [Configurar el administrador de AWS IoT Greengrass transmisiones](configure-stream-manager.md).
Después de configurar el administrador de flujos, puede crear e implementar sus aplicaciones de IoT. Por lo general, se trata de funciones Lambda definidas por el usuario que se `StreamManagerClient` utilizan en AWS IoT Greengrass el Core SDK para crear transmisiones e interactuar con ellas. Durante la creación de la secuencia, la función de Lambda define las políticas por secuencia, como los destinos de exportación, la prioridad y la persistencia. Para obtener más información, incluidos fragmentos de código para las operaciones `StreamManagerClient`, consulte [Se usa StreamManagerClient para trabajar con transmisiones](work-with-streams.md).
Para ver tutoriales que configuran un flujo de trabajo sencillo, consulte [Exportar flujos de datos a la Nube de AWS (consola)](stream-manager-console.md) o [Exportación de flujos de datos a la Nube de AWS (CLI)](stream-manager-cli.md).
## Requisitos
Se aplican los siguientes requisitos para el administrador de flujos:
+ Debe usar el software AWS IoT Greengrass Core v1.10 o posterior, con el administrador de transmisiones activado. Para obtener más información, consulte [Configurar el administrador de AWS IoT Greengrass transmisiones](configure-stream-manager.md).
El administrador de transmisiones no es compatible con las distribuciones. OpenWrt
+ Debe instalarse Java 8 Runtime (JDK 8) en el núcleo.
+ 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.
+ Stream Manager requiere un mínimo de 70 MB de RAM además del software AWS IoT Greengrass Core básico. El requisito total de memoria depende de la carga de trabajo.
+ Las 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 flujo. El SDK AWS IoT Greengrass principal está disponible en varios idiomas, pero solo las siguientes versiones admiten las operaciones del administrador de transmisiones:
+ SDK de Java (versión 1.4.0 o posterior)
+ SDK de Python (versión 1.5.0 o posterior)
+ SDK de Node.js (versión 1.6.0 o posterior)
Descargue la versión del SDK que corresponda al tiempo de ejecución de la función de Lambda e inclúyala en el paquete de implementación de la función de Lambda.
**nota**
El SDK AWS IoT Greengrass principal para Python requiere Python 3.7 o una versión posterior y tiene otras dependencias de paquetes. Para obtener más información, consulte [Crear un paquete de implementación de funciones de Lambda (consola)](stream-manager-console.md#stream-manager-console-create-deployment-package) o [Crear un paquete de implementación de funciones de Lambda (CLI)](stream-manager-cli.md#stream-manager-cli-create-deployment-package).
+ Si defines los destinos de Nube de AWS exportación para una transmisión, debes crear tus objetivos de exportación y conceder permisos de acceso en el rol de grupo Greengrass. Según el destino, es posible que también se apliquen otros requisitos. Para obtener más información, consulte:
+ [AWS IoT Analytics canales](stream-export-configurations.md#export-to-iot-analytics)
+ [Amazon Kinesis Data Streams](stream-export-configurations.md#export-to-kinesis)
+ [AWS IoT SiteWise propiedades de los activos](stream-export-configurations.md#export-to-iot-sitewise)
+ [Objetos de Amazon S3](stream-export-configurations.md#export-to-s3)
Usted es responsable de mantener estos Nube de AWS recursos.
## Seguridad de los datos
Cuando utilice el administrador de secuencias, tenga en cuenta las siguientes consideraciones de seguridad.
### Seguridad de los datos locales
AWS IoT Greengrass no cifra localmente los datos de transmisión en reposo o en tránsito entre los componentes del dispositivo principal.
+ **Datos en reposo**. Los datos de flujos se almacenan localmente en un directorio de almacenamiento en el núcleo de Greengrass. Para garantizar la seguridad de los datos, AWS IoT Greengrass utiliza los permisos de archivos de Unix y el cifrado de disco completo, si está activado. Puede utilizar el parámetro opcional [STREAM\$1MANAGER\$1STORE\$1ROOT\$1DIR](configure-stream-manager.md#STREAM_MANAGER_STORE_ROOT_DIR) para especificar el directorio de almacenamiento. Si cambia este parámetro más adelante para usar un directorio de almacenamiento diferente, AWS IoT Greengrass no elimina el directorio de almacenamiento anterior ni su contenido.
+ **Datos en tránsito local**. AWS IoT Greengrass no cifra los datos de transmisión en tránsito local en el núcleo entre las fuentes de datos, las funciones de Lambda, AWS IoT Greengrass el SDK principal y el administrador de transmisiones.
+ **Datos en tránsito al. Nube de AWS** Los flujos de datos exportados por el administrador de transmisiones Nube de AWS utilizan el cifrado de cliente de AWS servicio estándar con Transport Layer Security (TLS).
Para obtener más información, consulte [Cifrado de datos](data-encryption.md).
### Autenticación del cliente
Los clientes de Stream Manager utilizan el SDK AWS IoT Greengrass principal para comunicarse con Stream Manager. Cuando la autenticación de cliente está habilitada, sólo las funciones de Lambda del grupo Greengrass pueden interactuar con las secuencias en el administrador de flujos. Cuando la autenticación de cliente está deshabilitada, cualquier proceso que se ejecute en el núcleo de Greengrass (como [contenedores Docker](docker-app-connector.md)) puede interactuar con las secuencias en el administrador de secuencias. Debe deshabilitar la autenticación solo si su caso de negocio lo requiere.
Utilice el parámetro [STREAM\$1MANAGER\$1AUTHENTICATE\$1CLIENT](configure-stream-manager.md#STREAM_MANAGER_AUTHENTICATE_CLIENT) para establecer el modo de autenticación del cliente. Puedes configurar este parámetro desde la consola o la AWS IoT Greengrass API. Los cambios surten efecto después de implementar el grupo.
****
| | Habilitado | Deshabilitado |
| --- | --- | --- |
| Valor del parámetro | `true` (predeterminado y recomendado) | `false` |
| Clientes permitidos | Funciones de Lambda definidas por el usuario en el grupo Greengrass | Funciones de Lambda definidas por el usuario en el grupo Greengrass Otros procesos que se ejecutan en el dispositivo del núcleo de Greengrass |
## Véase también
+ [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)
+ [Exportar flujos de datos a la Nube de AWS (consola)](stream-manager-console.md)
+ [Exportación de flujos de datos a la Nube de AWS (CLI)](stream-manager-cli.md)
# Configurar el administrador de AWS IoT Greengrass transmisiones
En AWS IoT Greengrass esencia, Stream Manager puede almacenar, procesar y exportar datos de dispositivos de IoT. El administrador de secuencias proporciona parámetros que se utilizan para configurar los ajustes de tiempo de ejecución en el nivel de grupo. Esta configuración se aplica a todas las secuencias del núcleo de Greengrass. Puede usar la AWS IoT consola o la AWS IoT Greengrass API para configurar los ajustes del administrador de transmisiones. Los cambios surten efecto después de implementar el grupo.
**nota**
Después de configurar el administrador de flujos, puede crear e implementar aplicaciones de IoT que se ejecuten en el núcleo de Greengrass e interactúen con el administrador de flujos. Estas aplicaciones de IoT suelen ser funciones de Lambda definidas por el usuario. Para obtener más información, consulte [Se usa StreamManagerClient para trabajar con transmisiones](work-with-streams.md).
## Parámetros del administrador de secuencias
El administrador de secuencias proporciona los siguientes parámetros que le permiten definir la configuración en el nivel de grupo. Todos los parámetros son opcionales.
**Directorio de almacenamiento**
Nombre del parámetro: `STREAM_MANAGER_STORE_ROOT_DIR`
La ruta absoluta del directorio local utilizado para almacenar secuencias. Este valor debe comenzar con una barra inclinada (por ejemplo, `/data`).
Para obtener información sobre cómo proteger los datos de secuencias, consulte [Seguridad de los datos locales](stream-manager.md#stream-manager-security-stream-data).
Versión AWS IoT Greengrass básica mínima: 1.10.0
**Puerto del servidor**
Nombre del parámetro: `STREAM_MANAGER_SERVER_PORT`
El número de puerto local utilizado para comunicarse con el administrador de secuencias. El valor predeterminado es `8088`.
Versión mínima de AWS IoT Greengrass núcleo: 1.10.0
**Autenticar cliente**
Nombre del parámetro: `STREAM_MANAGER_AUTHENTICATE_CLIENT`
Indica si los clientes deben autenticarse para interactuar con el administrador de secuencias. El AWS IoT Greengrass Core SDK controla toda la interacción entre los clientes y el administrador de transmisiones. Este parámetro determina qué clientes pueden llamar al SDK AWS IoT Greengrass Core para trabajar con secuencias. Para obtener más información, consulte [Autenticación del cliente](stream-manager.md#stream-manager-security-client-authentication).
Los valores válidos son `true` o `false`. El valor predeterminado es `true` (recomendado).
+ `true`. Solo permite como clientes las funciones de Lambda de Greengrass. Los clientes de funciones Lambda utilizan protocolos AWS IoT Greengrass principales internos para autenticarse con el AWS IoT Greengrass Core SDK.
+ `false`. Permite que cualquier proceso que se ejecute en el AWS IoT Greengrass núcleo sea un cliente. No establezca a `false` a menos que su caso de negocio lo requiera. Por ejemplo, establezca este valor en `false` solo si los procesos no Lambda en el dispositivo principal deben comunicarse directamente con el administrador de flujos, como los [contenedores de Docker](docker-app-connector.md) que se ejecutan en el núcleo.
Versión AWS IoT Greengrass básica mínima: 1.10.0
**Ancho de banda máximo**
Nombre del parámetro: `STREAM_MANAGER_EXPORTER_MAX_BANDWIDTH`
El ancho de banda máximo promedio (en kilobits por segundo) que se puede utilizar para exportar datos. El valor predeterminado permite el uso ilimitado del ancho de banda disponible.
Versión mínima de AWS IoT Greengrass núcleo: 1.10.0
**Tamaño del grupo de subprocesos**
Nombre del parámetro: `STREAM_MANAGER_EXPORTER_THREAD_POOL_SIZE`
Cantidad máxima de subprocesos activos que se pueden utilizar para exportar datos. El valor predeterminado es `5`.
El tamaño óptimo depende del hardware, el volumen de secuencias y la cantidad planificada de secuencias de exportación. Si la velocidad de exportación es lenta, puede ajustar esta configuración para encontrar el tamaño óptimo para su hardware y su caso de negocio. La CPU y la memoria del hardware del dispositivo principal son factores limitantes. Para comenzar, puede intentar establecer este valor igual a la cantidad de núcleos de procesador en el dispositivo.
Tenga cuidado de no establecer un tamaño superior al que admite el hardware. Cada secuencia consume recursos de hardware, por lo que debe intentar limitar la cantidad de secuencias de exportación en dispositivos restringidos.
Versión mínima de AWS IoT Greengrass núcleo: 1.10.0
**Argumentos de JVM**
Nombre del parámetro: `JVM_ARGS`
Argumentos personalizados de la máquina virtual de Java para pasar al administrador de secuencias al inicio. Varios argumentos deben separarse por espacios.
Utilice este parámetro sólo cuando deba anular la configuración predeterminada utilizada por la JVM. Por ejemplo, puede que necesite aumentar el tamaño predeterminado del montón si planea exportar un gran número de secuencias.
Versión mínima de AWS IoT Greengrass núcleo: 1.10.0
**Directorios de archivos de entrada de solo lectura**
Nombre del parámetro: `STREAM_MANAGER_READ_ONLY_DIRS`
Lista de rutas absolutas separadas por comas a los directorios situados fuera del sistema de archivos raíz que almacenan los archivos de entrada. El administrador de flujos lee y carga los archivos en Amazon S3 y monta los directorios como de solo lectura. Para obtener más información sobre la exportación a Amazon S3, consulte [Objetos de Amazon S3](stream-export-configurations.md#export-to-s3).
Utilice este parámetro solo si se cumplen las siguientes condiciones:
+ El directorio de archivos de entrada de una transmisión que se exporta a Amazon S3 se encuentra en una de las siguientes ubicaciones:
+ Una partición distinta del sistema de archivos raíz.
+ En `/tmp` el sistema de archivos raíz.
+ La [Creación de contenedores por defecto](lambda-group-config.md#lambda-containerization-groupsettings) del grupo Greengrass es **contenedor de Greengrass.**
Ejemplo de valor: `/mnt/directory-1,/mnt/directory-2,/tmp`
Versión mínima de AWS IoT Greengrass núcleo: 1.11.0
**Tamaño mínimo para la carga de varias partes**
Nombre del parámetro: `STREAM_MANAGER_EXPORTER_S3_DESTINATION_MULTIPART_UPLOAD_MIN_PART_SIZE_BYTES`
El tamaño mínimo (en bytes) de una parte en una carga multiparte a Amazon S3. El administrador de flujos utiliza esta configuración y el tamaño del archivo de entrada para determinar cómo agrupar los datos en una solicitud PUT de varias partes. El valor predeterminado y mínimo es de `5242880` bytes (5 MB).
El administrador de flujos usa la propiedad `sizeThresholdForMultipartUploadBytes` de la transmisión para determinar si se debe exportar a Amazon S3 como una carga única o multiparte. Las funciones de Lambda definidas por el usuario establecen este umbral cuando crean una transmisión que se exporta a Amazon S3. El umbral de tamaño predeterminado es 5 MB.
Versión mínima de AWS IoT Greengrass núcleo: 1.11.0
## Configuración del administrador de secuencias (consola)
Puede utilizar la AWS IoT consola para las siguientes tareas de administración:
+ [Comprobar si el administrador de secuencias está habilitado](#check-stream-manager-console)
+ [Habilitar o deshabilitar el administrador de secuencias durante la creación de grupos](#enable-stream-manager-console-new-group)
+ [Habilitar o deshabilitar el administrador de secuencias en un grupo existente](#enable-stream-manager-console-existing-group)
+ [Cambiar la configuración del administrador de secuencias](#change-stream-manager-console)
Los cambios surten efecto después de que se implemente el grupo de Greengrass. Para ver un tutorial que muestra cómo implementar un grupo de Greengrass que contiene una función de Lambda que interactúa con el administrador de flujos, consulte [Exportar flujos de datos a la Nube de AWS (consola)](stream-manager-console.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.
### Para comprobar si el administrador de secuencias está habilitado (consola)
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. Elija la pestaña de **Funciones de Lambda**.
1. En **Funciones de Lambda del sistema**, seleccione **Administrador de flujos** y luego elija **Editar.**
1. Compruebe el estado activado o desactivado. También se muestra cualquier ajuste personalizado del administrador de secuencias que se haya configurado.
### Para habilitar o deshabilitar el administrador de secuencias durante la creación de grupos (consola)
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. Elija **Crear grupo**. Su elección en la página siguiente determina cómo configurar el administrador de secuencias para el grupo.
1. Proceda a través de las páginas **Nombre su grupo** y elija un **núcleo Greengrass**.
1. Elija **Crear grupo**.
1. En la página de configuración del grupo, elija la pestaña **Funciones de Lambda**, seleccione **Administrador de flujos** y elija **Editar**.
+ Para habilitar el administrador de flujos con la configuración predeterminada, elija **Habilitar valores predeterminados**.
+ Para habilitar el administrador de secuencias con configuración personalizada, elija **Customize settings (Personalizar configuración)**.
1. En la página **Configurar administrador de flujos** elija **Habilitar valores personalizados**.
1. En **Custom settings (Configuración personalizada)**, introduzca valores para los parámetros del administrador de secuencias. Para obtener más información, consulte [Parámetros del administrador de secuencias](#stream-manager-parameters). Deje los campos vacíos para AWS IoT Greengrass poder usar sus valores predeterminados.
+ Para deshabilitar el administrador de flujos, seleccione **Desactivar**.
1. En la página **Configure stream manager (Configurar administrador de secuencias)** elija **Disable (Deshabilitar)**.
1. Seleccione **Save**.
1. Continúe en las páginas restantes para crear su grupo.
1. En la página **Dispositivos de cliente** descargue los recursos de seguridad, revise la información y, a continuación, elija **Finalizar**.
**nota**
Cuando el administrador de secuencias esté habilitado, debe [instalar Java 8 Runtime](stream-manager.md#stream-manager-requirements) en el dispositivo principal antes de implementar el grupo.
### Para habilitar o deshabilitar el administrador de secuencias para un grupo existente (consola)
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. Elija la pestaña de **Funciones de Lambda**.
1. En **Funciones de Lambda del sistema**, seleccione **Administrador de flujos** y luego elija **Editar.**
1. Compruebe el estado activado o desactivado. También se muestra cualquier ajuste personalizado del administrador de secuencias que se haya configurado.
### Para cambiar la configuración del administrador de secuencias (consola)
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. Elija la pestaña de **Funciones de Lambda**.
1. En **Funciones de Lambda del sistema**, seleccione **Administrador de flujos** y luego elija **Editar.**
1. Compruebe el estado activado o desactivado. También se muestra cualquier ajuste personalizado del administrador de secuencias que se haya configurado.
1. Seleccione **Save**.
## Configuración del administrador de secuencias (CLI)
En AWS CLI, utilice la función `GGStreamManager` Lambda del sistema para configurar el administrador de flujos. Las funciones de System Lambda son componentes del software AWS IoT Greengrass Core. Para el administrador de flujos y algunas otras funciones de Lambda del sistema, puede configurar la funcionalidad de Greengrass gestionando los objetos `Function` y `FunctionDefinitionVersion` correspondientes del grupo Greengrass. Para obtener más información, consulte [Descripción general del modelo de objetos AWS IoT Greengrass grupales](deployments.md#api-overview).
Puede utilizar la API para las siguientes tareas de administración. En los ejemplos de esta sección se muestra cómo utilizar la API AWS CLI, pero también se puede llamar directamente a la AWS IoT Greengrass API o utilizar un AWS SDK.
+ [Comprobar si el administrador de secuencias está habilitado](#check-stream-manager-cli)
+ [Habilitar, deshabilitar o configurar el administrador de flujos](#enable-stream-manager-cli)
Los cambios surten efecto después de implementar el grupo. Para ver un tutorial que muestra cómo implementar un grupo de Greengrass con una función de Lambda que interactúa con el administrador de flujos, consulte. [Exportación de flujos de datos a la Nube de AWS (CLI)](stream-manager-cli.md)
**sugerencia**
Para ver si el administrador de flujos está habilitado y en ejecución desde su dispositivo principal, puede ejecutar el siguiente comando en un terminal del dispositivo principal.
```
ps aux | grep -i 'streammanager'
```
### Para comprobar si el administrador de secuencias está habilitado (CLI)
El administrador de flujos está habilitado si la versión de definición de característica implementada incluye la función de Lambda del sistema de `GGStreamManager`. Para verificar, haga lo siguiente;
1. Obtenga el grupo y IDs la versión grupal de Greengrass objetivo. En este procedimiento, suponemos que estos son el último grupo y la última versión de grupo. La siguiente consulta devuelve el grupo creado más recientemente.
```
aws greengrass list-groups --query "reverse(sort_by(Groups, &CreationTimestamp))[0]"
```
También puede hacer la consulta por nombre. No es necesario que los nombres de grupo sean únicos, por lo que podrían devolverse varios grupos.
```
aws greengrass list-groups --query "Groups[?Name=='MyGroup']"
```
**nota**
También puede encontrar estos valores en la AWS IoT consola. El ID de grupo se muestra en la página **Settings (Configuración)** del grupo. La versión del grupo IDs se muestra en la pestaña **Implementaciones** del grupo.
1. Copie los valores `Id` y `LatestVersion` del grupo de destino en la salida.
1. Obtenga la última versión del grupo.
+ Reemplace *group-id* por el `Id` que ha copiado.
+ Reemplace *latest-group-version-id* por el `LatestVersion` que ha copiado.
```
aws greengrass get-group-version \
--group-id group-id \
--group-version-id latest-group-version-id
```
1. `FunctionDefinitionVersionArn`En la salida, obtenga la definición IDs de función y la versión de la definición de función.
+ El ID de definición de la característica es el GUID que sigue al segmento `functions` en el Nombre de recurso de Amazon (ARN).
+ El ID de versión de definición de característica es el GUID que sigue al segmento `versions` del ARN.
```
arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/functions/function-definition-id/versions/function-definition-version-id
```
1. Obtenga la versión de la definición de funciones.
+ *function-definition-id*Sustitúyalo por el ID de definición de función.
+ *function-definition-version-id*Sustitúyalo por el ID de versión de la definición de función.
```
aws greengrass get-function-definition-version \
--function-definition-id function-definition-id \
--function-definition-version-id function-definition-version-id
```
Si la matriz `functions` en la salida incluye la característica `GGStreamManager`, entonces el administrador de flujos está habilitado. Cualquier variable de entorno definida para la característica representa una configuración personalizada para el administrador de flujos.
### Para habilitar, deshabilitar o configurar el administrador de flujos (CLI)
En AWS CLI, utilice la función `GGStreamManager` Lambda del sistema para configurar el administrador de flujos. Los cambios surten efecto después de implementar el grupo.
+ Para habilitar el administrador de flujos, incluya `GGStreamManager` en la matriz `functions` de su versión de definición de característica. Para establecer una configuración personalizada, defina variables de entorno para los [parámetros del administrador de secuencias](#stream-manager-parameters) correspondientes.
+ Para deshabilitar el administrador de flujos, elimine `GGStreamManager` de la matriz `functions` de su versión de definición de característica.
**Administrador de secuencias con una configuración predeterminada**
En el siguiente ejemplo de configuración se habilita el administrador de secuencias con una configuración predeterminada. Establece el ID de característica arbitraria en `streamManager`.
```
{
"FunctionArn": "arn:aws:lambda:::function:GGStreamManager:1",
"FunctionConfiguration": {
"MemorySize": 4194304,
"Pinned": true,
"Timeout": 3
},
"Id": "streamManager"
}
```
En cuanto a las propiedades `FunctionConfiguration`, es posible que sepa lo siguiente:
+ `MemorySize` está establecido en 4 194 304 KB (4 GB) con la configuración predeterminada. Siempre puede cambiar este valor. Se recomienda establecer `MemorySize` en al menos 128 000 KB.
+ `Pinned` se debe establecer en `true`.
+ `Timeout` es necesario para la versión de definición de característica, pero `GGStreamManager` no lo usa.
**Administrador de secuencias con una configuración personalizada**
El siguiente ejemplo de configuración habilita el administrador de flujos con valores personalizados para los parámetros de directorio de almacenamiento, puerto del servidor y tamaño del grupo de hilos.
```
{
"FunctionArn": "arn:aws:lambda:::function:GGStreamManager:1",
"FunctionConfiguration": {
"Environment": {
"Variables": {
"STREAM_MANAGER_STORE_ROOT_DIR": "/data",
"STREAM_MANAGER_SERVER_PORT": "1234",
"STREAM_MANAGER_EXPORTER_THREAD_POOL_SIZE": "4"
}
},
"MemorySize": 4194304,
"Pinned": true,
"Timeout": 3
},
"Id": "streamManager"
}
```
AWS IoT Greengrass usa valores predeterminados para los [parámetros del administrador de flujos](#stream-manager-parameters) que no están especificados como variables de entorno.
**El administrador de flujos con ajustes personalizados para las exportaciones de Amazon S3**
El siguiente ejemplo de configuración habilita el administrador de flujos con valores personalizados para los parámetros directorio de carga y tamaño mínimo de carga multiparte.
```
{
"FunctionArn": "arn:aws:lambda:::function:GGStreamManager:1",
"FunctionConfiguration": {
"Environment": {
"Variables": {
"STREAM_MANAGER_READ_ONLY_DIRS": "/mnt/directory-1,/mnt/directory-2,/tmp",
"STREAM_MANAGER_EXPORTER_S3_DESTINATION_MULTIPART_UPLOAD_MIN_PART_SIZE_BYTES": "10485760"
}
},
"MemorySize": 4194304,
"Pinned": true,
"Timeout": 3
},
"Id": "streamManager"
}
```
**Para habilitar, deshabilitar o configurar el administrador de flujos (CLI)**
1. Obtenga el grupo y IDs la versión grupal de Greengrass objetivo. En este procedimiento, suponemos que estos son el último grupo y la última versión de grupo. La siguiente consulta devuelve el grupo creado más recientemente.
```
aws greengrass list-groups --query "reverse(sort_by(Groups, &CreationTimestamp))[0]"
```
También puede hacer la consulta por nombre. No es necesario que los nombres de grupo sean únicos, por lo que podrían devolverse varios grupos.
```
aws greengrass list-groups --query "Groups[?Name=='MyGroup']"
```
**nota**
También puede encontrar estos valores en la AWS IoT consola. El ID de grupo se muestra en la página **Settings (Configuración)** del grupo. La versión del grupo IDs se muestra en la pestaña **Implementaciones** del grupo.
1. Copie los valores `Id` y `LatestVersion` del grupo de destino en la salida.
1. Obtenga la última versión del grupo.
+ Reemplace *group-id* por el `Id` que ha copiado.
+ Reemplace *latest-group-version-id* por el `LatestVersion` que ha copiado.
```
aws greengrass get-group-version \
--group-id group-id \
--group-version-id latest-group-version-id
```
1. Copie la versión `CoreDefinitionVersionArn` y todas las demás ARNs de la salida, excepto`FunctionDefinitionVersionArn`. Estos valores los utilizará más adelante cuando cree una versión de grupo.
1. Desde `FunctionDefinitionVersionArn` en el resultado, copie el ID de la definición de la característica. El ID es el GUID que va detrás del segmento `functions` en el ARN, tal y como se muestra en el siguiente ejemplo.
```
arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/functions/bcfc6b49-beb0-4396-b703-6dEXAMPLEcu5/versions/0f7337b4-922b-45c5-856f-1aEXAMPLEsf6
```
**nota**
O puede crear una definición de la función ejecutando el comando [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) y luego copiar el ID del resultado.
1. Añada una versión de definición de la función a la definición de la característica.
+ *function-definition-id*Sustitúyala por la `Id` que copiaste para la definición de la función.
+ En la matriz de `functions`, incluya todas las demás funciones que desee que estén disponibles en el núcleo de Greengrass. Puede usar el comando `get-function-definition-version` para obtener la lista de funciones existentes.
**Habilitar el administrador de secuencias con una configuración predeterminada**
En el ejemplo siguiente se habilita el administrador de flujos al incluir la característica `GGStreamManager` en la matriz `functions`. En este ejemplo se utilizan valores predeterminados para los [parámetros del administrador de secuencias](#stream-manager-parameters).
```
aws greengrass create-function-definition-version \
--function-definition-id function-definition-id \
--functions '[
{
"FunctionArn": "arn:aws:lambda:::function:GGStreamManager:1",
"FunctionConfiguration": {
"MemorySize": 4194304,
"Pinned": true,
"Timeout": 3
},
"Id": "streamManager"
},
{
"FunctionArn": "arn:aws:lambda:us-west-2:123456789012:function:MyLambdaFunction:MyAlias",
"FunctionConfiguration": {
"Executable": "myLambdaFunction.function_handler",
"MemorySize": 16000,
"Pinned": true,
"Timeout": 5
},
"Id": "myLambdaFunction"
},
... more user-defined functions
]
}'
```
La función `myLambdaFunction` de los ejemplos representa una de las funciones de Lambda que ha definido.
**Habilitar el administrador de secuencias con una configuración personalizada**
En el ejemplo siguiente se habilita el administrador de flujos al incluir la característica `GGStreamManager` en la matriz `functions`. Todas las configuraciones del administrador de flujos son opcionales, a menos que desee cambiar los valores predeterminados. Este ejemplo muestra cómo utilizar variables de entorno para establecer valores personalizados.
```
aws greengrass create-function-definition-version \
--function-definition-id function-definition-id \
--functions '[
{
"FunctionArn": "arn:aws:lambda:::function:GGStreamManager:1",
"FunctionConfiguration": {
"Environment": {
"Variables": {
"STREAM_MANAGER_STORE_ROOT_DIR": "/data",
"STREAM_MANAGER_SERVER_PORT": "1234",
"STREAM_MANAGER_EXPORTER_THREAD_POOL_SIZE": "4"
}
},
"MemorySize": 4194304,
"Pinned": true,
"Timeout": 3
},
"Id": "streamManager"
},
{
"FunctionArn": "arn:aws:lambda:us-west-2:123456789012:function:MyLambdaFunction:MyAlias",
"FunctionConfiguration": {
"Executable": "myLambdaFunction.function_handler",
"MemorySize": 16000,
"Pinned": true,
"Timeout": 5
},
"Id": "myLambdaFunction"
},
... more user-defined functions
]
}'
```
En cuanto a las propiedades `FunctionConfiguration`, es posible que sepa lo siguiente:
+ `MemorySize` está establecido en 4 194 304 KB (4 GB) con la configuración predeterminada. Siempre puede cambiar este valor. Se recomienda establecer `MemorySize` en al menos 128 000 KB.
+ `Pinned` se debe establecer en `true`.
+ `Timeout` es necesario para la versión de definición de característica, pero `GGStreamManager` no lo usa.
**Desactivar el administrador de secuencias**
El ejemplo siguiente se omite la característica `GGStreamManager`, lo que desactiva el administrador de flujos.
```
aws greengrass create-function-definition-version \
--function-definition-id function-definition-id \
--functions '[
{
"FunctionArn": "arn:aws:lambda:us-west-2:123456789012:function:MyLambdaFunction:MyAlias",
"FunctionConfiguration": {
"Executable": "myLambdaFunction.function_handler",
"MemorySize": 16000,
"Pinned": true,
"Timeout": 5
},
"Id": "myLambdaFunction"
},
... more user-defined functions
]
}'
```
Si no desea implementar ninguna función de Lambda, puede omitir la versión de la definición de característica por completo.
1. Copie el `Arn` de la versión de definición de la característica del resultado.
1. Cree una versión de grupo que contenga la función de Lambda del sistema.
+ *group-id*Sustitúyalo `Id` por el para el grupo.
+ *core-definition-version-arn*Sustitúyalo por el `CoreDefinitionVersionArn` que copió de la última versión del grupo.
+ *function-definition-version-arn*Sustitúyala por la `Arn` que copió para la nueva versión de definición de funciones.
+ Sustituya los ARNs demás componentes del grupo (por ejemplo, `SubscriptionDefinitionVersionArn` o`DeviceDefinitionVersionArn`) que haya 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
```
1. Copie la `Version` del resultado. Este es el ID de la nueva versión del grupo.
1. Implemente el grupo con la nueva versión del grupo.
+ *group-id*Sustitúyalo por el `Id` que copió para el grupo.
+ *group-version-id*Sustitúyala por la `Version` que copiaste para la nueva versión del grupo.
```
aws greengrass create-deployment \
--group-id group-id \
--group-version-id group-version-id \
--deployment-type NewDeployment
```
Siga este procedimiento si desea volver a editar la configuración del administrador de flujos más adelante. Asegúrese de crear una versión de definición de la función que incluya la función `GGStreamManager` con la configuración actualizada. La versión de grupo debe hacer referencia a todas las versiones de los componentes ARNs que desee implementar en el núcleo. Los cambios surten efecto después de implementar el grupo.
## Véase también
+ [Gestione los flujos de datos en el AWS IoT Greengrass núcleo](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)
+ [Exportar flujos de datos a la Nube de AWS (consola)](stream-manager-console.md)
+ [Exportación de flujos de datos a la Nube de AWS (CLI)](stream-manager-cli.md)
# Se usa StreamManagerClient para trabajar con transmisiones
Las funciones Lambda definidas por el usuario que se ejecutan en AWS IoT Greengrass el núcleo pueden usar `StreamManagerClient` el objeto del SDK de [Core para crear transmisiones [en AWS IoT Greengrass](stream-manager.md) el](lambda-functions.md#lambda-sdks) administrador de transmisiones y, a continuación, interactuar con las transmisiones. Cuando una función Lambda crea una transmisión, define los Nube de AWS destinos, la priorización y otras políticas de exportación y retención de datos para la transmisión. Para enviar datos al administrador de flujos, las funciones de Lambda anexan los datos al flujo. Si se define un destino de exportación para el flujo, el administrador de flujos exporta la secuencia automáticamente.
**nota**
Normalmente, los clientes del administrador de flujos son funciones de Lambda definidas por el usuario. Si su caso de negocio lo requiere, puede permitir que los procesos no-Lambda que se ejecutan en el núcleo de Greengrass (por ejemplo, un contenedor de Docker) interactúen con el administrador de flujos. Para obtener más información, consulte [Autenticación del cliente](stream-manager.md#stream-manager-security-client-authentication).
Los fragmentos de este tema muestran cómo los clientes llaman a los métodos de `StreamManagerClient` para trabajar con secuencias. Para obtener detalles sobre la implementación de los métodos y sus argumentos, utilice los vínculos a la referencia del SDK de cada fragmento. Para ver tutoriales que utilizan una función de Lambda completa de Python, consulte [Exportar flujos de datos a la Nube de AWS (consola)](stream-manager-console.md) o [Exportación de flujos de datos a la Nube de AWS (CLI)](stream-manager-cli.md).
Debe crear una función de Lambda `StreamManagerClient` fuera del controlador de funciones. Si se crea una instancia en el controlador, la función crea un `client` y una conexión al administrador de secuencias cada vez que se invoca.
**nota**
Si crea una instancia `StreamManagerClient` en el controlador, debe llamar explícitamente al método `close()` cuando el `client` complete su trabajo. De lo contrario, el `client` mantiene la conexión abierta y otro subproceso en ejecución hasta que salga del script.
`StreamManagerClient` admite las siguientes operaciones:
+ [Creación de una secuencia de mensajes](#streammanagerclient-create-message-stream)
+ [Agregar un mensaje](#streammanagerclient-append-message)
+ [Lectura de mensajes](#streammanagerclient-read-messages)
+ [Lista de secuencias](#streammanagerclient-list-streams)
+ [Descripción de una secuencia de mensajes](#streammanagerclient-describe-message-stream)
+ [Actualización de un flujo de mensajes](#streammanagerclient-update-message-stream)
+ [Eliminación de una secuencia de mensajes](#streammanagerclient-delete-message-stream)
## Creación de una secuencia de mensajes
Para crear un flujo, una función de Lambda definida por el usuario llama al método de creación y pasa un objeto de `MessageStreamDefinition`. Este objeto especifica el nombre exclusivo del flujo y define cómo el administrador del flujo debe gestionar los nuevos datos cuando se alcanza el tamaño máximo de flujo. Puede utilizar `MessageStreamDefinition` y sus tipos de datos (como `ExportDefinition`, `StrategyOnFull` y `Persistence`) para definir otras propiedades de secuencias. Entre ellos se incluyen:
+ El destino AWS IoT Analytics, Kinesis Data Streams AWS IoT SiteWise y Amazon S3 para las exportaciones automáticas. Para obtener más información, consulte [Exportación de configuraciones para Nube de AWS destinos compatibles](stream-export-configurations.md).
+ Prioridad de exportación. El administrador de secuencias exporta secuencias de mayor prioridad antes que secuencias de menor prioridad.
+ Tamaño e intervalo de lote máximos para AWS IoT Analytics Kinesis Data Streams AWS IoT SiteWise y destinos. El administrador de secuencias exporta mensajes cuando se cumple cualquiera de las condiciones.
+ Time-to-live (TTL). La cantidad de tiempo para garantizar que los datos de secuencia están disponibles para su procesamiento. Debe asegurarse de que los datos se pueden consumir dentro de este período de tiempo. Esta no es una política de eliminación. Es posible que los datos no se eliminen inmediatamente después del período TTL.
+ Persistencia de secuencia. Elija guardar las secuencias en el sistema de archivos para conservar los datos en los reinicios del núcleo o guardar las secuencias en la memoria.
+ Inicio del número de secuencia Especifique el número de secuencia del mensaje que se utilizará como mensaje de inicio en la exportación.
Para obtener más información acerca de `MessageStreamDefinition`, consulte la referencia del SDK para el lenguaje de destino:
+ [MessageStreamDefinition](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/MessageStreamDefinition.html)en el SDK de Java
+ [MessageStreamDefinition](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.MessageStreamDefinition.html)en el SDK de Node.js
+ [MessageStreamDefinition](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.MessageStreamDefinition)en el SDK de Python
**nota**
`StreamManagerClient` también proporciona un destino que puede utilizar para exportar secuencias a un servidor HTTP. Este destino está pensado solo con fines de prueba. No es estable y no se admite para su uso en entornos de producción.
Una vez creado un flujo, las funciones de Lambda pueden [anexar mensajes](#streammanagerclient-append-message) al flujo para enviar datos para su exportación y [leer los mensajes](#streammanagerclient-append-message) del flujo para su procesamiento local. El número de secuencias que cree depende de sus capacidades de hardware y de su caso de negocio. Una estrategia consiste en AWS IoT Analytics crear una transmisión para cada canal de destino de la transmisión de datos de Kinesis, aunque puede definir varios destinos para una transmisión. Una secuencia tiene una vida útil duradera.
### Requisitos
Esta operación tiene los siguientes requisitos:
+ Versión AWS IoT Greengrass básica mínima: 1.10.0
+ Versión mínima del SDK de AWS IoT Greengrass Core: Python: 1.5.0 \$1 Java: 1.4.0 \$1 Node.js: 1.6.0
**nota**
La creación de transmisiones con un destino de exportación AWS IoT SiteWise o Amazon S3 tiene los siguientes requisitos:
Versión AWS IoT Greengrass básica mínima: 1.11.0
Versión mínima del SDK de AWS IoT Greengrass Core: Python: 1.6.0 \$1 Java: 1.5.0 \$1 Node.js: 1.7.0
### Ejemplos
El siguiente fragmento crea una secuencia denominada `StreamName`. Define las propiedades de las secuencias en `MessageStreamDefinition` y los tipos de datos subordinados.
------
#### [ Python ]
```
client = StreamManagerClient()
try:
client.create_message_stream(MessageStreamDefinition(
name="StreamName", # Required.
max_size=268435456, # Default is 256 MB.
stream_segment_size=16777216, # Default is 16 MB.
time_to_live_millis=None, # By default, no TTL is enabled.
strategy_on_full=StrategyOnFull.OverwriteOldestData, # Required.
persistence=Persistence.File, # Default is File.
flush_on_write=False, # Default is false.
export_definition=ExportDefinition( # Optional. Choose where/how the stream is exported to the Nube de AWS.
kinesis=None,
iot_analytics=None,
iot_sitewise=None,
s3_task_executor=None
)
))
except StreamManagerException:
pass
# Properly handle errors.
except ConnectionError or asyncio.TimeoutError:
pass
# Properly handle errors.
```
Referencia del SDK de Python: [create\$1message\$1stream](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html#greengrasssdk.stream_manager.streammanagerclient.StreamManagerClient.create_message_stream) \$1 [MessageStreamDefinition](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.MessageStreamDefinition)
------
#### [ Java ]
```
try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) {
client.createMessageStream(
new MessageStreamDefinition()
.withName("StreamName") // Required.
.withMaxSize(268435456L) // Default is 256 MB.
.withStreamSegmentSize(16777216L) // Default is 16 MB.
.withTimeToLiveMillis(null) // By default, no TTL is enabled.
.withStrategyOnFull(StrategyOnFull.OverwriteOldestData) // Required.
.withPersistence(Persistence.File) // Default is File.
.withFlushOnWrite(false) // Default is false.
.withExportDefinition( // Optional. Choose where/how the stream is exported to the Nube de AWS.
new ExportDefinition()
.withKinesis(null)
.withIotAnalytics(null)
.withIotSitewise(null)
.withS3TaskExecutor(null)
)
);
} catch (StreamManagerException e) {
// Properly handle exception.
}
```
Referencia del [createMessageStream](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#createMessageStream-com.amazonaws.greengrass.streammanager.model.MessageStreamDefinition-)SDK de Java: \$1 [MessageStreamDefinition](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/MessageStreamDefinition.html)
------
#### [ Node.js ]
```
const client = new StreamManagerClient();
client.onConnected(async () => {
try {
await client.createMessageStream(
new MessageStreamDefinition()
.withName("StreamName") // Required.
.withMaxSize(268435456) // Default is 256 MB.
.withStreamSegmentSize(16777216) // Default is 16 MB.
.withTimeToLiveMillis(null) // By default, no TTL is enabled.
.withStrategyOnFull(StrategyOnFull.OverwriteOldestData) // Required.
.withPersistence(Persistence.File) // Default is File.
.withFlushOnWrite(false) // Default is false.
.withExportDefinition( // Optional. Choose where/how the stream is exported to the Nube de AWS.
new ExportDefinition()
.withKinesis(null)
.withIotAnalytics(null)
.withIotSitewise(null)
.withS3TaskExecutor(null)
)
);
} catch (e) {
// Properly handle errors.
}
});
client.onError((err) => {
// Properly handle connection errors.
// This is called only when the connection to the StreamManager server fails.
});
```
Referencia del SDK de Node.js: [createMessageStream](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#createMessageStream)\$1 [MessageStreamDefinition](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.MessageStreamDefinition.html)
------
Para obtener más información acerca de la configuración de destinos de exportación, consulte [Exportación de configuraciones para Nube de AWS destinos compatibles](stream-export-configurations.md).
## Agregar un mensaje
Para enviar datos al administrador de flujos para su exportación, las funciones de Lambda anexan los datos al flujo de destino. El destino de exportación determina el tipo de datos que se van a transferir a este método.
### Requisitos
Esta operación tiene los siguientes requisitos:
+ Versión AWS IoT Greengrass básica mínima: 1.10.0
+ Versión mínima del SDK de AWS IoT Greengrass Core: Python: 1.5.0 \$1 Java: 1.4.0 \$1 Node.js: 1.6.0
**nota**
La adición de mensajes a un destino de exportación AWS IoT SiteWise o a Amazon S3 tiene los siguientes requisitos:
Versión AWS IoT Greengrass básica mínima: 1.11.0
Versión mínima del SDK de AWS IoT Greengrass Core: Python: 1.6.0 \$1 Java: 1.5.0 \$1 Node.js: 1.7.0
### Ejemplos
#### AWS IoT Analytics o destinos de exportación de Kinesis Data Streams
El siguiente fragmento agrega un mensaje a la secuencia denominada `StreamName`. Para los AWS IoT Analytics destinos de Kinesis Data Streams, las funciones de Lambda añaden una masa de datos.
Este fragmento tiene los siguientes requisitos:
+ Versión básica mínima AWS IoT Greengrass : 1.10.0
+ Versión mínima del SDK de AWS IoT Greengrass Core: Python: 1.5.0 \$1 Java: 1.4.0 \$1 Node.js: 1.6.0
------
#### [ Python ]
```
client = StreamManagerClient()
try:
sequence_number = client.append_message(stream_name="StreamName", data=b'Arbitrary bytes data')
except StreamManagerException:
pass
# Properly handle errors.
except ConnectionError or asyncio.TimeoutError:
pass
# Properly handle errors.
```
Referencia del SDK de Python: [append\$1message](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html#greengrasssdk.stream_manager.streammanagerclient.StreamManagerClient.append_message)
------
#### [ Java ]
```
try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) {
long sequenceNumber = client.appendMessage("StreamName", "Arbitrary byte array".getBytes());
} catch (StreamManagerException e) {
// Properly handle exception.
}
```
Referencia de SDK de Java: [appendMessage](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#appendMessage-java.lang.String-byte:A-)
------
#### [ Node.js ]
```
const client = new StreamManagerClient();
client.onConnected(async () => {
try {
const sequenceNumber = await client.appendMessage("StreamName", Buffer.from("Arbitrary byte array"));
} catch (e) {
// Properly handle errors.
}
});
client.onError((err) => {
// Properly handle connection errors.
// This is called only when the connection to the StreamManager server fails.
});
```
Referencia del Node.js SDK: [appendMessage](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#appendMessage)
------
#### AWS IoT SiteWise destinos de exportación
El siguiente fragmento agrega un mensaje a la secuencia denominada `StreamName`. Para AWS IoT SiteWise los destinos, las funciones de Lambda añaden un objeto serializado. `PutAssetPropertyValueEntry` Para obtener más información, consulte [Exportación a AWS IoT SiteWise](stream-export-configurations.md#export-streams-to-sitewise).
**nota**
Al enviar datos a AWS IoT SiteWise, estos deben cumplir los requisitos de la acción. `BatchPutAssetPropertyValue` Para obtener más información, consulta [BatchPutAssetPropertyValue](https://docs.aws.amazon.com/iot-sitewise/latest/APIReference/API_BatchPutAssetPropertyValue.html) en la *AWS IoT SiteWise Referencia de la API de *.
Este fragmento tiene los siguientes requisitos:
+ Versión AWS IoT Greengrass básica mínima: 1.11.0
+ Versión mínima del SDK de AWS IoT Greengrass Core: Python: 1.6.0 \$1 Java: 1.5.0 \$1 Node.js: 1.7.0
------
#### [ Python ]
```
client = StreamManagerClient()
try:
# SiteWise requires unique timestamps in all messages. Add some randomness to time and offset.
# Note: To create a new asset property data, you should use the classes defined in the
# greengrasssdk.stream_manager module.
time_in_nanos = TimeInNanos(
time_in_seconds=calendar.timegm(time.gmtime()) - random.randint(0, 60), offset_in_nanos=random.randint(0, 10000)
)
variant = Variant(double_value=random.random())
asset = [AssetPropertyValue(value=variant, quality=Quality.GOOD, timestamp=time_in_nanos)]
putAssetPropertyValueEntry = PutAssetPropertyValueEntry(entry_id=str(uuid.uuid4()), property_alias="PropertyAlias", property_values=asset)
sequence_number = client.append_message(stream_name="StreamName", data=Util.validate_and_serialize_to_json_bytes(putAssetPropertyValueEntry))
except StreamManagerException:
pass
# Properly handle errors.
except ConnectionError or asyncio.TimeoutError:
pass
# Properly handle errors.
```
Referencia del SDK de Python: [append\$1message \$1 [PutAssetPropertyValueEntry](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.PutAssetPropertyValueEntry)](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html#greengrasssdk.stream_manager.streammanagerclient.StreamManagerClient.append_message)
------
#### [ Java ]
```
try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) {
Random rand = new Random();
// Note: To create a new asset property data, you should use the classes defined in the
// com.amazonaws.greengrass.streammanager.model.sitewise package.
List entries = new ArrayList<>() ;
// IoTSiteWise requires unique timestamps in all messages. Add some randomness to time and offset.
final int maxTimeRandomness = 60;
final int maxOffsetRandomness = 10000;
double randomValue = rand.nextDouble();
TimeInNanos timestamp = new TimeInNanos()
.withTimeInSeconds(Instant.now().getEpochSecond() - rand.nextInt(maxTimeRandomness))
.withOffsetInNanos((long) (rand.nextInt(maxOffsetRandomness)));
AssetPropertyValue entry = new AssetPropertyValue()
.withValue(new Variant().withDoubleValue(randomValue))
.withQuality(Quality.GOOD)
.withTimestamp(timestamp);
entries.add(entry);
PutAssetPropertyValueEntry putAssetPropertyValueEntry = new PutAssetPropertyValueEntry()
.withEntryId(UUID.randomUUID().toString())
.withPropertyAlias("PropertyAlias")
.withPropertyValues(entries);
long sequenceNumber = client.appendMessage("StreamName", ValidateAndSerialize.validateAndSerializeToJsonBytes(putAssetPropertyValueEntry));
} catch (StreamManagerException e) {
// Properly handle exception.
}
```
Referencia del SDK de Java: [AppendMessage \$1 [PutAssetPropertyValueEntry](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/sitewise/PutAssetPropertyValueEntry.html)](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#appendMessage-java.lang.String-byte:A-)
------
#### [ Node.js ]
```
const client = new StreamManagerClient();
client.onConnected(async () => {
try {
const maxTimeRandomness = 60;
const maxOffsetRandomness = 10000;
const randomValue = Math.random();
// Note: To create a new asset property data, you should use the classes defined in the
// aws-greengrass-core-sdk StreamManager module.
const timestamp = new TimeInNanos()
.withTimeInSeconds(Math.round(Date.now() / 1000) - Math.floor(Math.random() - maxTimeRandomness))
.withOffsetInNanos(Math.floor(Math.random() * maxOffsetRandomness));
const entry = new AssetPropertyValue()
.withValue(new Variant().withDoubleValue(randomValue))
.withQuality(Quality.GOOD)
.withTimestamp(timestamp);
const putAssetPropertyValueEntry = new PutAssetPropertyValueEntry()
.withEntryId(`${ENTRY_ID_PREFIX}${i}`)
.withPropertyAlias("PropertyAlias")
.withPropertyValues([entry]);
const sequenceNumber = await client.appendMessage("StreamName", util.validateAndSerializeToJsonBytes(putAssetPropertyValueEntry));
} catch (e) {
// Properly handle errors.
}
});
client.onError((err) => {
// Properly handle connection errors.
// This is called only when the connection to the StreamManager server fails.
});
```
Referencia del SDK de Node.js: [AppendMessage \$1 [PutAssetPropertyValueEntry](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.PutAssetPropertyValueEntry.html)](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#appendMessage)
------
#### Destinos de exportación de Amazon S3
El siguiente fragmento añade una tarea de exportación a la secuencia denominada `StreamName`. Para los destinos de Amazon S3, las funciones de Lambda añaden un objeto `S3ExportTaskDefinition` serializado que contiene información sobre el archivo de entrada de origen y el objeto de Amazon S3 de destino. Si el objeto especificado no existe, el administrador de flujos lo crea por usted. Para obtener más información, consulte [Exportación a Amazon S3](stream-export-configurations.md#export-streams-to-s3).
Este fragmento tiene los siguientes requisitos:
+ Versión AWS IoT Greengrass básica mínima: 1.11.0
+ Versión mínima del SDK de AWS IoT Greengrass Core: Python: 1.6.0 \$1 Java: 1.5.0 \$1 Node.js: 1.7.0
------
#### [ Python ]
```
client = StreamManagerClient()
try:
# Append an Amazon S3 Task definition and print the sequence number.
s3_export_task_definition = S3ExportTaskDefinition(input_url="URLToFile", bucket="BucketName", key="KeyName")
sequence_number = client.append_message(stream_name="StreamName", data=Util.validate_and_serialize_to_json_bytes(s3_export_task_definition))
except StreamManagerException:
pass
# Properly handle errors.
except ConnectionError or asyncio.TimeoutError:
pass
# Properly handle errors.
```
[Referencia del SDK de Python: [append\$1message \$1 S3](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html#greengrasssdk.stream_manager.streammanagerclient.StreamManagerClient.append_message) ExportTaskDefinition](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.S3ExportTaskDefinition)
------
#### [ Java ]
```
try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) {
// Append an Amazon S3 export task definition and print the sequence number.
S3ExportTaskDefinition s3ExportTaskDefinition = new S3ExportTaskDefinition()
.withBucket("BucketName")
.withKey("KeyName")
.withInputUrl("URLToFile");
long sequenceNumber = client.appendMessage("StreamName", ValidateAndSerialize.validateAndSerializeToJsonBytes(s3ExportTaskDefinition));
} catch (StreamManagerException e) {
// Properly handle exception.
}
```
[Referencia del SDK de Java: [AppendMessage \$1](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#appendMessage-java.lang.String-byte:A-) S3 ExportTaskDefinition](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/S3ExportTaskDefinition.html)
------
#### [ Node.js ]
```
const client = new StreamManagerClient();
client.onConnected(async () => {
try {
// Append an Amazon S3 export task definition and print the sequence number.
const taskDefinition = new S3ExportTaskDefinition()
.withBucket("BucketName")
.withKey("KeyName")
.withInputUrl("URLToFile");
const sequenceNumber = await client.appendMessage("StreamName", util.validateAndSerializeToJsonBytes(taskDefinition)));
} catch (e) {
// Properly handle errors.
}
});
client.onError((err) => {
// Properly handle connection errors.
// This is called only when the connection to the StreamManager server fails.
});
```
[Referencia del SDK de Node.js: [AppendMessage \$1](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#appendMessage) S3 ExportTaskDefinition](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.S3ExportTaskDefinition.html)
------
## Lectura de mensajes
Leer mensajes de un flujo.
### Requisitos
Esta operación tiene los siguientes requisitos:
+ Versión AWS IoT Greengrass básica mínima: 1.10.0
+ Versión mínima del SDK de AWS IoT Greengrass Core: Python: 1.5.0 \$1 Java: 1.4.0 \$1 Node.js: 1.6.0
### Ejemplos
El siguiente fragmento lee los mensajes de la secuencia denominada `StreamName`. El método read toma un objeto `ReadMessagesOptions` opcional que especifica el número de secuencia para comenzar a leer, los números mínimo y máximo para leer y un tiempo de espera para leer mensajes.
------
#### [ Python ]
```
client = StreamManagerClient()
try:
message_list = client.read_messages(
stream_name="StreamName",
# By default, if no options are specified, it tries to read one message from the beginning of the stream.
options=ReadMessagesOptions(
desired_start_sequence_number=100,
# Try to read from sequence number 100 or greater. By default, this is 0.
min_message_count=10,
# Try to read 10 messages. If 10 messages are not available, then NotEnoughMessagesException is raised. By default, this is 1.
max_message_count=100, # Accept up to 100 messages. By default this is 1.
read_timeout_millis=5000
# Try to wait at most 5 seconds for the min_messsage_count to be fulfilled. By default, this is 0, which immediately returns the messages or an exception.
)
)
except StreamManagerException:
pass
# Properly handle errors.
except ConnectionError or asyncio.TimeoutError:
pass
# Properly handle errors.
```
Referencia del SDK de Python: [read\$1messages \$1 [ReadMessagesOptions](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.ReadMessagesOptions)](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html#greengrasssdk.stream_manager.streammanagerclient.StreamManagerClient.read_messages)
------
#### [ Java ]
```
try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) {
List messages = client.readMessages("StreamName",
// By default, if no options are specified, it tries to read one message from the beginning of the stream.
new ReadMessagesOptions()
// Try to read from sequence number 100 or greater. By default this is 0.
.withDesiredStartSequenceNumber(100L)
// Try to read 10 messages. If 10 messages are not available, then NotEnoughMessagesException is raised. By default, this is 1.
.withMinMessageCount(10L)
// Accept up to 100 messages. By default this is 1.
.withMaxMessageCount(100L)
// Try to wait at most 5 seconds for the min_messsage_count to be fulfilled. By default, this is 0, which immediately returns the messages or an exception.
.withReadTimeoutMillis(Duration.ofSeconds(5L).toMillis())
);
} catch (StreamManagerException e) {
// Properly handle exception.
}
```
Referencia del SDK de Java: [readMessages \$1 [ReadMessagesOptions](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/ReadMessagesOptions.html)](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#readMessages-java.lang.String-com.amazonaws.greengrass.streammanager.model.ReadMessagesOptions-)
------
#### [ Node.js ]
```
const client = new StreamManagerClient();
client.onConnected(async () => {
try {
const messages = await client.readMessages("StreamName",
// By default, if no options are specified, it tries to read one message from the beginning of the stream.
new ReadMessagesOptions()
// Try to read from sequence number 100 or greater. By default this is 0.
.withDesiredStartSequenceNumber(100)
// Try to read 10 messages. If 10 messages are not available, then NotEnoughMessagesException is thrown. By default, this is 1.
.withMinMessageCount(10)
// Accept up to 100 messages. By default this is 1.
.withMaxMessageCount(100)
// Try to wait at most 5 seconds for the minMessageCount to be fulfilled. By default, this is 0, which immediately returns the messages or an exception.
.withReadTimeoutMillis(5 * 1000)
);
} catch (e) {
// Properly handle errors.
}
});
client.onError((err) => {
// Properly handle connection errors.
// This is called only when the connection to the StreamManager server fails.
});
```
Referencia del SDK de Node.js: [readMessages \$1 [ReadMessagesOptions](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.ReadMessagesOptions.html)](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#readMessages)
------
## Lista de secuencias
Obtenga la lista de flujos en el administrador de flujos.
### Requisitos
Esta operación tiene los siguientes requisitos:
+ Versión AWS IoT Greengrass básica mínima: 1.10.0
+ Versión mínima del SDK de AWS IoT Greengrass Core: Python: 1.5.0 \$1 Java: 1.4.0 \$1 Node.js: 1.6.0
### Ejemplos
El siguiente fragmento de código obtiene una lista de las secuencias (por nombre) del administrador de secuencias.
------
#### [ Python ]
```
client = StreamManagerClient()
try:
stream_names = client.list_streams()
except StreamManagerException:
pass
# Properly handle errors.
except ConnectionError or asyncio.TimeoutError:
pass
# Properly handle errors.
```
Referencia del SDK de Python: [list\$1streams](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html#greengrasssdk.stream_manager.streammanagerclient.StreamManagerClient.list_streams)
------
#### [ Java ]
```
try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) {
List streamNames = client.listStreams();
} catch (StreamManagerException e) {
// Properly handle exception.
}
```
Referencia de SDK de Java: [listStreams](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#listStreams--)
------
#### [ Node.js ]
```
const client = new StreamManagerClient();
client.onConnected(async () => {
try {
const streams = await client.listStreams();
} catch (e) {
// Properly handle errors.
}
});
client.onError((err) => {
// Properly handle connection errors.
// This is called only when the connection to the StreamManager server fails.
});
```
Referencia del Node.js SDK: [listStreams](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#listStreams)
------
## Descripción de una secuencia de mensajes
Obtenga metadatos sobre un flujo, incluida la definición, el tamaño y el estado de exportación del flujo.
### Requisitos
Esta operación tiene los siguientes requisitos:
+ Versión mínima de AWS IoT Greengrass Core: 1.10.0
+ Versión mínima del SDK de AWS IoT Greengrass Core: Python: 1.5.0 \$1 Java: 1.4.0 \$1 Node.js: 1.6.0
### Ejemplos
El siguiente fragmento de código obtiene metadatos de una secuencia llamada `StreamName`, como su definición, su tamaño y los estados del exportador.
------
#### [ Python ]
```
client = StreamManagerClient()
try:
stream_description = client.describe_message_stream(stream_name="StreamName")
if stream_description.export_statuses[0].error_message:
# The last export of export destination 0 failed with some error
# Here is the last sequence number that was successfully exported
stream_description.export_statuses[0].last_exported_sequence_number
if (stream_description.storage_status.newest_sequence_number >
stream_description.export_statuses[0].last_exported_sequence_number):
pass
# The end of the stream is ahead of the last exported sequence number
except StreamManagerException:
pass
# Properly handle errors.
except ConnectionError or asyncio.TimeoutError:
pass
# Properly handle errors.
```
Referencia del SDK de Python: [describe\$1message\$1stream](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html#greengrasssdk.stream_manager.streammanagerclient.StreamManagerClient.describe_message_stream)
------
#### [ Java ]
```
try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) {
MessageStreamInfo description = client.describeMessageStream("StreamName");
String lastErrorMessage = description.getExportStatuses().get(0).getErrorMessage();
if (lastErrorMessage != null && !lastErrorMessage.equals("")) {
// The last export of export destination 0 failed with some error.
// Here is the last sequence number that was successfully exported.
description.getExportStatuses().get(0).getLastExportedSequenceNumber();
}
if (description.getStorageStatus().getNewestSequenceNumber() >
description.getExportStatuses().get(0).getLastExportedSequenceNumber()) {
// The end of the stream is ahead of the last exported sequence number.
}
} catch (StreamManagerException e) {
// Properly handle exception.
}
```
Referencia del SDK de Java: [describeMessageStream](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#describeMessageStream-java.lang.String-)
------
#### [ Node.js ]
```
const client = new StreamManagerClient();
client.onConnected(async () => {
try {
const description = await client.describeMessageStream("StreamName");
const lastErrorMessage = description.exportStatuses[0].errorMessage;
if (lastErrorMessage) {
// The last export of export destination 0 failed with some error.
// Here is the last sequence number that was successfully exported.
description.exportStatuses[0].lastExportedSequenceNumber;
}
if (description.storageStatus.newestSequenceNumber >
description.exportStatuses[0].lastExportedSequenceNumber) {
// The end of the stream is ahead of the last exported sequence number.
}
} catch (e) {
// Properly handle errors.
}
});
client.onError((err) => {
// Properly handle connection errors.
// This is called only when the connection to the StreamManager server fails.
});
```
Referencia del SDK de Node.js: [describeMessageStream](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#describeMessageStream)
------
## Actualización de un flujo de mensajes
Actualiza las propiedades de un flujo existente. Es posible que desee actualizar un flujo si sus requisitos cambian después de crearlo. Por ejemplo:
+ Agrega una nueva [configuración de exportación](stream-export-configurations.md) para un Nube de AWS destino.
+ Aumente el tamaño máximo de un flujo para cambiar la forma en que se exportan o conservan los datos. Por ejemplo, el tamaño del flujo, en combinación con su estrategia en la configuración completa, puede provocar que los datos se eliminen o rechacen antes de que el administrador de flujos pueda procesarlos.
+ Pausa y reanuda las exportaciones; por ejemplo, si las tareas de exportación son prolongadas y quiere racionar los datos de carga.
Las funciones de Lambda siguen este proceso de alto nivel para actualizar un flujo:
1. [Consiga la descripción del flujo.](#streammanagerclient-describe-message-stream)
1. Actualice las propiedades de destino de los objetos correspondientes `MessageStreamDefinition` y subordinados.
1. Transfiera la actualización `MessageStreamDefinition`. Asegúrese de incluir las definiciones de objetos completas para el flujo actualizado. Las propiedades no definidas revierten a los valores predeterminados.
Puede especificar el número de secuencia del mensaje que se utilizará como mensaje de inicio en la exportación.
### Requisitos
Esta operación tiene los siguientes requisitos:
+ Versión AWS IoT Greengrass básica mínima: 1.11.0
+ Versión mínima del SDK de AWS IoT Greengrass Core: Python: 1.6.0 \$1 Java: 1.5.0 \$1 Node.js: 1.7.0
### Ejemplos
El siguiente fragmento de código actualiza la secuencia llamada `StreamName`. Actualiza varias propiedades de un flujo que se exporta a Kinesis Data Streams.
------
#### [ Python ]
```
client = StreamManagerClient()
try:
message_stream_info = client.describe_message_stream(STREAM_NAME)
message_stream_info.definition.max_size=536870912
message_stream_info.definition.stream_segment_size=33554432
message_stream_info.definition.time_to_live_millis=3600000
message_stream_info.definition.strategy_on_full=StrategyOnFull.RejectNewData
message_stream_info.definition.persistence=Persistence.Memory
message_stream_info.definition.flush_on_write=False
message_stream_info.definition.export_definition.kinesis=
[KinesisConfig(
# Updating Export definition to add a Kinesis Stream configuration.
identifier=str(uuid.uuid4()), kinesis_stream_name=str(uuid.uuid4()))]
client.update_message_stream(message_stream_info.definition)
except StreamManagerException:
pass
# Properly handle errors.
except ConnectionError or asyncio.TimeoutError:
pass
# Properly handle errors.
```
Referencia del SDK de Python: [updateMessageStream](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html#greengrasssdk.stream_manager.streammanagerclient.StreamManagerClient.update_message_stream)\$1 [MessageStreamDefinition](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.MessageStreamDefinition)
------
#### [ Java ]
```
try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) {
MessageStreamInfo messageStreamInfo = client.describeMessageStream(STREAM_NAME);
// Update the message stream with new values.
client.updateMessageStream(
messageStreamInfo.getDefinition()
.withStrategyOnFull(StrategyOnFull.RejectNewData) // Required. Updating Strategy on full to reject new data.
// Max Size update should be greater than initial Max Size defined in Create Message Stream request
.withMaxSize(536870912L) // Update Max Size to 512 MB.
.withStreamSegmentSize(33554432L) // Update Segment Size to 32 MB.
.withFlushOnWrite(true) // Update flush on write to true.
.withPersistence(Persistence.Memory) // Update the persistence to Memory.
.withTimeToLiveMillis(3600000L) // Update TTL to 1 hour.
.withExportDefinition(
// Optional. Choose where/how the stream is exported to the Nube de AWS.
messageStreamInfo.getDefinition().getExportDefinition().
// Updating Export definition to add a Kinesis Stream configuration.
.withKinesis(new ArrayList() {{
add(new KinesisConfig()
.withIdentifier(EXPORT_IDENTIFIER)
.withKinesisStreamName("test"));
}})
);
} catch (StreamManagerException e) {
// Properly handle exception.
}
```
Referencia del SDK de Java: [update\$1message\$1stream](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#updateMessageStream-java.lang.String-) \$1 [MessageStreamDefinition](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/MessageStreamDefinition.html)
------
#### [ Node.js ]
```
const client = new StreamManagerClient();
client.onConnected(async () => {
try {
const messageStreamInfo = await c.describeMessageStream(STREAM_NAME);
await client.updateMessageStream(
messageStreamInfo.definition
// Max Size update should be greater than initial Max Size defined in Create Message Stream request
.withMaxSize(536870912) // Default is 256 MB. Updating Max Size to 512 MB.
.withStreamSegmentSize(33554432) // Default is 16 MB. Updating Segment Size to 32 MB.
.withTimeToLiveMillis(3600000) // By default, no TTL is enabled. Update TTL to 1 hour.
.withStrategyOnFull(StrategyOnFull.RejectNewData) // Required. Updating Strategy on full to reject new data.
.withPersistence(Persistence.Memory) // Default is File. Update the persistence to Memory
.withFlushOnWrite(true) // Default is false. Updating to true.
.withExportDefinition(
// Optional. Choose where/how the stream is exported to the Nube de AWS.
messageStreamInfo.definition.exportDefinition
// Updating Export definition to add a Kinesis Stream configuration.
.withKinesis([new KinesisConfig().withIdentifier(uuidv4()).withKinesisStreamName(uuidv4())])
)
);
} catch (e) {
// Properly handle errors.
}
});
client.onError((err) => {
// Properly handle connection errors.
// This is called only when the connection to the StreamManager server fails.
});
```
Referencia del SDK de Node.js: \$1 [updateMessageStream[MessageStreamDefinition](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.MessageStreamDefinition.html)](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#updateMessageStream)
------
### Restricciones para actualizar los flujos
Se aplican las siguientes restricciones al actualizar flujos. A menos que se indique en la siguiente lista, las actualizaciones se aplican de inmediato.
+ No puede actualizar la persistencia de un flujo. Para cambiar este comportamiento, [elimine el flujo](#streammanagerclient-delete-message-stream) y [crea un flujo](#streammanagerclient-create-message-stream) que defina la nueva política de persistencia.
+ Puede actualizar el tamaño máximo de una transmisión solo en las siguientes condiciones:
+ El tamaño máximo debe ser superior o igual al tamaño actual del flujo. Para encontrar esta información, [describa la secuencia](#streammanagerclient-describe-message-stream) y, a continuación, compruebe el estado de almacenamiento del objeto `MessageStreamInfo` devuelto.
+ El tamaño máximo debe ser superior o igual al tamaño del segmento del flujo.
+ Puede actualizar el tamaño del segmento de la transmisión a un valor inferior al tamaño máximo del flujo. La configuración actualizada se aplica a los segmentos nuevos.
+ Las actualizaciones de la propiedad tiempo de vida (TTL) se aplican a las nuevas operaciones de anexión. Si reduce este valor, es posible que el administrador de flujos también elimine los segmentos existentes que superen el TTL.
+ Las actualizaciones de la estrategia en toda la propiedad se aplican a las nuevas operaciones de anexión. Si establece la estrategia para sobrescribir los flujos de datos más antiguos, es posible que el administrador de flujos también sobrescriba los segmentos existentes en función del nuevo ajuste.
+ Las actualizaciones de la propiedad de vaciar al escribir se aplican a los mensajes nuevos.
+ Las actualizaciones de las configuraciones de exportación se aplican a las nuevas exportaciones. La solicitud de actualización debe incluir todas las configuraciones de exportación que desee admitir. De lo contrario, el administrador de flujos las elimina.
+ Al actualizar una configuración de exportación, especifique el identificador de la configuración de exportación de destino.
+ Para añadir una configuración de exportación, especifique un identificador único para la nueva configuración de exportación.
+ Para eliminar una configuración de exportación, omita la configuración de exportación.
+ Para [actualizar](#streammanagerclient-update-message-stream) el número de secuencia inicial de una configuración de exportación en un flujo, debe especificar un valor inferior al último número de secuencia. Para encontrar esta información, [describa la secuencia](#streammanagerclient-describe-message-stream) y, a continuación, compruebe el estado de almacenamiento del objeto `MessageStreamInfo` devuelto.
## Eliminación de una secuencia de mensajes
Elimina un flujo. Cuando elimina una secuencia, todos los datos almacenados para la secuencia se eliminan del disco.
### Requisitos
Esta operación tiene los siguientes requisitos:
+ Versión AWS IoT Greengrass básica mínima: 1.10.0
+ Versión mínima del SDK de AWS IoT Greengrass Core: Python: 1.5.0 \$1 Java: 1.4.0 \$1 Node.js: 1.6.0
### Ejemplos
El siguiente fragmento de código elimina la secuencia llamada `StreamName`.
------
#### [ Python ]
```
client = StreamManagerClient()
try:
client.delete_message_stream(stream_name="StreamName")
except StreamManagerException:
pass
# Properly handle errors.
except ConnectionError or asyncio.TimeoutError:
pass
# Properly handle errors.
```
Referencia del SDK de Python: [deleteMessageStream](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html#greengrasssdk.stream_manager.streammanagerclient.StreamManagerClient.delete_message_stream)
------
#### [ Java ]
```
try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) {
client.deleteMessageStream("StreamName");
} catch (StreamManagerException e) {
// Properly handle exception.
}
```
Referencia del SDK de Java: [delete\$1message\$1stream](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#deleteMessageStream-java.lang.String-)
------
#### [ Node.js ]
```
const client = new StreamManagerClient();
client.onConnected(async () => {
try {
await client.deleteMessageStream("StreamName");
} catch (e) {
// Properly handle errors.
}
});
client.onError((err) => {
// Properly handle connection errors.
// This is called only when the connection to the StreamManager server fails.
});
```
Referencia del SDK de Node.js: [deleteMessageStream](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#deleteMessageStream)
------
## 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)
+ [Exportación de configuraciones para Nube de AWS destinos compatibles](stream-export-configurations.md)
+ [Exportar flujos de datos a la Nube de AWS (consola)](stream-manager-console.md)
+ [Exportación de flujos de datos a la Nube de AWS (CLI)](stream-manager-cli.md)
+ `StreamManagerClient`en la referencia del SDK AWS IoT Greengrass principal:
+ [Python](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html)
+ [Java](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html)
+ [Node.js](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html)
# Exportación de configuraciones para Nube de AWS destinos compatibles
Las funciones Lambda definidas por el usuario se `StreamManagerClient` utilizan en AWS IoT Greengrass el SDK principal para interactuar con el administrador de transmisiones. Cuando una función de Lambda [crea un flujo](work-with-streams.md#streammanagerclient-create-message-stream) o [actualiza un flujo](work-with-streams.md#streammanagerclient-create-message-stream), pasa un objeto `MessageStreamDefinition` que representa las propiedades del flujo, incluida la definición de exportación. El objeto `ExportDefinition` contiene las configuraciones de exportación definidas para el flujo. El administrador de flujos utiliza estas configuraciones de exportación para determinar dónde y cómo exportar el flujo.
![\[Diagrama del modelo de objetos del tipo de ExportDefinition propiedad.\]](http://docs.aws.amazon.com/es_es/greengrass/v1/developerguide/images/stream-manager-exportconfigs.png)
Puede definir cero o más configuraciones de exportación en un flujo, incluidas varias configuraciones de exportación para un único tipo de destino. Por ejemplo, puede exportar un flujo a dos canales AWS IoT Analytics y a un flujo de datos de Kinesis.
En caso de intentos fallidos de exportación, el administrador del flujo vuelve a intentar exportar los datos continuamente al Nube de AWS a intervalos de hasta cinco minutos. La cantidad de reintentos no tiene un límite máximo.
**nota**
`StreamManagerClient` también proporciona un destino que puede utilizar para exportar secuencias a un servidor HTTP. Este destino está pensado solo con fines de prueba. No es estable y no se admite para su uso en entornos de producción.
**Topics**
+ [AWS IoT Analytics canales](#export-to-iot-analytics)
+ [Amazon Kinesis Data Streams](#export-to-kinesis)
+ [AWS IoT SiteWise propiedades de los activos](#export-to-iot-sitewise)
+ [Objetos de Amazon S3](#export-to-s3)
Usted es responsable del mantenimiento de estos Nube de AWS recursos.
## AWS IoT Analytics canales
El administrador de transmisiones admite exportaciones automáticas a AWS IoT Analytics. AWS IoT Analytics le permite realizar análisis avanzados de sus datos para ayudarle a tomar decisiones empresariales y mejorar los modelos de aprendizaje automático. Para obtener más información, consulte [¿Qué es AWS IoT Analytics?](https://docs.aws.amazon.com/iotanalytics/latest/userguide/welcome.html) en la *Guía AWS IoT Analytics del usuario*.
En el SDK AWS IoT Greengrass principal, las funciones de Lambda utilizan el `IoTAnalyticsConfig` para definir la configuración de exportación para este tipo de destino. Para obtener más información, consulte la referencia del SDK para el lenguaje de destino.
+ [Io TAnalytics Config](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.IoTAnalyticsConfig) en el SDK de Python
+ [Io TAnalytics Config](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/export/IoTAnalyticsConfig.html) en el SDK de Java
+ [Io TAnalytics Config](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.IoTAnalyticsConfig.html) en el SDK de Node.js
### Requisitos
Este destino de exportación tiene los siguientes requisitos:
+ Los canales de destino AWS IoT Analytics deben estar en el mismo grupo Cuenta de AWS y Región de AWS en el grupo Greengrass.
+ El [Rol de grupo de Greengrass](group-role.md) debe permitir el permiso `iotanalytics:BatchPutMessage` para segmentar los canales. Por ejemplo:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iotanalytics:BatchPutMessage"
],
"Resource": [
"arn:aws:iotanalytics:us-east-1:123456789012:channel/channel_1_name",
"arn:aws:iotanalytics:us-east-1:123456789012:channel/channel_2_name"
]
}
]
}
```
------
Puede conceder acceso granular o condicional a recursos (por ejemplo, utilizando un esquema de nomenclatura con comodín `*`) Para obtener más información, consulte [Adición y eliminación de políticas de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) en la *Guía del usuario de IAM*.
### Exportando a AWS IoT Analytics
Para crear una transmisión a la que se exporte AWS IoT Analytics, las funciones de Lambda [crean una transmisión](work-with-streams.md#streammanagerclient-create-message-stream) con una definición de exportación que incluye uno o más `IoTAnalyticsConfig` objetos. Este objeto define los ajustes de exportación, como el canal de destino, el tamaño del lote, el intervalo del lote y la prioridad.
Cuando sus funciones de Lambda reciben datos de los dispositivos, [anexan mensajes](work-with-streams.md#streammanagerclient-append-message) que contienen una masa de datos al flujo de destino.
A continuación, el administrador de flujos exporta los datos en función de los ajustes del lote y la prioridad definidos en las configuraciones de exportación del flujo.
## Amazon Kinesis Data Streams
El administrador de flujos permite exportar automáticamente a Amazon Kinesis Data Streams. Kinesis Data Streams se suele utilizar para agregar grandes volúmenes de datos y cargarlos en un almacenamiento de datos o en un clúster de map-reduce. Para obtener más información, consulte [Qué son los Amazon Kinesis Data Streams](https://docs.aws.amazon.com/streams/latest/dev/what-is-this-service.html) en la *Guía para desarrolladores de Amazon Kinesis*.
En el SDK AWS IoT Greengrass principal, las funciones de Lambda utilizan el `KinesisConfig` para definir la configuración de exportación para este tipo de destino. Para obtener más información, consulte la referencia del SDK para el lenguaje de destino.
+ [KinesisConfig](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.KinesisConfig)en el SDK de Python
+ [KinesisConfig](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/export/KinesisConfig.html)en el SDK de Java
+ [KinesisConfig](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.KinesisConfig.html)en el SDK de Node.js
### Requisitos
Este destino de exportación tiene los siguientes requisitos:
+ Las transmisiones de destino de Kinesis Data Streams deben estar en el Cuenta de AWS mismo grupo Greengrass Región de AWS y deben estar en el mismo grupo.
+ El [Rol de grupo de Greengrass](group-role.md) debe conceder el permiso `kinesis:PutRecords` para destinar flujos de datos. Por ejemplo:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"kinesis:PutRecords"
],
"Resource": [
"arn:aws:kinesis:us-east-1:123456789012:stream/stream_1_name",
"arn:aws:kinesis:us-east-1:123456789012:stream/stream_2_name"
]
}
]
}
```
------
Puede conceder acceso granular o condicional a recursos (por ejemplo, utilizando un esquema de nomenclatura con comodín `*`) Para obtener más información, consulte [Adición y eliminación de políticas de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) en la *Guía del usuario de IAM*.
### Exportación a Kinesis Data Streams
Para crear un flujo que se exporte a Kinesis Data Streams, sus funciones de Lambda [crean un flujo](work-with-streams.md#streammanagerclient-create-message-stream) con una definición de exportación que incluye uno o más objetos `KinesisConfig`. Este objeto define los ajustes de exportación, como el flujo de datos de destino, el tamaño del lote, el intervalo del lote y la prioridad.
Cuando sus funciones de Lambda reciben datos de los dispositivos, [anexan mensajes](work-with-streams.md#streammanagerclient-append-message) que contienen una masa de datos al flujo de destino. A continuación, el administrador de flujos exporta los datos en función de los ajustes del lote y la prioridad definidos en las configuraciones de exportación del flujo.
El administrador de flujos genera un UUID aleatorio único como clave de partición para cada registro cargado en Amazon Kinesis.
## AWS IoT SiteWise propiedades de los activos
Stream Manager admite la exportación automática a AWS IoT SiteWise. AWS IoT SiteWise le permite recopilar, organizar y analizar datos de equipos industriales a escala. Para obtener más información, consulte [¿Qué es AWS IoT SiteWise?](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/what-is-sitewise.html) en la *Guía AWS IoT SiteWise del usuario*.
En el SDK AWS IoT Greengrass principal, las funciones de Lambda utilizan el `IoTSiteWiseConfig` para definir la configuración de exportación para este tipo de destino. Para obtener más información, consulte la referencia del SDK para el lenguaje de destino.
+ [Io TSite WiseConfig](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.IoTSiteWiseConfig) en el SDK de Python
+ [Io TSite WiseConfig](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/export/IoTSiteWiseConfig.html) en el SDK de Java
+ [Io TSite WiseConfig](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.IoTSiteWiseConfig.html) en el SDK de Node.js
**nota**
AWS también proporciona la[SiteWise Conector IoT](iot-sitewise-connector.md), que es una solución prediseñada que se puede utilizar con fuentes OPC-UA.
### Requisitos
Este destino de exportación tiene los siguientes requisitos:
+ Las propiedades de los activos objetivo AWS IoT SiteWise deben estar en el mismo grupo Greengrass Cuenta de AWS y Región de AWS al mismo grupo.
**nota**
Para ver la lista de regiones AWS IoT SiteWise compatibles, consulte los [AWS IoT SiteWise puntos finales y las cuotas](https://docs.aws.amazon.com/general/latest/gr/iot-sitewise.html#iot-sitewise_region) en la Referencia *AWS general*.
+ [Rol de grupo de Greengrass](group-role.md)El `iotsitewise:BatchPutAssetPropertyValue` debe permitir que el permiso se dirija a las propiedades de los activos. El siguiente ejemplo de política utiliza la clave `iotsitewise:assetHierarchyPath` de condición para conceder acceso a un activo raíz de destino y a sus elementos secundarios. Puede eliminarlas `Condition` de la política para permitir el acceso a todos sus AWS IoT SiteWise activos o especificar ARNs activos individuales.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iotsitewise:BatchPutAssetPropertyValue",
"Resource": "*",
"Condition": {
"StringLike": {
"iotsitewise:assetHierarchyPath": [
"/root node asset ID",
"/root node asset ID/*"
]
}
}
}
]
}
```
------
Puede conceder acceso granular o condicional a recursos (por ejemplo, utilizando un esquema de nomenclatura con comodín `*`) Para obtener más información, consulte [Adición y eliminación de políticas de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) en la *Guía del usuario de IAM*.
Para obtener información de seguridad importante, consulte la [ BatchPutAssetPropertyValue autorización](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/security_iam_service-with-iam.html#security_iam_service-with-iam-id-based-policies-batchputassetpropertyvalue-action) en la *Guía del AWS IoT SiteWise usuario*.
### Exportación a AWS IoT SiteWise
Para crear una transmisión a la que se exporte AWS IoT SiteWise, las funciones de Lambda [crean una transmisión](work-with-streams.md#streammanagerclient-create-message-stream) con una definición de exportación que incluye uno o más `IoTSiteWiseConfig` objetos. Este objeto define los ajustes de exportación, como el tamaño del lote, el intervalo del lote y la prioridad.
Cuando sus funciones de Lambda reciben datos de propiedades de activos desde dispositivos, agregan mensajes que contienen esos datos al flujo de destino. Los mensajes son objetos `PutAssetPropertyValueEntry` serializados en JSON que contienen los valores de propiedad de una o más propiedades de los activos. Para obtener más información, consulte [Añadir un mensaje](work-with-streams.md#streammanagerclient-append-message-sitewise) para los AWS IoT SiteWise destinos de exportación.
**nota**
Al enviar datos a AWS IoT SiteWise, estos deben cumplir los requisitos de la `BatchPutAssetPropertyValue` acción. Para obtener más información, consulta [BatchPutAssetPropertyValue](https://docs.aws.amazon.com/iot-sitewise/latest/APIReference/API_BatchPutAssetPropertyValue.html) en la *AWS IoT SiteWise Referencia de la API de *.
A continuación, el administrador de flujos exporta los datos en función de los ajustes del lote y la prioridad definidos en las configuraciones de exportación del flujo.
Puede ajustar los ajustes del administrador de flujos y la lógica de la función de Lambda para diseñar su estrategia de exportación. Por ejemplo:
+ Para realizar exportaciones prácticamente en tiempo real, establezca ajustes del tamaño de lote e intervalos bajos y añada los datos al flujo cuando lo reciba.
+ Para optimizar el procesamiento por lotes, mitigar las restricciones de ancho de banda o minimizar los costos, las funciones de Lambda pueden agrupar timestamp-quality-value los puntos de datos (TQV) recibidos para una sola propiedad de activo antes de agregar los datos a la transmisión. Una estrategia consiste en agrupar las entradas de hasta 10 combinaciones diferentes de propiedades y activos (o alias de propiedades) en un mensaje, en lugar de enviar más de una entrada para la misma propiedad. Esto ayuda al Administrador de flujos a mantenerse dentro de las [cuotas de AWS IoT SiteWise](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/quotas.html).
## Objetos de Amazon S3
El administrador de flujos permite exportar automáticamente a Amazon S3. Puede utilizar Amazon S3 para almacenar y recuperar grandes cantidades de datos. Para obtener más información, consulte [¿Qué es Amazon S3?](https://docs.aws.amazon.com/AmazonS3/latest/dev/Welcome.html) en la *Guía para desarrolladores de Amazon Simple Storage Service*.
En el SDK AWS IoT Greengrass principal, las funciones de Lambda utilizan el `S3ExportTaskExecutorConfig` para definir la configuración de exportación para este tipo de destino. Para obtener más información, consulte la referencia del SDK para el lenguaje de destino.
+ [S3 ExportTaskExecutorConfig](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.S3ExportTaskExecutorConfig) en el SDK de Python
+ [S3 ExportTaskExecutorConfig](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/export/S3ExportTaskExecutorConfig.html) en el SDK de Java
+ [S3 ExportTaskExecutorConfig](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.S3ExportTaskExecutorConfig.html) en el SDK de Node.js
### Requisitos
Este destino de exportación tiene los siguientes requisitos:
+ Los buckets de Amazon S3 de destino deben estar en el mismo grupo Cuenta de AWS que los de Greengrass.
+ Si la [contenerización predeterminada](lambda-group-config.md#lambda-containerization-groupsettings) para el grupo de Greengrass es el **contenedor de Greengrass**, debe configurar el parámetro [STREAM\$1MANAGER\$1READ\$1ONLY\$1DIRS](configure-stream-manager.md#stream-manager-read-only-directories) para usar un directorio de archivos de entrada que esté en `/tmp` o no esté en el sistema de archivos raíz.
+ Si una función de Lambda que se ejecuta en el modo **contenedor de Greengrass** escribe archivos de entrada en el directorio de archivos de entrada, usted debe crear un recurso de volumen local para el directorio y montar el directorio en el contenedor con permisos de escritura. Esto garantiza que los archivos se escriban en el sistema de archivos raíz y que sean visibles fuera del contenedor. Para obtener más información, consulte [Acceder a recursos locales con conectores y funciones de Lambda](access-local-resources.md).
+ El [Rol de grupo de Greengrass](group-role.md) debe permitir los siguientes permisos para los buckets de destino. Por ejemplo:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:AbortMultipartUpload",
"s3:ListMultipartUploadParts"
],
"Resource": [
"arn:aws:s3:::bucket-1-name/*",
"arn:aws:s3:::bucket-2-name/*"
]
}
]
}
```
------
Puede conceder acceso granular o condicional a recursos (por ejemplo, utilizando un esquema de nomenclatura con comodín `*`) Para obtener más información, consulte [Adición y eliminación de políticas de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) en la *Guía del usuario de IAM*.
### Exportación a Amazon S3
Para crear un flujo que se exporte a Amazon S3, las funciones de Lambda utilizan el objeto `S3ExportTaskExecutorConfig` para configurar la política de exportación. La política define los ajustes de exportación, como el umbral de carga multiparte y la prioridad. Para las exportaciones de Amazon S3, el administrador de flujos carga los datos que lee de los archivos locales en el dispositivo principal. Para iniciar una carga, sus funciones de Lambda anexan una tarea de exportación al flujo de destino. La tarea de exportación contiene información sobre el archivo de entrada y el objeto Amazon S3 de destino. El administrador de flujos ejecuta las tareas en la secuencia en que se anexan al flujo.
**nota**
El depósito de destino ya debe existir en su. Cuenta de AWS Si no existe un objeto para la clave especificada, el administrador de flujos crea el objeto automáticamente.
Este flujo de alto nivel se muestra en el siguiente diagrama.
![\[Diagrama del flujo de trabajo del administrador de flujos para las exportaciones de Amazon S3.\]](http://docs.aws.amazon.com/es_es/greengrass/v1/developerguide/images/stream-manager-s3.png)
El administrador de flujos utiliza la propiedad de umbral de carga multiparte, el ajuste del [tamaño mínimo de las piezas](configure-stream-manager.md#stream-manager-minimum-part-size) y el tamaño del archivo de entrada para determinar cómo cargar los datos. El umbral de carga multiparte debe ser igual o mayor que el tamaño mínimo de la pieza. Si desea cargar datos en paralelo, puede crear varios flujos.
Las claves que especifican los objetos de Amazon S3 de destino pueden incluir DateTimeFormatter cadenas [Java](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html) válidas en `!{timestamp:value}` los marcadores de posición. Puede utilizar estos marcadores de fecha y hora para particionar los datos en Amazon S3 en función de la hora en la que se cargaron los datos del archivo de entrada. Por ejemplo, el siguiente nombre de clave se resuelve en un valor como `my-key/2020/12/31/data.txt`.
```
my-key/!{timestamp:YYYY}/!{timestamp:MM}/!{timestamp:dd}/data.txt
```
**nota**
Si desea supervisar el estado de exportación de un flujo, cree primero un flujo de estado y, a continuación, configure el flujo de exportación para utilizarlo. Para obtener más información, consulte [Supervise las tareas de exportación](#monitor-export-status-s3).
#### Administración de datos de entrada
Puede crear un código que las aplicaciones de IoT usen para administrar el ciclo de vida de los datos de entrada. El siguiente ejemplo de flujo de trabajo muestra cómo se pueden utilizar las funciones de Lambda para administrar estos datos.
1. Un proceso local recibe datos de dispositivos o periféricos y, a continuación, los escribe en los archivos de un directorio del dispositivo principal. Estos son los archivos de entrada del administrador de flujos.
**nota**
Para determinar si debe configurar el acceso al directorio de archivos de entrada, consulte el parámetro [STREAM\$1MANAGER\$1READ\$1ONLY\$1DIRS](configure-stream-manager.md#stream-manager-read-only-directories).
El proceso en el que se ejecuta el administrador de flujos hereda todos los permisos del sistema de archivos de la [identidad de acceso predeterminada](lambda-group-config.md#lambda-access-identity-groupsettings) del grupo. El administrador de flujos debe tener permiso de acceso a los archivos de entrada. Puede utilizar el comando `chmod(1)` para cambiar el permiso de los archivos, si es necesario.
1. Una función de Lambda escanea el directorio y [anexa una tarea de exportación](work-with-streams.md#streammanagerclient-append-message-export-task) a la secuencia de destino cuando se crea un archivo nuevo. La tarea es un objeto `S3ExportTaskDefinition` serializado en JSON que especifica la URL del archivo de entrada, el bucket y la clave de Amazon S3 de destino y los metadatos de usuario opcionales.
1. El administrador de flujos lee el archivo de entrada y exporta los datos a Amazon S3 en el orden de las tareas anexas. El bucket de destino ya debe existir en su. Cuenta de AWS Si no existe un objeto para la clave especificada, el administrador de flujos crea el objeto automáticamente.
1. La función de Lambda [lee los mensajes](work-with-streams.md#streammanagerclient-read-messages) de un flujo de estado para supervisar el estado de la exportación. Una vez finalizadas las tareas de exportación, la función de Lambda puede eliminar los archivos de entrada correspondientes. Para obtener más información, consulte [Supervise las tareas de exportación](#monitor-export-status-s3).
### Supervise las tareas de exportación
Puede crear un código que las aplicaciones de IoT utilizan para monitorear el estado de sus exportaciones de Amazon S3. Las funciones de Lambda deben crear un flujo de estado y, a continuación, configurar el flujo de exportación para escribir actualizaciones de estado en el flujo de estado. Una sola transmisión de estado puede recibir actualizaciones de estado de varias transmisiones que se exportan a Amazon S3.
En primer lugar, [cree un flujo](work-with-streams.md#streammanagerclient-create-message-stream) para utilizarlo como flujo de estado. Puede configurar las políticas de tamaño y retención del flujo para controlar la vida útil de los mensajes de estado. Por ejemplo:
+ Configure `Persistence` en `Memory` si no desea guardar los mensajes de estado.
+ Configure `StrategyOnFull` en `OverwriteOldestData` para que no se pierdan los nuevos mensajes de estado.
A continuación, cree o actualice el flujo de exportación para usar el flujo de estado. En concreto, defina la propiedad de configuración de estado de la configuración de `S3ExportTaskExecutorConfig` exportación del flujo. Esto le indica al administrador del flujo que escriba mensajes de estado sobre las tareas de exportación en el flujo de estado. En el objeto `StatusConfig`, especifique el nombre del flujo de estado y el nivel de detalle. Los siguientes valores admitidos van desde el menos detallado (`ERROR`) al más detallado (). `TRACE` El valor predeterminado es `INFO`.
+ `ERROR`
+ `WARN`
+ `INFO`
+ `DEBUG`
+ `TRACE`
El siguiente ejemplo de flujo de trabajo muestra cómo las funciones de Lambda pueden utilizar un flujo de estado para supervisar el estado de la exportación.
1. Como se describió en el flujo de trabajo anterior, una función de Lambda [anexa una tarea de exportación a un](work-with-streams.md#streammanagerclient-append-message-export-task) flujo que está configurado para escribir mensajes de estado sobre las tareas de exportación en un flujo de estado. La operación de incorporación devuelve un número de secuencia que representa el ID de la tarea.
1. Una función de Lambda [lee los mensajes](work-with-streams.md#streammanagerclient-read-messages) secuencialmente del flujo de estado y, a continuación, filtra los mensajes en función del nombre del flujo y el identificador de la tarea o en función de una propiedad de la tarea de exportación del contexto del mensaje. Por ejemplo, la función de Lambda puede filtrar por la URL del archivo de entrada de la tarea de exportación, que está representada por el objeto `S3ExportTaskDefinition` en el contexto del mensaje.
Los siguientes códigos de estado indican que una tarea de exportación ha alcanzado un estado completo:
+ `Success`. Se ha completado correctamente la carga.
+ `Failure`. El administrador de flujos detectó un error; por ejemplo, el bucket especificado no existe. Tras resolver el problema, puede volver a añadir la tarea de exportación al flujo.
+ `Canceled`. La tarea se canceló porque se eliminó la definición de transmisión o exportación o porque el período time-to-live (TTL) de la tarea expiró.
**nota**
La tarea también puede tener un estado de `InProgress` o `Warning`. El administrador de flujos emite advertencias cuando un evento devuelve un error que no afecta a la ejecución de la tarea. Por ejemplo, si no se limpia una carga parcial cancelada, aparecerá una advertencia.
1. Una vez finalizadas las tareas de exportación, la función de Lambda puede eliminar los archivos de entrada correspondientes.
El siguiente ejemplo muestra cómo una función de Lambda puede leer y procesar los mensajes de estado.
------
#### [ Python ]
```
import time
from greengrasssdk.stream_manager import (
ReadMessagesOptions,
Status,
StatusConfig,
StatusLevel,
StatusMessage,
StreamManagerClient,
)
from greengrasssdk.stream_manager.util import Util
client = StreamManagerClient()
try:
# Read the statuses from the export status stream
is_file_uploaded_to_s3 = False
while not is_file_uploaded_to_s3:
try:
messages_list = client.read_messages(
"StatusStreamName", ReadMessagesOptions(min_message_count=1, read_timeout_millis=1000)
)
for message in messages_list:
# Deserialize the status message first.
status_message = Util.deserialize_json_bytes_to_obj(message.payload, StatusMessage)
# Check the status of the status message. If the status is "Success",
# the file was successfully uploaded to S3.
# If the status was either "Failure" or "Cancelled", the server was unable to upload the file to S3.
# We will print the message for why the upload to S3 failed from the status message.
# If the status was "InProgress", the status indicates that the server has started uploading
# the S3 task.
if status_message.status == Status.Success:
logger.info("Successfully uploaded file at path " + file_url + " to S3.")
is_file_uploaded_to_s3 = True
elif status_message.status == Status.Failure or status_message.status == Status.Canceled:
logger.info(
"Unable to upload file at path " + file_url + " to S3. Message: " + status_message.message
)
is_file_uploaded_to_s3 = True
time.sleep(5)
except StreamManagerException:
logger.exception("Exception while running")
except StreamManagerException:
pass
# Properly handle errors.
except ConnectionError or asyncio.TimeoutError:
pass
# Properly handle errors.
```
Referencia del SDK de Python: [read\$1messages \$1 [StatusMessage](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.StatusMessage)](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html#greengrasssdk.stream_manager.streammanagerclient.StreamManagerClient.read_messages)
------
#### [ Java ]
```
import com.amazonaws.greengrass.streammanager.client.StreamManagerClient;
import com.amazonaws.greengrass.streammanager.client.utils.ValidateAndSerialize;
import com.amazonaws.greengrass.streammanager.model.ReadMessagesOptions;
import com.amazonaws.greengrass.streammanager.model.Status;
import com.amazonaws.greengrass.streammanager.model.StatusConfig;
import com.amazonaws.greengrass.streammanager.model.StatusLevel;
import com.amazonaws.greengrass.streammanager.model.StatusMessage;
try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) {
try {
boolean isS3UploadComplete = false;
while (!isS3UploadComplete) {
try {
// Read the statuses from the export status stream
List messages = client.readMessages("StatusStreamName",
new ReadMessagesOptions().withMinMessageCount(1L).withReadTimeoutMillis(1000L));
for (Message message : messages) {
// Deserialize the status message first.
StatusMessage statusMessage = ValidateAndSerialize.deserializeJsonBytesToObj(message.getPayload(), StatusMessage.class);
// Check the status of the status message. If the status is "Success", the file was successfully uploaded to S3.
// If the status was either "Failure" or "Canceled", the server was unable to upload the file to S3.
// We will print the message for why the upload to S3 failed from the status message.
// If the status was "InProgress", the status indicates that the server has started uploading the S3 task.
if (Status.Success.equals(statusMessage.getStatus())) {
System.out.println("Successfully uploaded file at path " + FILE_URL + " to S3.");
isS3UploadComplete = true;
} else if (Status.Failure.equals(statusMessage.getStatus()) || Status.Canceled.equals(statusMessage.getStatus())) {
System.out.println(String.format("Unable to upload file at path %s to S3. Message %s",
statusMessage.getStatusContext().getS3ExportTaskDefinition().getInputUrl(),
statusMessage.getMessage()));
sS3UploadComplete = true;
}
}
} catch (StreamManagerException ignored) {
} finally {
// Sleep for sometime for the S3 upload task to complete before trying to read the status message.
Thread.sleep(5000);
}
} catch (e) {
// Properly handle errors.
}
} catch (StreamManagerException e) {
// Properly handle exception.
}
```
Referencia del SDK de Java: [readMessages \$1 [StatusMessage](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/StatusMessage.html)](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#readMessages-java.lang.String-com.amazonaws.greengrass.streammanager.model.ReadMessagesOptions-)
------
#### [ Node.js ]
```
const {
StreamManagerClient, ReadMessagesOptions,
Status, StatusConfig, StatusLevel, StatusMessage,
util,
} = require('aws-greengrass-core-sdk').StreamManager;
const client = new StreamManagerClient();
client.onConnected(async () => {
try {
let isS3UploadComplete = false;
while (!isS3UploadComplete) {
try {
// Read the statuses from the export status stream
const messages = await c.readMessages("StatusStreamName",
new ReadMessagesOptions()
.withMinMessageCount(1)
.withReadTimeoutMillis(1000));
messages.forEach((message) => {
// Deserialize the status message first.
const statusMessage = util.deserializeJsonBytesToObj(message.payload, StatusMessage);
// Check the status of the status message. If the status is 'Success', the file was successfully uploaded to S3.
// If the status was either 'Failure' or 'Cancelled', the server was unable to upload the file to S3.
// We will print the message for why the upload to S3 failed from the status message.
// If the status was "InProgress", the status indicates that the server has started uploading the S3 task.
if (statusMessage.status === Status.Success) {
console.log(`Successfully uploaded file at path ${FILE_URL} to S3.`);
isS3UploadComplete = true;
} else if (statusMessage.status === Status.Failure || statusMessage.status === Status.Canceled) {
console.log(`Unable to upload file at path ${FILE_URL} to S3. Message: ${statusMessage.message}`);
isS3UploadComplete = true;
}
});
// Sleep for sometime for the S3 upload task to complete before trying to read the status message.
await new Promise((r) => setTimeout(r, 5000));
} catch (e) {
// Ignored
}
} catch (e) {
// Properly handle errors.
}
});
client.onError((err) => {
// Properly handle connection errors.
// This is called only when the connection to the StreamManager server fails.
});
```
Referencia del SDK de Node.js: [readMessages \$1 [StatusMessage](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StatusMessage.html)](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#readMessages)
------
# 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)
# Exportación de flujos de datos a la Nube de AWS (CLI)
Este tutorial le muestra cómo usarlo AWS CLI para configurar e implementar un AWS IoT Greengrass grupo con el administrador de transmisiones habilitado. 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.
Cuando utilizas la AWS IoT Greengrass API, que incluye los comandos de Greengrass en AWS CLI, para crear un grupo, el administrador de transmisiones está deshabilitado de forma predeterminada. Para habilitar el administrador de flujos en su núcleo, [cree una versión de definición de función](#stream-manager-cli-create-function-definition) que incluya la función de Lambda de `GGStreamManager` del sistema y una versión de grupo que haga referencia a la nueva versión de definición de función. A continuación, implemente el grupo.
## 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"
]
}
]
}
```
------
+ La AWS CLI instalada y configurada en su ordenador. Para obtener más información, consulte [Instalación de la AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) y [Configuración de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) en la *Guía del usuario de la AWS Command Line Interface *.
Los comandos de ejemplo de este tutorial están escritos para Linux y otros sistemas basados en Unix. Si utiliza Windows, consulte [Especificar los valores de los parámetros de la interfaz de línea de AWS comandos](https://docs.aws.amazon.com/cli/latest/userguide/cli-using-param.html) para obtener más información sobre las diferencias de sintaxis.
Si el comando contiene una cadena JSON, el tutorial ofrece un ejemplo que tiene el JSON en una sola línea. En algunos sistemas, puede que sea más eficiente editar y ejecutar comandos con este formato.
El tutorial contiene los siguientes pasos generales:
1. [Creación de un paquete de implementación de la función de Lambda](#stream-manager-cli-create-deployment-package)
1. [Crear una función de Lambda](#stream-manager-cli-create-function)
1. [Crear una versión y una definición de la función](#stream-manager-cli-create-function-definition)
1. [Crear una versión y una definición del registrador](#stream-manager-cli-create-logger-definition)
1. [Obtener el ARN de la versión de la definición del núcleo](#stream-manager-cli-get-core-definition-version-arn)
1. [Cree una versión del grupo](#stream-manager-cli-create-group-version)
1. [Creación de una implementación](#stream-manager-cli-create-deployment)
1. [Pruebe la aplicación](#stream-manager-cli-test-application)
Completar el tutorial debería tomarle aproximadamente 30 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
1. Cree un rol de IAM para poder pasar el ARN del rol cuando cree la función.
------
#### [ JSON Expanded ]
```
aws iam create-role --role-name Lambda_empty --assume-role-policy '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}'
```
------
#### [ JSON Single-line ]
```
aws iam create-role --role-name Lambda_empty --assume-role-policy '{"Version": "2012-10-17", "Statement": [{"Effect": "Allow", "Principal": {"Service": "lambda.amazonaws.com"},"Action": "sts:AssumeRole"}]}'
```
------
**nota**
AWS IoT Greengrass no usa este rol porque los permisos para sus funciones Lambda de Greengrass se especifican en el rol de grupo de Greengrass. En este tutorial, va a crear un rol vacío.
1. Copie la `Arn` del resultado.
1. Utilice la AWS Lambda API para crear la función. `TransferStream` El siguiente comando da por hecho que el archivo ZIP está en el directorio actual.
+ Reemplace *role-arn* por el `Arn` que ha copiado.
```
aws lambda create-function \
--function-name TransferStream \
--zip-file fileb://transfer_stream_python.zip \
--role role-arn \
--handler transfer_stream.function_handler \
--runtime python3.7
```
1. Publique una versión de la función.
```
aws lambda publish-version --function-name TransferStream --description 'First version'
```
1. Cree un alias a la versión publicada.
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.
```
aws lambda create-alias --function-name TransferStream --name GG_TransferStream --function-version 1
```
**nota**
AWS IoT Greengrass **no admite los alias de Lambda para las versiones \$1LATEST.**
1. Copie la `AliasArn` del resultado. Este valor se utiliza al configurar la función para. AWS IoT Greengrass
Ahora está listo para configurar la función para AWS IoT Greengrass.
## Paso 3: Crear una versión y una definición de la función
Este paso crea una versión de definición de función que hace referencia a la función de Lambda `GGStreamManager` del sistema y a la función de Lambda `TransferStream` definida por el usuario. Para habilitar el administrador de transmisiones al usar la AWS IoT Greengrass API, la versión de definición de funciones debe incluir la `GGStreamManager` función.
1. Cree una definición de función con una versión inicial que contenga las funciones de Lambda del sistema y definidas por el usuario.
Con la siguiente versión de definición se habilita al administrador de flujos con la [configuración de parámetros](configure-stream-manager.md) predeterminada. Para configurar parámetros personalizados, debe definir variables de entorno para los parámetros correspondientes del administrador de flujos. Para ver un ejemplo, consulte[Para habilitar, deshabilitar o configurar el administrador de flujos (CLI)](configure-stream-manager.md#enable-stream-manager-cli). AWS IoT Greengrass utiliza la configuración predeterminada para los parámetros que se omiten. `MemorySize`debería ser al menos`128000`. `Pinned`debe estar configurado en`true`.
**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).
+ *arbitrary-function-id*Sustitúyala por un nombre para la función, como. **stream-manager**
+ *alias-arn*Sustitúyalo por el `AliasArn` que copió al crear el alias de la `TransferStream` función Lambda.
------
#### [ JSON expanded ]
```
aws greengrass create-function-definition --name MyGreengrassFunctions --initial-version '{
"Functions": [
{
"Id": "arbitrary-function-id",
"FunctionArn": "arn:aws:lambda:::function:GGStreamManager:1",
"FunctionConfiguration": {
"MemorySize": 128000,
"Pinned": true,
"Timeout": 3
}
},
{
"Id": "TransferStreamFunction",
"FunctionArn": "alias-arn",
"FunctionConfiguration": {
"Executable": "transfer_stream.function_handler",
"MemorySize": 16000,
"Pinned": true,
"Timeout": 5
}
}
]
}'
```
------
#### [ JSON single ]
```
aws greengrass create-function-definition \
--name MyGreengrassFunctions \
--initial-version '{"Functions": [{"Id": "arbitrary-function-id","FunctionArn": "arn:aws:lambda:::function:GGStreamManager:1", "FunctionConfiguration": {"Environment": {"Variables":{"STREAM_MANAGER_STORE_ROOT_DIR": "/data","STREAM_MANAGER_SERVER_PORT": "1234","STREAM_MANAGER_EXPORTER_MAX_BANDWIDTH": "20000"}},"MemorySize": 128000,"Pinned": true,"Timeout": 3}},{"Id": "TransferStreamFunction", "FunctionArn": "alias-arn", "FunctionConfiguration": {"Executable": "transfer_stream.function_handler", "MemorySize": 16000,"Pinned": true,"Timeout": 5}}]}'
```
------
**nota**
`Timeout` es necesario para la versión de definición de característica, pero `GGStreamManager` no lo usa. Para obtener más información sobre `Timeout` y otras configuraciones a nivel de grupo, 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. Copie la `LatestVersionArn` del resultado. Este valor se usa para añadir la versión de la definición de función a la versión de grupo que implementó en el núcleo.
## Paso 4: Crear una versión y una definición del registrador
Defina la configuración de registro del grupo. En este tutorial, configurará los componentes AWS IoT Greengrass del sistema, las funciones Lambda definidas por el usuario y los conectores 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. Cree una definición del registro que incluya una versión inicial.
------
#### [ JSON Expanded ]
```
aws greengrass create-logger-definition --name "LoggingConfigs" --initial-version '{
"Loggers": [
{
"Id": "1",
"Component": "GreengrassSystem",
"Level": "INFO",
"Space": 10240,
"Type": "FileSystem"
},
{
"Id": "2",
"Component": "Lambda",
"Level": "INFO",
"Space": 10240,
"Type": "FileSystem"
}
]
}'
```
------
#### [ JSON Single-line ]
```
aws greengrass create-logger-definition \
--name "LoggingConfigs" \
--initial-version '{"Loggers":[{"Id":"1","Component":"GreengrassSystem","Level":"INFO","Space":10240,"Type":"FileSystem"},{"Id":"2","Component":"Lambda","Level":"INFO","Space":10240,"Type":"FileSystem"}]}'
```
------
1. Copie el `LatestVersionArn` de la definición del registro del resultado. Este valor se usa para añadir la versión de definición del registro a la versión del grupo que implementa en el núcleo.
## Paso 5: Obtener el ARN de la versión de la definición del núcleo
Obtenga el ARN de la versión de definición del núcleo para agregar a su nueva versión de grupo. Para implementar una versión de grupo, debe hacer referencia a una versión de definición de núcleo que contenga exactamente un núcleo.
1. Obtenga el grupo y IDs la versión grupal de Greengrass objetivo. En este procedimiento, suponemos que estos son el último grupo y la última versión de grupo. La siguiente consulta devuelve el grupo creado más recientemente.
```
aws greengrass list-groups --query "reverse(sort_by(Groups, &CreationTimestamp))[0]"
```
También puede hacer la consulta por nombre. No es necesario que los nombres de grupo sean únicos, por lo que podrían devolverse varios grupos.
```
aws greengrass list-groups --query "Groups[?Name=='MyGroup']"
```
**nota**
También puede encontrar estos valores en la AWS IoT consola. El ID de grupo se muestra en la página **Settings (Configuración)** del grupo. La versión del grupo IDs se muestra en la pestaña **Implementaciones** del grupo.
1. Copie el `Id` del grupo de destino de la salida. Puede utilizar esto para obtener la versión de la definición de núcleo y al implementar el grupo.
1. Copie el `LatestVersion` del resultado, que es el ID de la última versión añadida al grupo. Puede utilizar esto para obtener la versión de la definición de núcleo.
1. Obtenga el ARN de la versión de la definición principal:
1. Obtenga la versión de grupo.
+ *group-id*Sustitúyala por la `Id` que copiaste para el grupo.
+ *group-version-id*Sustitúyala por la `LatestVersion` que copiaste para el grupo.
```
aws greengrass get-group-version \
--group-id group-id \
--group-version-id group-version-id
```
1. Copie la `CoreDefinitionVersionArn` del resultado. Este valor se usa para añadir la versión de la definición del núcleo a la versión de grupo que implementó en el núcleo.
## Paso 6: Crear una versión del grupo
Ahora, puede crear una versión de grupo que contenga las entidades que desea implementar. Para ello, cree una versión de grupo que haga referencia a la versión de destino de cada tipo de componente. Para este tutorial, incluirá una versión de definición de núcleo, una versión de definición de función y una versión de definición de registrador.
1. Cree una versión de grupo.
+ *group-id*Sustitúyala por la `Id` que copiaste para el grupo.
+ *core-definition-version-arn*Sustitúyalo por el `CoreDefinitionVersionArn` que copió para la versión de definición básica.
+ *function-definition-version-arn*Sustitúyala por la `LatestVersionArn` que copiaste para la nueva versión de definición de funciones.
+ *logger-definition-version-arn*Sustitúyala por la `LatestVersionArn` que copiaste para tu nueva versión de definición de registrador.
```
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 \
--logger-definition-version-arn logger-definition-version-arn
```
1. Copie la `Version` del resultado. Este es el ID de la nueva versión del grupo.
## Paso 7: Crear una implementación
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. Cree una implementación de .
+ *group-id*Sustitúyala por la `Id` que copiaste para el grupo.
+ *group-version-id*Reemplácelo por el `Version` que copió para la nueva versión del grupo.
```
aws greengrass create-deployment \
--deployment-type NewDeployment \
--group-id group-id \
--group-version-id group-version-id
```
1. Copie la `DeploymentId` del resultado.
1. Obtenga el estado de las implementaciones.
+ *group-id*Sustitúyala por la `Id` que copiaste para el grupo.
+ *deployment-id*Reemplácelo por el `DeploymentId` que copió para la implementación.
```
aws greengrass get-deployment-status \
--group-id group-id \
--deployment-id deployment-id
```
Si el estado es `Success`, la implementación fue correcta. Para obtener ayuda sobre la resolución de problemas, consulte [Solución de problemas AWS IoT Greengrass](gg-troubleshooting.md).
## Paso 8: 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-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. Siga [Paso 6: Crear una versión del grupo](#stream-manager-cli-create-group-version) para crear una nueva versión de grupo. pero elimine la opción `--function-definition-version-arn` en el comando `create-group-version`. O bien, cree una versión de definición de función que no incluya la función **TransferStream**Lambda.
**nota**
Al omitir la función de Lambda de `GGStreamManager` del sistema de la versión de grupo implementada, se deshabilita la administración de secuencias en el núcleo.
1. Siga [Paso 7: Crear una implementación](#stream-manager-cli-create-deployment) para implementar la nueva versión de grupo.
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 de `Lambda` a `DEBUG` y, a continuación, crear e implementar una nueva versión de grupo.
## Véase también
+ [Gestione los flujos de datos en el AWS IoT Greengrass núcleo](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)
+ [Configurar el administrador de AWS IoT Greengrass transmisiones](configure-stream-manager.md)
+ [Exportar flujos de datos a la Nube de AWS (consola)](stream-manager-console.md)
+ [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/cli/latest/reference/iam) de la Referencia de *AWS CLI comandos*
+ [AWS Lambda comandos](https://docs.aws.amazon.com/cli/latest/reference/lambda) de la Referencia de *AWS CLI comandos*
+ [AWS IoT Greengrass comandos](https://docs.aws.amazon.com/cli/latest/reference/greengrass/index.html) de la *Referencia de AWS CLI comandos*