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. # Se usa StreamManagerClient para trabajar con transmisiones Los componentes de Greengrass definidos por el usuario que se ejecutan en el dispositivo principal de Greengrass pueden utilizar el objeto `StreamManagerClient` en el SDK del Administrador de flujos para crear flujos en el [administrador de flujos](manage-data-streams.md) y luego interactuar con ellos. Cuando un componente 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, los componentes 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 componentes de Greengrass definidos por el usuario. Si su caso de negocio lo requiere, puede permitir que los procesos que no sean componentes 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](manage-data-streams.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. Si utiliza el administrador de flujos en una función de Lambda, la función de Lambda debe iniciar `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, un componente de Greengrass definido por el usuario llama al método de creación y pasa un objeto `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-greengrass.github.io/aws-greengrass-stream-manager-sdk-java/com/amazonaws/greengrass/streammanager/model/MessageStreamDefinition.html)en el SDK de Java + [MessageStreamDefinition](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-js/aws-greengrass-core-sdk.StreamManager.MessageStreamDefinition.html)en el SDK de Node.js + [MessageStreamDefinition](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.data.html#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, los componentes de Greengrass pueden [anexar mensajes](#streammanagerclient-append-message) al flujo con el fin de enviar datos para su exportación y [leer los mensajes](#streammanagerclient-read-messages) 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 mínima del SDK del Administrados de flujos: Python: 1.1.0  \$1  Java: 1.1.0  \$1  Node.js: 1.1.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-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.streammanagerclient.html#stream_manager.streammanagerclient.StreamManagerClient.create_message_stream) \$1 [MessageStreamDefinition](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.data.html#stream_manager.data.MessageStreamDefinition) ------ #### [ Java ] ``` try (final StreamManagerClient client = StreamManagerClientFactory.standard().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) .withS3(null) ) ); } catch (StreamManagerException e) { // Properly handle exception. } ``` Referencia del [createMessageStream](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#createMessageStream-com.amazonaws.greengrass.streammanager.model.MessageStreamDefinition-)SDK de Java: \$1 [MessageStreamDefinition](https://aws-greengrass.github.io/aws-greengrass-stream-manager-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) .withS3(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-greengrass.github.io/aws-greengrass-stream-manager-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#createMessageStream)\$1 [MessageStreamDefinition](https://aws-greengrass.github.io/aws-greengrass-stream-manager-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, los componentes de Greengrass 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 mínima del SDK del Administrados de flujos: Python: 1.1.0  \$1  Java: 1.1.0  \$1  Node.js: 1.1.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, sus componentes de Greengrass añaden una masa de datos. Este fragmento tiene los siguientes requisitos: + Versión mínima del SDK del Administrados de flujos: Python: 1.1.0  \$1  Java: 1.1.0  \$1  Node.js: 1.1.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-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.streammanagerclient.html#stream_manager.streammanagerclient.StreamManagerClient.append_message) ------ #### [ Java ] ``` try (final StreamManagerClient client = StreamManagerClientFactory.standard().build()) { long sequenceNumber = client.appendMessage("StreamName", "Arbitrary byte array".getBytes()); } catch (StreamManagerException e) { // Properly handle exception. } ``` Referencia de SDK de Java: [appendMessage](https://aws-greengrass.github.io/aws-greengrass-stream-manager-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-greengrass.github.io/aws-greengrass-stream-manager-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, sus componentes de Greengrass 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 mínima del SDK del Administrados de flujos: Python: 1.1.0  \$1  Java: 1.1.0  \$1  Node.js: 1.1.0 ------ #### [ Python ] ``` client = StreamManagerClient() try: # SiteWise requires unique timestamps in all messages and also needs timestamps not earlier # than 10 minutes in the past. 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", 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-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.data.html#stream_manager.data.PutAssetPropertyValueEntry)](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.streammanagerclient.html#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 and also needs timestamps not earlier // than 10 minutes in the past. 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-greengrass.github.io/aws-greengrass-stream-manager-sdk-java/com/amazonaws/greengrass/streammanager/model/sitewise/PutAssetPropertyValueEntry.html)](https://aws-greengrass.github.io/aws-greengrass-stream-manager-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-greengrass.github.io/aws-greengrass-stream-manager-sdk-js/aws-greengrass-core-sdk.StreamManager.PutAssetPropertyValueEntry.html)](https://aws-greengrass.github.io/aws-greengrass-stream-manager-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, los componentes de Greengrass anexan 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 mínima del SDK del Administrados de flujos: Python: 1.1.0  \$1  Java: 1.1.0  \$1  Node.js: 1.1.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", 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-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.streammanagerclient.html#stream_manager.streammanagerclient.StreamManagerClient.append_message) ExportTaskDefinition](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.data.html#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-greengrass.github.io/aws-greengrass-stream-manager-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#appendMessage-java.lang.String-byte:A-) S3 ExportTaskDefinition](https://aws-greengrass.github.io/aws-greengrass-stream-manager-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-greengrass.github.io/aws-greengrass-stream-manager-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#appendMessage) S3 ExportTaskDefinition](https://aws-greengrass.github.io/aws-greengrass-stream-manager-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 mínima del SDK del Administrados de flujos: Python: 1.1.0  \$1  Java: 1.1.0  \$1  Node.js: 1.1.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-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.data.html#stream_manager.data.ReadMessagesOptions)](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.streammanagerclient.html#stream_manager.streammanagerclient.StreamManagerClient.read_messages) ------ #### [ Java ] ``` try (final StreamManagerClient client = StreamManagerClientFactory.standard().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-greengrass.github.io/aws-greengrass-stream-manager-sdk-java/com/amazonaws/greengrass/streammanager/model/ReadMessagesOptions.html)](https://aws-greengrass.github.io/aws-greengrass-stream-manager-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-greengrass.github.io/aws-greengrass-stream-manager-sdk-js/aws-greengrass-core-sdk.StreamManager.ReadMessagesOptions.html)](https://aws-greengrass.github.io/aws-greengrass-stream-manager-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 mínima del SDK del Administrados de flujos: Python: 1.1.0  \$1  Java: 1.1.0  \$1  Node.js: 1.1.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-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.streammanagerclient.html#stream_manager.streammanagerclient.StreamManagerClient.list_streams) ------ #### [ Java ] ``` try (final StreamManagerClient client = StreamManagerClientFactory.standard().build()) { List streamNames = client.listStreams(); } catch (StreamManagerException e) { // Properly handle exception. } ``` Referencia de SDK de Java: [listStreams](https://aws-greengrass.github.io/aws-greengrass-stream-manager-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-greengrass.github.io/aws-greengrass-stream-manager-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 del SDK del Administrados de flujos: Python: 1.1.0  \$1  Java: 1.1.0  \$1  Node.js: 1.1.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-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.streammanagerclient.html#stream_manager.streammanagerclient.StreamManagerClient.describe_message_stream) ------ #### [ Java ] ``` try (final StreamManagerClient client = StreamManagerClientFactory.standard().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-greengrass.github.io/aws-greengrass-stream-manager-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-greengrass.github.io/aws-greengrass-stream-manager-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. Los componentes de Greengrass siguen este proceso general 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 mínima del SDK del Administrados de flujos: Python: 1.1.0  \$1  Java: 1.1.0  \$1  Node.js: 1.1.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-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.streammanagerclient.html#stream_manager.streammanagerclient.StreamManagerClient.update_message_stream)\$1 [MessageStreamDefinition](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.data.html#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-greengrass.github.io/aws-greengrass-stream-manager-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#updateMessageStream-java.lang.String-) \$1 [MessageStreamDefinition](https://aws-greengrass.github.io/aws-greengrass-stream-manager-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-greengrass.github.io/aws-greengrass-stream-manager-sdk-js/aws-greengrass-core-sdk.StreamManager.MessageStreamDefinition.html)](https://aws-greengrass.github.io/aws-greengrass-stream-manager-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 mínima del SDK del Administrados de flujos: Python: 1.1.0  \$1  Java: 1.1.0  \$1  Node.js: 1.1.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-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.streammanagerclient.html#stream_manager.streammanagerclient.StreamManagerClient.delete_message_stream) ------ #### [ Java ] ``` try (final StreamManagerClient client = StreamManagerClientFactory.standard().build()) { client.deleteMessageStream("StreamName"); } catch (StreamManagerException e) { // Properly handle exception. } ``` Referencia del SDK de Java: [delete\$1message\$1stream](https://aws-greengrass.github.io/aws-greengrass-stream-manager-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-greengrass.github.io/aws-greengrass-stream-manager-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#deleteMessageStream) ------ ## Véase también + [Administración de flujos de datos en los dispositivos principales de Greengrass](manage-data-streams.md) + [Configurar el administrador de secuencias de AWS IoT Greengrass](configure-stream-manager.md) + [Exportación de configuraciones para Nube de AWS destinos compatibles](stream-export-configurations.md) + `StreamManagerClient` en la referencia del SDK del Administrador de flujos: + [Python](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.streammanagerclient.html) + [Java](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html) + [Node.js](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html) # Exportación de configuraciones para Nube de AWS destinos compatibles Los componentes de Greengrass definidos por el usuario utilizan `StreamManagerClient` en el SDK del administrador de flujos para interactuar con el administrador de flujos. Cuando un componente [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/v2/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 de exportación fallidos, Stream Manager vuelve a intentar exportar los datos continuamente a Nube de AWS 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 del administrador de flujos, los componentes de Greengrass utilizan `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-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.data.html#stream_manager.data.IoTAnalyticsConfig) en el SDK de Python + [Io TAnalytics Config](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-java/com/amazonaws/greengrass/streammanager/model/export/IoTAnalyticsConfig.html) en el SDK de Java + [Io TAnalytics Config](https://aws-greengrass.github.io/aws-greengrass-stream-manager-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 Cuenta de AWS y Región de AWS igual que el dispositivo principal de Greengrass. + El [Autorizar a los dispositivos principales a interactuar con AWS los servicios](device-service-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, sus componentes de Greengrass [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 componentes de Greengrass 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 utiliza normalmente para agregar grandes volúmenes de datos y cargarlos en un almacén MapReduce de datos o un clúster. 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 del administrador de flujos, los componentes de Greengrass utilizan `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-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.data.html#stream_manager.data.KinesisConfig)en el SDK de Python + [KinesisConfig](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-java/com/amazonaws/greengrass/streammanager/model/export/KinesisConfig.html)en el SDK de Java + [KinesisConfig](https://aws-greengrass.github.io/aws-greengrass-stream-manager-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 dispositivo principal de Greengrass Región de AWS y en el mismo. + (Recomendado) La versión 2.2.1 del administrador de flujos mejora el rendimiento de la exportación de flujos a los destinos del flujo de datos de Kinesis. Para usar las mejoras de esta última versión, actualice su [componente de administrador de flujos](stream-manager-component.md) a la versión 2.2.1 y utilice la política `kinesis:ListShards` en el [rol de intercambio de tokens de Greengrass](device-service-role.md). + El [Autorizar a los dispositivos principales a interactuar con AWS los servicios](device-service-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 componentes de Greengrass [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 componentes de Greengrass 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 del administrador de flujos, los componentes de Greengrass utilizan `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-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.data.html#stream_manager.data.IoTSiteWiseConfig) en el SDK de Python + [Io TSite WiseConfig](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-java/com/amazonaws/greengrass/streammanager/model/export/IoTSiteWiseConfig.html) en el SDK de Java + [Io TSite WiseConfig](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-js/aws-greengrass-core-sdk.StreamManager.IoTSiteWiseConfig.html) en el SDK de Node.js **nota** AWS también proporciona AWS IoT SiteWise componentes, que ofrecen una solución prediseñada que puede utilizar para transmitir datos desde fuentes OPC-UA. Para obtener más información, consulte [Colector IoT SiteWise OPC UA](iotsitewise-opcua-collector-component.md). ### Requisitos Este destino de exportación tiene los siguientes requisitos: + Las propiedades de los activos de destino AWS IoT SiteWise deben estar en el mismo Cuenta de AWS y Región de AWS igual que el dispositivo principal de Greengrass. **nota** Para ver la lista de Región de AWS dispositivos 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*. + [Autorizar a los dispositivos principales a interactuar con AWS los servicios](device-service-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 eliminarlos `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, sus componentes de Greengrass [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 componentes de Greengrass reciben datos de propiedad de activos, anexan mensajes que contienen 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 la configuración del administrador de flujos y la lógica del componente de Greengrass 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, sus componentes de Greengrass 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 del administrador de flujos, los componentes de Greengrass utilizan `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-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.data.html#stream_manager.data.S3ExportTaskExecutorConfig) en el SDK de Python + [S3 ExportTaskExecutorConfig](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-java/com/amazonaws/greengrass/streammanager/model/export/S3ExportTaskExecutorConfig.html) en el SDK de Java + [S3 ExportTaskExecutorConfig](https://aws-greengrass.github.io/aws-greengrass-stream-manager-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 Amazon S3 de destino deben estar en el mismo lugar Cuenta de AWS que el dispositivo principal de Greengrass. + 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 el directorio como un volumen 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 en el componente administrador de flujos, que se ejecuta fuera del contenedor. + Si un componente contenedor de Docker escribe archivos de entrada en un directorio de archivos de entrada, usted debe montar el directorio como un volumen 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 en el componente administrador de flujos, que se ejecuta fuera del contenedor. + El [Autorizar a los dispositivos principales a interactuar con AWS los servicios](device-service-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, sus componentes de Greengrass 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 componentes de Greengrass 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. 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 los componentes de Greengrass 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. 1. Un componente de Greengrass escanea el directorio y [anexa una tarea de exportación](work-with-streams.md#streammanagerclient-append-message-export-task) al flujo 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. El componente de Greengrass [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, el componente de Greengrass 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. Sus componentes de Greengrass 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 los componentes de Greengrass pueden utilizar un flujo de estado para supervisar el estado de exportación. 1. Como se describió en el flujo de trabajo anterior, un componente de Greengrass [anexa una tarea de exportación](work-with-streams.md#streammanagerclient-append-message-export-task) a un 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. Un componente de Greengrass [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, el componente de Greengrass 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 detuvo 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 borra una carga parcial cancelada, aparecerá una advertencia. 1. Una vez finalizadas las tareas de exportación, el componente de Greengrass puede eliminar los archivos de entrada correspondientes. En el siguiente ejemplo, se muestra cómo un componente de Greengrass puede leer y procesar los mensajes de estado. ------ #### [ Python ] ``` import time from stream_manager import ( ReadMessagesOptions, Status, StatusConfig, StatusLevel, StatusMessage, StreamManagerClient, ) from 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-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.data.html#stream_manager.data.StatusMessage)](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.streammanagerclient.html#stream_manager.streammanagerclient.StreamManagerClient.read_messages) ------ #### [ Java ] ``` import com.amazonaws.greengrass.streammanager.client.StreamManagerClient; import com.amazonaws.greengrass.streammanager.client.StreamManagerClientFactory; 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 = StreamManagerClientFactory.standard().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-greengrass.github.io/aws-greengrass-stream-manager-sdk-java/com/amazonaws/greengrass/streammanager/model/StatusMessage.html)](https://aws-greengrass.github.io/aws-greengrass-stream-manager-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-stream-manager-sdk'*); 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-greengrass.github.io/aws-greengrass-stream-manager-sdk-js/aws-greengrass-core-sdk.StreamManager.StatusMessage.html)](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#readMessages) ------