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. # Crear y administrar Kinesis Data Streams Amazon Kinesis Data Streams adquiere una gran cantidad de datos en tiempo real, almacena de forma duradera los datos y hace que estos estén disponibles para su consumo. La unidad de datos almacenada por Kinesis Data Streams es un *registro de datos*. Una *secuencia de datos* representa un grupo de registros de datos. Los registros de datos de una secuencia de datos se distribuyen en fragmentos. Un *fragmento* contiene una sucesión de registros de datos en una secuencia. Sirve como unidad de rendimiento base de un flujo de datos de Kinesis. Una partición admite 1 MB/s y 1000 registros por segundo para *escrituras* y 2 MB/s para *lecturas* en los modos de capacidad aprovisionada y bajo demanda. Los límites de la partición garantizan un rendimiento predecible, lo que facilita el diseño y funcionamiento de un flujo de datos de alta fiabilidad. En esta sección, aprenderá a configurar el modo de capacidad de la transmisión y a crear una transmisión mediante la Consola de administración de AWS tecla o. APIs Luego, puede tomar medidas adicionales en el flujo. **Topics** + [Elegir el modo correcto para el flujo](how-do-i-size-a-stream.md) + [Cree una transmisión con el Consola de administración de AWS](how-do-i-create-a-stream.md) + [Cree una transmisión mediante el APIs](kinesis-using-sdk-java-create-stream.md) + [Actualizar un flujo](updating-a-stream.md) + [Lista de secuencias](kinesis-using-sdk-java-list-streams.md) + [Obtener lista de particiones](kinesis-using-sdk-java-list-shards.md) + [Eliminar un flujo](kinesis-using-sdk-java-delete-stream.md) + [Cambiar las particiones de un flujo](kinesis-using-sdk-java-resharding.md) + [Cambiar el periodo de retención de datos](kinesis-extended-retention.md) + [Etiquetar recursos de Amazon Kinesis Data Streams](tagging.md) + [Gestión de registros de gran tamaño](large-records.md) + [Realice pruebas de resiliencia con AWS Fault Injection Service](kinesis-fis.md) # Elegir el modo correcto para el flujo En los temas siguientes se explica cómo elegir el mejor modo para su aplicación y cómo cambiar entre los modos, si fuera necesario. **Topics** + [¿Cuáles son los distintos modos de Kinesis Data Streams?](#diff-modes-kds) + [Características y casos de uso del modo estándar bajo demanda](#ondemandmode) + [Características y casos de uso del modo de ventaja bajo demanda](#ondemand-advantage-mode) + [Características del modo aprovisionado y casos de uso](#provisionedmode) + [Cambio entre modos](#switchingmodes) ## ¿Cuáles son los distintos modos de Kinesis Data Streams? Un modo determina cómo se administra la capacidad de un flujo de datos y cómo se le cobra por el uso de su flujo de datos. En Amazon Kinesis Data Streams, puede elegir entre un modo **estándar bajo demanda**, **ventaja bajo demanda** y **aprovisionado** para sus flujos de datos. + **Estándar bajo demanda**: los flujos de datos con un modo bajo demanda no requieren planificación de la capacidad y se escalan automáticamente para gestionar gigabytes de escritura y rendimiento de lectura por minuto. Con el modo bajo demanda, Kinesis Data Streams administra automáticamente las particiones para proporcionar el rendimiento necesario. + **Ventaja bajo demanda**: un modo a nivel de cuenta que ofrece más funciones y brinda una estructura de precios más sencilla para los flujos bajo demanda. En este modo, puede aumentar de forma proactiva la capacidad de rendimiento de escritura de un flujo en cualquier momento. En cuanto a los precios, ya no hay un cargo fijo por flujo, y el uso de la ingesta, la recuperación y la retención prolongada de datos en todos los flujos bajo demanda son al menos un 60 % más bajas que las de **estándar bajo demanda**. + **Aprovisionado**: para el flujo de datos con un modo aprovisionado, debe especificar el número de particiones para el flujo de datos. La capacidad total de un flujo de datos es la suma de las capacidades de las particiones. Puede aumentar o reducir el número de particiones de un flujo de datos, según sea necesario. Puede utilizar Kinesis Data `PutRecord` Streams `PutRecords` APIs y escribir datos en sus flujos de datos en cualquier modo. Para recuperar datos, los tres modos de capacidad admiten consumidores predeterminados que utilizan la API `GetRecords` y consumidores de distribución ramificada mejorada (EFO) que utilizan la API `SubscribeToShard`. Todas las capacidades de Kinesis Data Streams, incluidos el modo de retención, el cifrado y las métricas de supervisión, entre otros, son compatibles tanto para el modo bajo demanda como para el modo aprovisionado. Kinesis Data Streams proporciona una alta durabilidad y disponibilidad tanto en el modo bajo demanda como en el modo de capacidad aprovisionada. ## Características y casos de uso del modo estándar bajo demanda Los flujos de datos en el modo bajo demanda no requieren planificación de capacidad y se escalan automáticamente para manejar gigabytes de rendimiento de escritura y lectura por minuto. El modo bajo demanda simplifica la ingesta y el almacenamiento de grandes volúmenes de datos con baja latencia, ya que elimina el aprovisionamiento y la gestión de servidores, almacenamiento o rendimiento. Puede ingerir miles de millones de registros al día sin ninguna sobrecarga operativa. El modo bajo demanda es ideal para responder a las necesidades de un tráfico de aplicaciones muy variable e impredecible. Ya no tendrá que aprovisionar estas cargas de trabajo para los picos de capacidad, lo que puede dar lugar a costos más elevados debido al bajo uso. El modo bajo demanda es adecuado para cargas de trabajo con patrones de tráfico impredecibles y muy variables. Con el modo de capacidad bajo demanda, paga por GB de datos escritos y leídos de sus flujos de datos. No necesita especificar el rendimiento de lectura y escritura que espera de su aplicación. Kinesis Data Streams se adapta instantáneamente a sus cargas de trabajo a medida que aumentan o disminuyen. Para obtener más información, consulte los [Precios de Amazon Kinesis Data Streams](https://aws.amazon.com/kinesis/data-streams/pricing/). Un flujo de datos en el modo bajo demanda admite hasta el doble del rendimiento de escritura máximo observado en los 30 días anteriores. A medida que el rendimiento de escritura de su flujo de datos alcanza un nuevo pico, Kinesis Data Streams escala automáticamente la capacidad del flujo de datos. Por ejemplo, si su flujo de datos tiene un rendimiento de escritura que varía entre el 10 MB/s y el 40% MB/s, then Kinesis Data Streams ensures that you can easily burst to double your previous peak throughput, or 80 MB/s. If the same data stream sustains a new peak throughput of 50 MB/s, Kinesis Data Streams ensures that there is enough capacity to ingest 100 MB/s del rendimiento de escritura. Sin embargo, puede producirse una limitación de escritura si el tráfico aumenta a más del doble del pico anterior en un periodo de 15 minutos. En este caso, es necesario reintentar las peticiones limitadas. La capacidad de lectura agregada de un flujo de datos con el modo bajo demanda aumenta proporcionalmente al rendimiento de escritura. Esto ayuda a garantizar que las aplicaciones de consumo siempre tengan un rendimiento de lectura adecuado para procesar los datos entrantes en tiempo real. Con la API `GetRecords` se obtiene al menos el doble de rendimiento de escritura que de lectura de datos. Le recomendamos que utilice una aplicación de consumo con la API `GetRecord`, para que tenga espacio suficiente de recuperación cuando la aplicación necesite reponerse de un tiempo de inactividad. Se recomienda que utilice la capacidad de distribución ramificada mejorada de Kinesis Data Streams para escenarios que requieran agregar más de una aplicación consumidora. La distribución ramificada mejorada admite la adición de hasta 20 aplicaciones consumidoras a un flujo de datos mediante la API `SubscribeToShard`, y cada aplicación consumidora tiene un rendimiento dedicado. ### Manejar excepciones de rendimiento de lectura y escritura Con el modo bajo demanda (igual que con el modo de capacidad aprovisionada), debe especificar una clave de partición con cada registro para escribir datos en su flujo de datos. Kinesis Data Streams utiliza sus claves de partición para distribuir los datos entre las particiones. Kinesis Data Streams supervisa el tráfico de cada partición. Cuando el tráfico entrante supera los 500 KB/s por fragmento, divide el fragmento en 15 minutos. Los valores de clave hash de la partición principal se redistribuyen uniformemente entre las particiones secundarias. Si el tráfico entrante supera el doble de su pico anterior, puede experimentar excepciones de lectura o escritura durante unos 15 minutos, incluso cuando sus datos se distribuyan uniformemente entre las particiones. Le recomendamos que reintente todas estas solicitudes para que todos los registros se almacenen correctamente en Kinesis Data Streams. Puede experimentar excepciones de lectura y escritura si utiliza una clave de partición que provoque una distribución desigual de los datos y los registros asignados a una partición concreta superan sus límites. Con el modo bajo demanda, el flujo de datos se adapta automáticamente para gestionar patrones de distribución de datos irregulares, a menos que una sola clave de partición supere los límites de MB/s rendimiento de 1 unidad y 1000 registros por segundo de un fragmento. En el modo bajo demanda, Kinesis Data Streams divide las particiones de manera uniforme cuando detecta un aumento del tráfico. Sin embargo, no detecta ni aísla las claves hash que dirigen una mayor parte del tráfico entrante a una partición concreta. Si utiliza claves de partición muy desiguales, es posible que siga recibiendo excepciones de escritura. Para estos casos de uso, le recomendamos que utilice el modo de capacidad aprovisionada que admite divisiones de particiones granulares. ## Características y casos de uso del modo de ventaja bajo demanda La ventaja bajo demanda es una configuración a nivel de cuenta que ofrece más funciones y ofrece una estructura de precios diferente para todas los flujos bajo demanda de la región. En este modo, los flujos bajo demanda conservan su funcionalidad y siguen escalando automáticamente la capacidad según el uso real de datos. Si desea aumentar de forma proactiva la capacidad de rendimiento de escritura de una transmisión, puede configurar el rendimiento en caliente. Por ejemplo, si el flujo de datos tiene un rendimiento de escritura entre 10 MB/s y 40, MB/s, you can expect it to handle up to 80MB/s of instant throughput increases without throttling. However, if you forecast an upcoming event to peak around 200MB/s of traffic, you can configure the stream with a warm throughput of 200MB/s para garantizar que la capacidad esté disponible cuando llegue el rendimiento de datos. El uso del rendimiento en caliente no conlleva ningún cargo adicional. Otra ventaja del modo de ventaja bajo demanda es que los flujos bajo demanda pasan a una estructura de precios más sencilla. Con el modo activado, la cuenta ya no cobrará cargos fijos por flujo y solo tendrá que pagar los cargos por ingesta y recuperación de datos y los cargos opcionales de retención prolongada. Cada dimensión de precios también tiene un descuento notable en comparación con la dimensión correspondiente del estándar bajo demanda. Para obtener más información, consulte los [Precios de Amazon Kinesis Data Streams](https://aws.amazon.com/kinesis/data-streams/pricing/). Las recuperaciones de datos de distribución ramificada mejorada tampoco tienen un precio superior en comparación con las recuperaciones de datos estándar de este modo. Además, con el modo On-Demand Advantage, puede registrar hasta 50 consumidores por transmisión para utilizar la distribución mejorada. Al activar On-Demand Advantage, la cuenta se compromete a recuperar al menos el 25% MiB/s of data ingest and 25MiB/s de los datos de todas las transmisiones bajo demanda. En el caso de las cuentas que cumplen el requisito de uso mínimo, la consola de Kinesis Data Streams comprueba si los patrones de uso de su cuenta son adecuados para utilizar el **modo de ventaja bajo demanda**. Si el uso de datos de su cuenta es inferior al requerido, se le cobrará la diferencia en concepto de déficit, pero seguirá teniendo la misma tarifa con descuento. Si habilita la ventaja bajo demanda, también dispone de un periodo mínimo de 24 horas antes de que pueda desactivar el modo. En general, la ventaja bajo demanda es la mejor forma de transmitir con Kinesis Data Streams si tiene un rendimiento constante cercano o superior al compromiso mínimo, si necesita muchos consumidores de distribución ramificada mejorada o si opera con cientos de flujos de datos. ## Características del modo aprovisionado y casos de uso Con el modo aprovisionado, después de crear el flujo de datos, puede aumentar o reducir dinámicamente la capacidad de su partición mediante la API Consola de administración de AWS o la misma. [UpdateShardCount](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_UpdateShardCount.html) Puede realizar actualizaciones mientras haya una aplicación productora o consumidora de Kinesis Data Streams que escriba o lea datos del flujo. El modo aprovisionado es adecuado para tráfico predecible con requisitos de capacidad fáciles de prever. Puede utilizar el modo aprovisionado si desea un control detallado sobre cómo se distribuyen los datos entre las particiones. Con el modo aprovisionado, debe especificar el número de particiones del flujo de datos. Para determinar el tamaño de un flujo de datos con el modo aprovisionado, necesita los siguientes valores de entrada: + El tamaño promedio del registro de datos escrito en el flujo en kilobytes (KB), redondeado al 1 KB más cercano (`average_data_size_in_KB`). + El número de registros de datos escritos en la secuencia de y leídos desde esta por segundo (`records_per_second`). + El número de consumidores, que son aplicaciones de Kinesis Data Streams que consumen datos de forma simultánea e independiente del flujo (`number_of_consumers`). + El ancho de banda de escritura entrante (en KB`incoming_write_bandwidth_in_KB`), que es igual a `average_data_size_in_KB` multiplicado por `records_per_second`. + El ancho de banda de lectura saliente (en KB`outgoing_read_bandwidth_in_KB`), que es igual a `incoming_write_bandwidth_in_KB` multiplicado por `number_of_consumers`. Puede calcular el número de particiones (`number_of_shards`) que su flujo necesita mediante los valores de entrada de la siguiente fórmula. ``` number_of_shards = ceiling(max(incoming_write_bandwidth_in_KiB/1024, outgoing_read_bandwidth_in_KiB/2048)) ``` En el modo aprovisionado, es posible que se produzcan excepciones en el rendimiento de lectura y escritura si no se configura el flujo de datos para manejar los picos de rendimiento. En este caso, debe escalar manualmente su flujo de datos para acomodar el tráfico de datos. También puede experimentar excepciones de lectura y escritura si utiliza una clave de partición que provoque una distribución desigual de los datos y los registros signados a una partición superan sus límites. Para resolver este problema en el modo aprovisionado, identifique estas particiones y divídalas manualmente para acomodar mejor su tráfico. Para obtener más información, consulte [Redistribución de un flujo](https://docs.aws.amazon.com/streams/latest/dev/kinesis-using-sdk-java-resharding.html). ## Cambio entre modos Para cada flujo de datos del que disponga Cuenta de AWS, puede cambiar entre los modos bajo demanda y aprovisionamiento dos veces en un plazo de 24 horas. El cambio entre los modos no provoca ninguna interrupción en las aplicaciones que utilizan este flujo de datos. Puede seguir escribiendo y leyendo de este flujo de datos. Al cambiar entre los modos, ya sea de bajo demanda a provisionado o de provisionado a bajo demanda, el estado del flujo pasa a *Actualizando*. Debe esperar a que el estado del flujo de datos pase a *Activo* para poder modificar de nuevo sus propiedades. Al cambiar del modo de capacidad aprovisionada al modo bajo demanda, el flujo de datos conserva inicialmente el recuento de particiones que tenía antes de la transición y, a partir de ese momento, Kinesis Data Streams supervisa el tráfico de datos y escala el recuento de particiones de este flujo de datos bajo demanda en función del rendimiento de escritura. Cuando cambia del modo bajo demanda al modo aprovisionado, el flujo de datos también conserva inicialmente el recuento de particiones que tenía antes de la transición, pero a partir de este momento, el usuario es responsable de supervisar y ajustar el recuento de particiones de este flujo de datos para adaptarse adecuadamente al rendimiento de escritura. Puede cambiar del modo **estándar bajo demanda** a la **ventaja bajo demanda** habilitando una configuración a nivel de cuenta. Cuando está habilitada, la cuenta se compromete a utilizar al menos el 25% MiB/s of data ingest and 25MiB/s de la recuperación de datos en todas las transmisiones bajo demanda de la región. Una vez activado, debe esperar al menos 24 horas antes de poder desactivar la **ventaja bajo demanda**, pero puede solicitar el cambio en cualquier momento. Si desea cambiar de **ventaja bajo demanda** a **estándar bajo demanda**, primero debe eliminar los flujos de alto rendimiento configurados con demanda. # Cree una transmisión con el Consola de administración de AWS Puede crear un flujo mediante la consola de Kinesis Data Streams, la API de Kinesis Data Streams o la AWS Command Line Interface (AWS CLI). **Para crear un flujo de datos con la consola** 1. [Inicie sesión en la consola de Kinesis Consola de administración de AWS y ábrala en https://console.aws.amazon.com /kinesis.](https://console.aws.amazon.com/kinesis) 1. En la barra de navegación, expanda el selector de regiones y seleccione una región. 1. Elija **Crear flujo de datos**. 1. En la página **Crear flujo de Kinesis**, escriba un nombre para su flujo de datos y, a continuación, elija el modo de capacidad **Bajo demanda** o **Aprovisionado**. El modo **Bajo demanda** está seleccionado de forma predeterminada. Para obtener más información, consulte [Elegir el modo correcto para el flujo](how-do-i-size-a-stream.md). Con el modo **Bajo demanda**, puede seleccionar **Crear flujo de Kinesis** para crear su flujo de datos. Con el modo **aprovisionado**, debe especificar el número de particiones que necesita y, a continuación, elegir **Crear flujo de Kinesis**. En la página **Flujos de Kinesis**, el valor **Estado** del flujo es **Creándose** mientras se crea. Cuando el flujo está listo para usarse, el valor **Estado** cambia a **Activo**. 1. Elija el nombre del flujo. La página **Detalles del flujo** muestra un resumen de la configuración del flujo, junto con información de monitoreo. **Creación de un flujo mediante la API de Kinesis Data Streams** + Para más información sobre la creación de flujos mediante la API de Kinesis Data Streams, consulte [Cree una transmisión mediante el APIs](kinesis-using-sdk-java-create-stream.md). **Para crear una transmisión mediante AWS CLI** + Para obtener información sobre cómo crear una transmisión mediante el AWS CLI, consulte el comando [create-stream](https://docs.aws.amazon.com/cli/latest/reference/kinesis/create-stream.html). # Cree una transmisión mediante el APIs Siga estos pasos para crear su flujo de datos de Kinesis. ## Crear el cliente de Kinesis Data Streams Antes de poder trabajar con flujos de datos de Kinesis, debe crear un objeto cliente. El siguiente código Java crea una instancia de un compilador de clientes y la usa para definir la región, las credenciales y la configuración del cliente. A continuación, crea un objeto cliente. ``` AmazonKinesisClientBuilder clientBuilder = AmazonKinesisClientBuilder.standard(); clientBuilder.setRegion(regionName); clientBuilder.setCredentials(credentialsProvider); clientBuilder.setClientConfiguration(config); AmazonKinesis client = clientBuilder.build(); ``` Para obtener más información, consulte [Regiones y puntos de conexión de Kinesis Data Streams](https://docs.aws.amazon.com/general/latest/gr/rande.html#ak_region) en *Referencia general de AWS*. ## Crear la secuencia Ahora que ya creó su cliente de Kinesis Data Streams, puede crear un flujo mediante la consola o de forma programada. Para crear un flujo de forma programada, cree una instancia de un objeto `CreateStreamRequest` y especifique un nombre para el flujo. Si desea usar el modo aprovisionado, debe especificar el número de particiones del flujo que deben usarse. + **Bajo demanda**: ``` CreateStreamRequest createStreamRequest = new CreateStreamRequest(); createStreamRequest.setStreamName( myStreamName ); ``` + **Aprovisionado**: ``` CreateStreamRequest createStreamRequest = new CreateStreamRequest(); createStreamRequest.setStreamName( myStreamName ); createStreamRequest.setShardCount( myStreamSize ); ``` El nombre de la secuencia identifica la secuencia. El nombre se refiere a la AWS cuenta utilizada por la aplicación. También se limita a la región. Es decir, dos flujos en dos AWS cuentas diferentes pueden tener el mismo nombre y dos flujos en la misma AWS cuenta pero en dos regiones diferentes pueden tener el mismo nombre, pero no dos flujos en la misma cuenta y en la misma región. El rendimiento del flujo depende del número de particiones. Para obtener un mayor rendimiento aprovisionado, necesitará más particiones. Si hay más fragmentos, también se incrementa el AWS coste de la transmisión. Para obtener más información sobre cómo calcular un número adecuado de fragmentos para una aplicación, consulte [Elegir el modo correcto para el flujo](how-do-i-size-a-stream.md). Tras configurar el objeto `createStreamRequest`, cree un flujo llamando al método `createStream` en el cliente. Después de llamar a `createStream`, espere a que la secuencia alcance el estado `ACTIVE` antes de realizar cualquier operación en la secuencia. Para comprobar el estado de la secuencia, llame al método `describeStream`. Sin embargo, `describeStream` arroja una excepción si la secuencia no existe. Por lo tanto, incluya la llamada a `describeStream` en un bloque `try/catch`. ``` client.createStream( createStreamRequest ); DescribeStreamRequest describeStreamRequest = new DescribeStreamRequest(); describeStreamRequest.setStreamName( myStreamName ); long startTime = System.currentTimeMillis(); long endTime = startTime + ( 10 * 60 * 1000 ); while ( System.currentTimeMillis() < endTime ) { try { Thread.sleep(20 * 1000); } catch ( Exception e ) {} try { DescribeStreamResult describeStreamResponse = client.describeStream( describeStreamRequest ); String streamStatus = describeStreamResponse.getStreamDescription().getStreamStatus(); if ( streamStatus.equals( "ACTIVE" ) ) { break; } // // sleep for one second // try { Thread.sleep( 1000 ); } catch ( Exception e ) {} } catch ( ResourceNotFoundException e ) {} } if ( System.currentTimeMillis() >= endTime ) { throw new RuntimeException( "Stream " + myStreamName + " never went active" ); } ``` # Actualizar un flujo Puede actualizar los detalles de un flujo mediante la consola de Kinesis Data Streams, la API de Kinesis Data Streams o la AWS CLI. **nota** Puede habilitar el cifrado en el servidor para secuencias existentes o para las secuencias que acaba de crear. ## Uso de la consola **Para actualizar una secuencia de datos con la consola** 1. Abra la consola Amazon Kinesis en. [https://console.aws.amazon.com/kinesis/](https://console.aws.amazon.com/kinesis/) 1. En la barra de navegación, expanda el selector de regiones y seleccione una región. 1. Elija el nombre de la secuencia en la lista. La página **Detalles del flujo** muestra un resumen de la configuración del flujo e información de monitoreo. 1. Para cambiar entre los modos de capacidad bajo demanda y aprovisionada para un flujo de datos, seleccione **Editar modo de capacidad** en la pestaña **Configuración**. Para obtener más información, consulte [Elegir el modo correcto para el flujo](how-do-i-size-a-stream.md). **importante** Para cada transmisión de datos de su AWS cuenta, puede cambiar entre los modos bajo demanda y aprovisionamiento dos veces en un plazo de 24 horas. 1. En el caso de un flujo de datos con el modo aprovisionado, para editar el número de particiones, seleccione **Editar particiones aprovisionadas** en la pestaña **Configuración** y, a continuación, ingrese un nuevo recuento de particiones. 1. Para habilitar el cifrado del servidor para registros de datos, elija **Editar** en la sección **Cifrado en el servidor**. Seleccione una clave de KMS para utilizarla como clave maestra de cifrado, o utilice la clave maestra predeterminada, **aws/kinesis**, administrada por Kinesis. Si habilita el cifrado de una transmisión y utiliza su propia clave AWS KMS maestra, asegúrese de que las aplicaciones de producción y consumo tengan acceso a la clave AWS KMS maestra que utilizó. Para asignar permisos a una aplicación de modo que tenga acceso a una clave de AWS KMS generada por el usuario, consulte [Permisos para utilizar claves de KMS generadas por el usuario](permissions-user-key-KMS.md). 1. Para editar el periodo de retención de datos, elija **Editar** en la sección **Periodo de retención de datos** y, a continuación, escriba un nuevo periodo de retención de datos. 1. Si ha habilitado las métricas personalizadas en su cuenta, elija **Editar** en la sección **Métricas en el nivel de partición** y, a continuación, especifique las métricas para su flujo. Para obtener más información, consulte [Supervise el servicio Amazon Kinesis Data Streams con Amazon CloudWatch](monitoring-with-cloudwatch.md). ## Uso de la API de Para actualizar los detalles de una secuencia a través de la API, consulte los siguientes métodos: + [AddTagsToStream](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_AddTagsToStream.html) + [DecreaseStreamRetentionPeriod](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_DecreaseStreamRetentionPeriod.html) + [DisableEnhancedMonitoring](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_DisableEnhancedMonitoring.html) + [EnableEnhancedMonitoring](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_EnableEnhancedMonitoring.html) + [IncreaseStreamRetentionPeriod](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_IncreaseStreamRetentionPeriod.html) + [RemoveTagsFromStream](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_RemoveTagsFromStream.html) + [StartStreamEncryption](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_StartStreamEncryption.html) + [StopStreamEncryption](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_StopStreamEncryption.html) + [UpdateShardCount](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_UpdateShardCount.html) ## Usa la AWS CLI Para obtener información sobre cómo actualizar una transmisión mediante el AWS CLI, consulte la referencia de la [CLI de Kinesis](https://docs.aws.amazon.com/cli/latest/reference/kinesis/index.html). # Lista de secuencias Las transmisiones se limitan a la AWS cuenta asociada a las AWS credenciales utilizadas para instanciar el cliente de Kinesis Data Streams y también a la región especificada para el cliente. Una cuenta de AWS podría tener muchos flujos activos en un momento dado. Puede listar sus flujos en la consola de Kinesis Data Streams o mediante programación. El código de esta sección muestra cómo enumerar todas las transmisiones de su cuenta. AWS ``` ListStreamsRequest listStreamsRequest = new ListStreamsRequest(); listStreamsRequest.setLimit(20); ListStreamsResult listStreamsResult = client.listStreams(listStreamsRequest); List streamNames = listStreamsResult.getStreamNames(); ``` Este código de muestra crea primero una nueva instancia de `ListStreamsRequest` y llama a su método `setLimit` para especificar que se debería devolver un máximo de 20 secuencias por cada llamada a `listStreams`. Si no especifica un valor para `setLimit`, Kinesis Data Streams devuelve un número de flujos menor o igual que el número de la cuenta. A continuación, el código pasa `listStreamsRequest` al método `listStreams` del cliente. El valor `listStreams` devuelto se almacena en un objeto `ListStreamsResult`. El código llama al método `getStreamNames` en este objeto y almacena los nombres de secuencia devueltos en la lista `streamNames`. Tenga en cuenta que Kinesis Data Streams podría devolver menos flujos de los especificados en el límite establecido, incluso si hay más flujos que en la cuenta y región. Para garantizar que pueda recuperar todas las secuencias, utilice el método `getHasMoreStreams` tal y como se describe en el siguiente código de muestra. ``` while (listStreamsResult.getHasMoreStreams()) { if (streamNames.size() > 0) { listStreamsRequest.setExclusiveStartStreamName(streamNames.get(streamNames.size() - 1)); } listStreamsResult = client.listStreams(listStreamsRequest); streamNames.addAll(listStreamsResult.getStreamNames()); } ``` Este código llama al método `getHasMoreStreams` en `listStreamsRequest` para comprobar si hay secuencias adicionales disponibles más allá de las que se devuelven en la llamada inicial a `listStreams`. En caso afirmativo, el código llama al método `setExclusiveStartStreamName` con el nombre de la última secuencia que se devolviera en la llamada anterior a `listStreams`. El método `setExclusiveStartStreamName` hace que la siguiente llamada a `listStreams` se inicie después de dicha secuencia. El grupo de nombres de secuencia que devuelve esa secuencia se añade a la lista `streamNames`. Este proceso continúa hasta que todos los nombres de secuencia se han recopilado en la lista. Las secuencias que devuelve `listStreams` pueden estar en uno de los siguientes estados: + `CREATING` + `ACTIVE` + `UPDATING` + `DELETING` Puede comprobar el estado de una secuencia mediante el método `describeStream`, tal y como se muestra en la sección anterior, [Cree una transmisión mediante el APIs](kinesis-using-sdk-java-create-stream.md). # Obtener lista de particiones Un flujo de datos puede tener una o varias particiones. El método recomendado para enumerar o recuperar los fragmentos de un flujo de datos es usar la API. [ListShards](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_ListShards.html) El siguiente ejemplo muestra cómo obtener una lista de las particiones de un flujo de datos. Para obtener una descripción completa de la operación principal utilizada en este ejemplo y de todos los parámetros que puede configurar para la operación, consulte. [ListShards](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_ListShards.html) ``` import software.amazon.awssdk.services.kinesis.KinesisAsyncClient; import software.amazon.awssdk.services.kinesis.model.ListShardsRequest; import software.amazon.awssdk.services.kinesis.model.ListShardsResponse; import java.util.concurrent.TimeUnit; public class ShardSample { public static void main(String[] args) { KinesisAsyncClient client = KinesisAsyncClient.builder().build(); ListShardsRequest request = ListShardsRequest .builder().streamName("myFirstStream") .build(); try { ListShardsResponse response = client.listShards(request).get(5000, TimeUnit.MILLISECONDS); System.out.println(response.toString()); } catch (Exception e) { System.out.println(e.getMessage()); } } } ``` Para ejecutar el ejemplo de código anterior puede utilizar un archivo POM como el siguiente. ``` 4.0.0 kinesis.data.streams.samples shards 1.0-SNAPSHOT org.apache.maven.plugins maven-compiler-plugin 8 8 software.amazon.awssdk kinesis 2.0.0 ``` Con la `ListShards` API, puede usar el [ShardFilter](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_ShardFilter.html)parámetro para filtrar la respuesta de la API. Solo puede especificar un filtro a la vez. Si utilizas el `ShardFilter` parámetro al invocar la ListShards API, `Type` es la propiedad obligatoria y debes especificarla. Si especifica los tipos `AT_TRIM_HORIZON`, `FROM_TRIM_HORIZON` o `AT_LATEST`, no necesita especificar las propiedades opcionales `ShardId` o `Timestamp`. Si especifica el tipo `AFTER_SHARD_ID`, también deberá proporcionar el valor de la propiedad opcional `ShardId`. La `ShardId` propiedad tiene una funcionalidad idéntica a la del `ExclusiveStartShardId` parámetro de la ListShards API. Cuando se especifica la propiedad `ShardId`, la respuesta incluye las particiones que comienzan con la partición cuyo ID sigue inmediatamente al `ShardId` proporcionado. Si especifica el tipo `AT_TIMESTAMP` o `FROM_TIMESTAMP_ID`, también deberá proporcionar el valor de la propiedad opcional `Timestamp`. Si especifica el tipo `AT_TIMESTAMP`, se devolverán todas las particiones que estaban abiertas en la marca de tiempo proporcionada. Si se especifica el tipo `FROM_TIMESTAMP`, se devolverán todas las particiones a partir de la fecha y hora indicadas hasta TIP. **importante** `DescribeStreamSummary`y `ListShard` APIs proporcionan una forma más escalable de recuperar información sobre sus flujos de datos. Más específicamente, las cuotas de la DescribeStream API pueden provocar limitaciones. Para obtener más información, consulte [Cuotas y límites](service-sizes-and-limits.md). Ten en cuenta también que `DescribeStream` las cuotas se comparten entre todas las aplicaciones que interactúan con todos los flujos de datos de tu AWS cuenta. Las cuotas de la ListShards API, por otro lado, son específicas para un único flujo de datos. Por lo tanto, no solo se obtiene un TPS más alto con la ListShards API, sino que la acción se amplía mejor a medida que se crean más flujos de datos. Le recomendamos que migre a todos los productores y consumidores que utilizan la DescribeStream API para que, en su lugar, invoquen la DescribeStreamSummary y la. ListShard APIs Para identificar a estos productores y consumidores, recomendamos utilizar Athena para analizar los CloudTrail registros, ya que los agentes de usuario de KPL y KCL se capturan en las llamadas a la API. ``` SELECT useridentity.sessioncontext.sessionissuer.username, useridentity.arn,eventname,useragent, count(*) FROM cloudtrail_logs WHERE Eventname IN ('DescribeStream') AND eventtime BETWEEN '' AND '' GROUP BY useridentity.sessioncontext.sessionissuer.username,useridentity.arn,eventname,useragent ORDER BY count(*) DESC LIMIT 100 ``` También recomendamos volver a configurar las integraciones de AWS Lambda y Amazon Firehose con Kinesis Data Streams que invocan la API para que, en su lugar, `DescribeStream` las integraciones invoquen y. `DescribeStreamSummary` `ListShards` En concreto, en el caso de AWS Lambda, debe actualizar el mapeo de la fuente de eventos. En el caso de Amazon Firehose, deben actualizarse los permisos de IAM correspondientes para que incluyan el permiso de IAM de `ListShards`. # Eliminar un flujo Puede eliminar un flujo con la consola de Kinesis Data Streams o mediante programación. Para eliminar una secuencia de forma programada, utilice `DeleteStreamRequest` tal y como se muestra en el siguiente código. ``` DeleteStreamRequest deleteStreamRequest = new DeleteStreamRequest(); deleteStreamRequest.setStreamName(myStreamName); client.deleteStream(deleteStreamRequest); ``` Cierre todas las aplicaciones que utilicen la secuencia antes de eliminarla. Si una aplicación intenta utilizar secuencias eliminadas, recibirá excepciones `ResourceNotFound`. Además, si posteriormente crea una secuencia nueva con el mismo nombre que la secuencia anterior y las aplicaciones que utilizaban esta siguen en ejecución, dichas aplicaciones podrían intentar interactuar con la secuencia nueva como si fuera la secuencia anterior, con resultados impredecibles. # Cambiar las particiones de un flujo **importante** Puede volver a fragmentar su transmisión mediante la API. [UpdateShardCount](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_UpdateShardCount.html) También puede seguir realizando las divisiones y las fusiones como explicamos aquí. Amazon Kinesis Data Streams permite *efectuar cambios en las particiones*, lo que le implica ajustar el número de particiones de la secuencia para adaptarse a los cambios en la velocidad del flujo de datos en la secuencia. Los cambios en las particiones se consideran operaciones avanzadas. Si es la primera vez que utiliza Kinesis Data Streams, vuelva a este tema después de familiarizarse con todos los demás aspectos de Kinesis Data Streams. Existen dos tipos de operaciones de cambio de los fragmentos: división de fragmento y fusión de fragmentos. En una división, se divide un único fragmento en dos fragmentos. En una fusión, se combinan dos fragmentos en un único fragmento. Los cambios en los fragmentos siempre se realizan *en pares*, es decir, no se puede dividir en más de dos fragmentos en una sola operación y no se pueden fusionar más de dos fragmentos en una sola operación. El fragmento o par de fragmentos sobre los que actúa la operación de cambio se denominan fragmentos *principales*. El fragmento o par de fragmentos que surge como resultado de la operación de cambio se denominan fragmentos *secundarios*. La división aumenta el número de fragmentos en la secuencia, y por tanto incrementa la capacidad de datos de la misma. Dado que se le cobrará por fragmento, la división aumenta el costo de su secuencia. Del mismo modo, la fusión reduce el número de fragmentos en la secuencia, y por tanto disminuye la capacidad de datos y el costo de la misma. Los cambios en los fragmentos suele realizarlos una aplicación administrativa distinta de las aplicaciones productoras (put) y consumidoras (get). Una aplicación administrativa de este tipo supervisa el rendimiento general de la transmisión en función de las métricas proporcionadas por Amazon CloudWatch o en función de las métricas recopiladas de los productores y los consumidores. La aplicación administrativa también necesita un conjunto de permisos de IAM más amplio que el de los consumidores o los productores, ya que los consumidores y los productores normalmente no deberían necesitar acceder al material APIs utilizado para volver a fragmentarlo. Para más información sobre los permisos de IAM para Kinesis Data Streams, consulte [Control del acceso a los recursos de Amazon Kinesis Data Streams mediante IAM](controlling-access.md). Para más información sobre cambios en las particiones, consulte [¿Cómo puedo cambiar el número de particiones abiertas en Kinesis Data Streams?](https://aws.amazon.com/premiumsupport/knowledge-center/kinesis-data-streams-open-shards/) **Topics** + [Decidir una estrategia para volver a particionar](kinesis-using-sdk-java-resharding-strategies.md) + [Dividir una partición](kinesis-using-sdk-java-resharding-split.md) + [Fusionar dos particiones](kinesis-using-sdk-java-resharding-merge.md) + [Completar la acción de volver a particionar](kinesis-using-sdk-java-after-resharding.md) # Decidir una estrategia para volver a particionar El objetivo de realizar cambios en las particiones en Amazon Kinesis Data Streams es que la secuencia pueda adaptarse a los cambios en la velocidad del flujo de datos. Puede dividir fragmentos para aumentar la capacidad (y los costos) de la secuencia. Puede fusionar fragmentos para reducir el costo (y la capacidad) de la secuencia. Una forma de hacerlo sería dividir todas las particiones del flujo, lo que duplicaría su capacidad. Sin embargo, esto podría facilitar una capacidad adicional mayor que la que necesita realmente y, por tanto, crear costos innecesarios. También puede utilizar métricas para determinar cuáles son sus particiones *calientes* o *frías*, es decir, particiones que reciben muchos más datos o muchos menos datos de lo esperado. A continuación, puede dividir los fragmentos "calientes" de manera selectiva para aumentar la capacidad de las claves hash que se dirigen a esos fragmentos. Del mismo modo, podría fusionar fragmentos "fríos "para aprovechar mejor su capacidad. Puede obtener algunos datos de rendimiento para su transmisión a partir de las CloudWatch métricas de Amazon que publica Kinesis Data Streams. Sin embargo, también puede recopilar sus propias métricas para las secuencias. Podría registrar los valores de las claves hash generadas por las claves de partición de sus registros de datos. Recuerde especificar la clave de partición en el momento en el que añada el registro a la secuencia. ``` putRecordRequest.setPartitionKey( String.format( "myPartitionKey" ) ); ``` Kinesis Data Streams [MD5](http://en.wikipedia.org/wiki/MD5)utiliza para calcular la clave hash a partir de la clave de partición. Como usted especifica la clave de partición para el registro, puede utilizarla MD5 para calcular el valor de la clave hash de ese registro y registrarlo. También puede registrar los fragmentos a IDs los que están asignados los registros de datos. Puede consultar la ID de fragmento utilizando el método `getShardId` del objeto `putRecordResults` que devuelve el método `putRecords` y el objeto `putRecordResult` que devuelve el método `putRecord`. ``` String shardId = putRecordResult.getShardId(); ``` Con los valores del fragmento IDs y la clave hash, puede determinar qué fragmentos y claves hash reciben más o menos tráfico. A continuación, puede utilizar los cambios en los fragmentos para proporcionar más o menos capacidad, según proceda para estas claves. # Dividir una partición Para dividir una partición en Amazon Kinesis Data Streams, debe especificar cómo deben redistribuirse los valores de clave hash de la partición principal a las particiones secundarias. Cuando añade un registro de datos a una secuencia, se asigna a un fragmento según un valor de clave hash. El valor de la clave hash es el [MD5](http://en.wikipedia.org/wiki/MD5)hash de la clave de partición que se especifica para el registro de datos en el momento de añadir el registro de datos a la transmisión. Los registros de datos que tengan la misma clave de partición también tienen el mismo valor de clave hash. Los valores de clave hash posibles para un fragmento dado constituyen un conjunto de valores enteros positivos, ordenados y contiguos. Esta serie de posibles valores de clave hash viene dada por: ``` shard.getHashKeyRange().getStartingHashKey(); shard.getHashKeyRange().getEndingHashKey(); ``` Al dividir el fragmento especifica un valor de este rango. Ese valor de clave hash y todos los valores de clave hash superiores se distribuyen a uno de los fragmentos secundarios. Todos los valores de clave hash inferiores se distribuyen a los demás fragmentos secundarios. El código siguiente ilustra una operación de división de fragmentos que redistribuye las claves hash de manera uniforme entre cada uno de los fragmentos secundarios, básicamente dividiendo a la mitad el fragmento principal. Esta es solo una de las posibles formas de dividir el fragmento principal. Podría, por ejemplo, dividir el fragmento de forma que el tercio más bajo de las claves del fragmento principal vaya a uno de los fragmentos secundarios y los dos tercios más altos de las claves vayan al otro fragmento secundario. Sin embargo, para muchas aplicaciones, la división de fragmentos a la mitad resulta un enfoque eficaz. El código asume que `myStreamName` contiene el nombre de la secuencia y la variable de objeto `shard` contiene el fragmento que se ha de dividir. Empiece por crear una instancia de un nuevo objeto `splitShardRequest` y por introducir un nombre para la secuencia y una ID para el fragmento. ``` SplitShardRequest splitShardRequest = new SplitShardRequest(); splitShardRequest.setStreamName(myStreamName); splitShardRequest.setShardToSplit(shard.getShardId()); ``` Determine el valor de clave hash que está a medio camino entre los valores mínimo y máximo del fragmento. Este será el valor de clave hash inicial para el fragmento secundario que contendrá la mitad superior de las claves hash del fragmento principal. Especifique este valor en el método `setNewStartingHashKey`. Solo necesita especificar este valor. Kinesis Data Streams distribuye automáticamente las claves hash por debajo de este valor a la otra partición primaria creada por la división. El último paso consiste en llamar al método `splitShard` en el cliente de Kinesis Data Streams. ``` BigInteger startingHashKey = new BigInteger(shard.getHashKeyRange().getStartingHashKey()); BigInteger endingHashKey = new BigInteger(shard.getHashKeyRange().getEndingHashKey()); String newStartingHashKey = startingHashKey.add(endingHashKey).divide(new BigInteger("2")).toString(); splitShardRequest.setNewStartingHashKey(newStartingHashKey); client.splitShard(splitShardRequest); ``` El primer paso tras este procedimiento se muestra en [Esperar a que un flujo se active de nuevo](kinesis-using-sdk-java-after-resharding.md#kinesis-using-sdk-java-resharding-wait-until-active). # Fusionar dos particiones Una operación de fusión toma dos fragmentos especificados y los combina en un único fragmento. Tras la fusión, el fragmento secundario recibe los datos de todos los valores de claves hash que cubrían los dos fragmentos principales. **Adyacencia de fragmentos** Para fusionar dos fragmentos, estos deben ser *adyacentes*. Se considera que dos fragmentos son adyacentes si la unión de los rangos de las claves hash de ambos forma un conjunto continuo sin huecos. Por ejemplo, supongamos que tiene dos fragmentos, uno con un rango de clave hash de 276...381 y el otro con un rango de clave hash de 382...454. Podría fusionar estos dos fragmentos en uno, que tendría un rango de clave hash de 276...454. Por tomar otro ejemplo, supongamos que tiene dos fragmentos, uno con un rango de clave hash de 276...381 y el otro con un rango de clave hash de 455...560. No es posible combinar estos dos fragmentos, ya que habría uno o varios fragmentos entre ellos abarcando el rango 382...454. El conjunto de todos los `OPEN` fragmentos de una transmisión, como grupo, siempre abarca todo el rango de valores de las claves hash. MD5 Para obtener más información sobre los estados de los fragmentos, como `CLOSED`, consulte [Tener en cuenta el direccionamiento de datos, persistencia de datos y estado de particiones tras los cambios en las particiones](kinesis-using-sdk-java-after-resharding.md#kinesis-using-sdk-java-resharding-data-routing). Para identificar fragmentos candidatos a la fusión, debe filtrar todos los que están en un estado `CLOSED`. Las particiones que están `OPEN` (es decir, no `CLOSED`) tienen un número secuencial final de `null`. Puede comprobar el número secuencial final de un fragmento con: ``` if( null == shard.getSequenceNumberRange().getEndingSequenceNumber() ) { // Shard is OPEN, so it is a possible candidate to be merged. } ``` Después de filtrar los fragmentos cerrados, ordene los fragmentos restantes por el valor de clave hash más alto que permita cada fragmento. Puede recuperar este valor mediante: ``` shard.getHashKeyRange().getEndingHashKey(); ``` Si hay dos fragmentos adyacentes en la lista filtrada y ordenada, se pueden fusionar. **Código para la operación de fusión** Con el siguiente código se fusionan dos fragmentos. El código asume que `myStreamName` contiene el nombre de la secuencia y las variables de objeto `shard1` y `shard2` contienen los dos fragmentos adyacentes que se han de fusionar. Para la operación de fusión, comience por crear una instancia de un nuevo objeto `mergeShardsRequest`. Especifique el nombre de la secuencia con el método `setStreamName`. A continuación, especifique qué dos fragmentos quiere fusionar con los métodos `setShardToMerge` y `setAdjacentShardToMerge`. Por último, llame al método `mergeShards` en el cliente de Kinesis Data Streams para realizar la operación. ``` MergeShardsRequest mergeShardsRequest = new MergeShardsRequest(); mergeShardsRequest.setStreamName(myStreamName); mergeShardsRequest.setShardToMerge(shard1.getShardId()); mergeShardsRequest.setAdjacentShardToMerge(shard2.getShardId()); client.mergeShards(mergeShardsRequest); ``` El primer paso tras este procedimiento se muestra en [Esperar a que un flujo se active de nuevo](kinesis-using-sdk-java-after-resharding.md#kinesis-using-sdk-java-resharding-wait-until-active). # Completar la acción de volver a particionar Después de realizar cualquier tipo de procedimiento que implique cambios en las particiones en Amazon Kinesis Data Streams y antes de reanudar el procesamiento de registros normal, son necesarios otros procedimientos y consideraciones. Estos pasos se describen en las siguientes secciones. **Topics** + [Esperar a que un flujo se active de nuevo](#kinesis-using-sdk-java-resharding-wait-until-active) + [Tener en cuenta el direccionamiento de datos, persistencia de datos y estado de particiones tras los cambios en las particiones](#kinesis-using-sdk-java-resharding-data-routing) ## Esperar a que un flujo se active de nuevo Tras realizar una operación de cambio de partición, ya sea `splitShard` o `mergeShards`, tendrá que esperar a que el flujo vuelva a estar activo. El código que ha de usar es el mismo que al esperar a que una secuencia se active tras la [creación de una secuencia](kinesis-using-sdk-java-create-stream.md). Ese código es el siguiente: ``` DescribeStreamRequest describeStreamRequest = new DescribeStreamRequest(); describeStreamRequest.setStreamName( myStreamName ); long startTime = System.currentTimeMillis(); long endTime = startTime + ( 10 * 60 * 1000 ); while ( System.currentTimeMillis() < endTime ) { try { Thread.sleep(20 * 1000); } catch ( Exception e ) {} try { DescribeStreamResult describeStreamResponse = client.describeStream( describeStreamRequest ); String streamStatus = describeStreamResponse.getStreamDescription().getStreamStatus(); if ( streamStatus.equals( "ACTIVE" ) ) { break; } // // sleep for one second // try { Thread.sleep( 1000 ); } catch ( Exception e ) {} } catch ( ResourceNotFoundException e ) {} } if ( System.currentTimeMillis() >= endTime ) { throw new RuntimeException( "Stream " + myStreamName + " never went active" ); } ``` ## Tener en cuenta el direccionamiento de datos, persistencia de datos y estado de particiones tras los cambios en las particiones Kinesis Data Streams es un servicio de flujo de datos en tiempo real. Las aplicaciones deberían presuponer que los datos fluyen de forma continua a través de las particiones en el flujo. Cuando realiza cambios en los fragmentos, los registros de datos dirigidos a los fragmentos principales se redireccionan a los fragmentos secundarios en función de los valores de clave hash que asignan las claves de partición de los registros de datos. Sin embargo, los registros de datos que estaban en los fragmentos principales antes de los cambios permanecerán en dichos fragmentos. Las particiones principales no desaparecen cuando se producen los cambios. Persistirán junto con los datos que contenían antes de los cambios. Se puede acceder a los registros de datos de las particiones principales mediante las operaciones [`getShardIterator` y `getRecords`](developing-consumers-with-sdk.md#kinesis-using-sdk-java-get-data) de la API de Kinesis Data Streams, o a través de Kinesis Client Library. **nota** Se puede obtener acceso a los registros de datos a partir del momento en el que se agregan a la secuencia y hasta el periodo de retención actual. Esto es así independientemente de los cambios en los fragmentos de la secuencia durante ese periodo. Para obtener más información acerca del periodo de retención de una secuencia, consulte [Cambiar el periodo de retención de datos](kinesis-extended-retention.md). En el proceso de realizar cambios en los fragmentos, un fragmento principal cambia de un estado `OPEN` a un estado `CLOSED`, y después a un estado `EXPIRED`. + **OPEN**: antes de una operación de cambio en los fragmentos, un fragmento principal tiene el estado `OPEN`, lo que significa que los registros de datos pueden tanto agregarse al fragmento como recuperarse desde él. + **CLOSED**: tras una operación de cambio en los fragmentos, el fragmento principal cambia a un estado `CLOSED`. Esto implica que ya no se agregan registros de datos al fragmento. Los registros de datos que se habrían añadido a este fragmento se agregarán a un fragmento secundario en su lugar. Sin embargo, se pueden seguir recuperando registros de datos desde el fragmento durante un tiempo limitado. + **EXPIRED**: tras vencer el periodo de retención de la secuencia, todos los registros de datos del fragmento principal habrán caducado y ya no se podrá obtener acceso a ellos. En este punto, el propio fragmento cambia a un estado `EXPIRED`. Las llamadas a `getStreamDescription().getShards` para enumerar los fragmentos de la secuencia no incluyen los fragmentos `EXPIRED` en la lista de fragmentos que devuelve. Para obtener más información acerca del periodo de retención de una secuencia, consulte [Cambiar el periodo de retención de datos](kinesis-extended-retention.md). Tras realizar los cambios en los fragmentos, y cuando la secuencia ha recuperado el estado `ACTIVE`, podría comenzar inmediatamente a leer datos en los fragmentos secundarios. Sin embargo, las particiones principales que permanecen tras realizar los cambios podrían seguir conteniendo datos que aún no se han leído y que se habrían agregado al flujo antes de los cambios. Si lee datos de los fragmentos secundarios antes de haber leído todos los datos de los fragmentos principales, podría leer datos de una clave hash determinada fuera del orden determinado por los números secuenciales de los registros de datos. Por lo tanto, suponiendo que el orden de los datos sea importante, después de un cambio en los fragmentos siempre se deben seguir leyendo datos de los fragmentos principales hasta que se agoten. Solo entonces debería empezar a leer datos de los fragmentos secundarios. Cuando `getRecordsResult.getNextShardIterator` devuelve `null`, indica que ya ha leído todos los datos del fragmento principal. # Cambiar el periodo de retención de datos Amazon Kinesis Data Streams admite cambios en el periodo de retención de los registros de datos del flujo de datos. Un flujo de datos de Kinesis es una secuencia ordenada de registros de datos pensada para que se pueda escribir y leer en ella en tiempo real. Por lo tanto, los registros de datos se almacenan temporalmente en fragmentos de su secuencia. El periodo de tiempo desde que se agrega un registro hasta que ya no se puede obtener acceso a él se denomina *periodo de retención*. Un flujo de datos de Kinesis almacena registros desde 24 horas de forma predeterminada, hasta 8760 horas (365 días). Puede actualizar el período de retención mediante la consola de Kinesis Data Streams o mediante [IncreaseStreamRetentionPeriod](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_IncreaseStreamRetentionPeriod.html)las operaciones y [DecreaseStreamRetentionPeriod](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_DecreaseStreamRetentionPeriod.html). Con la consola de Kinesis Data Streams, puede editar en bloque el periodo de retención de más de un flujo de datos al mismo tiempo. Puede aumentar el período de retención hasta un máximo de 8760 horas (365 días) mediante la [IncreaseStreamRetentionPeriod](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_IncreaseStreamRetentionPeriod.html)operación o la consola de Kinesis Data Streams. Puede reducir el período de retención hasta un mínimo de 24 horas mediante la [DecreaseStreamRetentionPeriod](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_DecreaseStreamRetentionPeriod.html)operación o la consola de Kinesis Data Streams. La sintaxis de la solicitud para ambas operaciones incluye el nombre de la secuencia y el periodo de retención en horas. Por último, puede comprobar el periodo de retención actual de una secuencia si llama a la operación [DescribeStream](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_DescribeStream.html). A continuación, se muestra un ejemplo de cambio del periodo de retención usando la AWS CLI: ``` aws kinesis increase-stream-retention-period --stream-name retentionPeriodDemo --retention-period-hours 72 ``` Kinesis Data Streams deja de producir registros inaccesibles en el antiguo período de retención en unos minutos tras aumentar el periodo de retención. Por ejemplo, cambiar el periodo de retención de 24 horas a 48 horas implica que los registros añadidos a la secuencia 23 horas y 55 minutos antes seguirán estando disponibles después de que hayan transcurrido 24 horas. Kinesis Data Streams hace que los registros más antiguos que el nuevo periodo de retención sean inaccesibles casi inmediatamente tras reducir el periodo de retención. Por tanto, debe tener mucho cuidado al llamar a la operación [DecreaseStreamRetentionPeriod](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_DecreaseStreamRetentionPeriod.html). Establezca el periodo de retención de datos para garantizar que sus consumidores puedan leer los datos antes de que estos venzan, por si surge algún problema. Debe tener en cuenta detenidamente todas las posibilidades, como, por ejemplo, un problema con la lógica de procesamiento de registros o que una dependencia posterior esté inactiva durante un periodo prolongado de tiempo. Piense en el periodo de retención como si fuera una red de seguridad que proporciona un mayor tiempo de recuperación para los consumidores de datos. Las operaciones de la API para el periodo de retención le permiten realizar esta configuración de forma proactiva o responder a eventos operativos de forma reactiva. Para las secuencias con periodos de retención mayores a 24 horas se aplican cargos adicionales. Para obtener más información, consulte los [precios de Amazon Kinesis Data Streams](https://aws.amazon.com/kinesis/data-streams/pricing/). # Etiquetar recursos de Amazon Kinesis Data Streams Puede asignar sus propios metadatos a los flujos y a los consumidores de distribución ramificada mejorada que cree en Amazon Kinesis Data Streams en forma de *etiquetas*. Una etiqueta es un par clave-valor definido por el usuario para un flujo. El uso de etiquetas es una forma sencilla pero eficaz de gestionar AWS los recursos y organizar los datos, incluidos los datos de facturación. **Topics** + [Revisar los conceptos básicos de etiquetas](#tagging-basics) + [Seguir costos mediante etiquetado](#tagging-billing) + [Comprender las restricciones de las etiquetas](#tagging-restrictions) + [Etiquetar flujos mediante la consola de Kinesis Data Streams](#tagging-console) + [Etiquete las transmisiones mediante el AWS CLI](#tagging-cli) + [Etiquete las transmisiones con Kinesis Data Streams APIs](#tagging-api) + [Etiquete a los consumidores mediante el AWS CLI](#tagging-consumers-cli) + [Etiquete a los consumidores mediante Kinesis Data Streams APIs](#tagging-consumers-api) ## Revisar los conceptos básicos de etiquetas Los recursos de Kinesis Data Streams que se pueden etiquetar son los flujos de datos y consumidores con distribución ramificada mejorada. Utilice la consola AWS CLI de Kinesis Data Streams o la API de Kinesis Data Streams para realizar las siguientes tareas: + crear un recurso con etiquetas, + agregar etiquetas a un recurso, + enumerar las etiquetas de los recursos, + eliminar etiquetas de un recurso. **nota** No es posible aplicar etiquetas a consumidores de distribución ramificada mejorada mediante la consola de Kinesis Data Streams. Para aplicar etiquetas a los consumidores, utilice nuestra API AWS CLI de Kinesis Data Streams. Puede utilizar etiquetas para categorizar sus recursos . Por ejemplo, puede clasificar los recursos en categorías por objetivo, propietario o entorno. Dado que define la clave y el valor de cada etiqueta, puede crear un conjunto de categorías personalizadas para satisfacer sus necesidades específicas. Por ejemplo, podría definir un conjunto de etiquetas que le ayude a realizar un seguimiento de los recursos por propietario y aplicaciones asociadas. Estos son algunos ejemplos de etiquetas: + Proyecto: nombre del proyecto + Propietario: nombre + Objetivo: pruebas de carga + Aplicación: nombre de aplicación + Entorno: producción **importante** Para agregar etiquetas al crear un flujo, debe incluir los permisos `kinesis:CreateStream` y `kinesis:AddTagsToStream` para ese flujo. **No se puede utilizar** el permiso `kinesis:TagResource` para etiquetar flujos al crearlos. Para agregar etiquetas durante el registro de un consumidor, debe incluir los permisos `kinesis:TagResource` y `kinesis:RegisterStreamConsumer`. ## Seguir costos mediante etiquetado Puede usar etiquetas para categorizar y realizar un seguimiento de sus AWS costos. Al aplicar etiquetas a los recursos de Kinesis Data Streams, AWS el informe de asignación de costes incluye el uso y los costes agregados por etiquetas. Puede aplicar etiquetas que representen categorías de negocio (como centros de costos, nombres de aplicación o propietarios) para estructurar los costos entre diferentes servicios. Para obtener más información, consulte [Utilizar etiquetas de asignación de costos para informes de facturación personalizados](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html) en la *Guía del usuario de AWS Billing *. ## Comprender las restricciones de las etiquetas Se aplican las siguientes restricciones a las etiquetas: **Restricciones básicas** + El número máximo de etiquetas para cada recurso es de 50. + Las claves y los valores de las etiquetas distinguen entre mayúsculas y minúsculas. + No se pueden cambiar ni editar etiquetas de un recurso eliminado. **Restricciones de clave de etiqueta** + Cada clave de etiqueta debe ser única. Si agrega una etiqueta con una clave que ya está en uso, la nueva etiqueta sobrescribe el par clave-valor existente. + No puedes empezar una clave de etiqueta con él `aws:` porque este prefijo está reservado para que lo usen. AWS AWS crea etiquetas que comienzan con este prefijo en tu nombre, pero no puedes editarlas ni eliminarlas. + Las claves de etiqueta deben tener entre 1 y 128 caracteres Unicode de longitud. + Las claves de etiquetas deben constar de los siguientes caracteres: letras Unicode, números, espacios en blanco y los siguientes caracteres especiales: `_ . / = + - @`. **Restricciones de valor de etiqueta** + Los valores de etiqueta deben tener entre 0 y 255 caracteres Unicode de longitud. + Los valores de etiqueta pueden estar en blanco. De lo contrario, deben constar de los siguientes caracteres: letras Unicode, números, espacios en blanco y cualquiera de los siguientes caracteres especiales: `_ . / = + - @`. ## Etiquetar flujos mediante la consola de Kinesis Data Streams Puede agregar, actualizar, enumerar y eliminar etiquetas de sus flujos con la consola de Kinesis Data Streams. **Para ver las etiquetas de una secuencia** 1. [Inicie sesión en la consola de Kinesis Consola de administración de AWS y ábrala en https://console.aws.amazon.com /kinesis.](https://console.aws.amazon.com/kinesis) 1. En el panel de navegación izquierdo, elija **Flujos de datos**. 1. En la página **Flujos de datos**, seleccione el flujo que desea etiquetar. 1. En la página de detalles de Stream, seleccione **Configuración**. 1. En la sección **Etiquetas**, consulte las etiquetas aplicadas al flujo. **Crear un flujo de datos con una etiqueta** 1. Abra la consola de Kinesis Data Streams. 1. En el panel de navegación izquierdo, elija **Flujos de datos**. 1. Elija **Create data stream (Crear flujo de datos)**. 1. En la página **Crear flujo de datos**, escriba un nombre para su flujo de datos. 1. En **Capacidad de flujo de datos**, elija el modo de capacidad **Bajo demanda** o **Aprovisionado**. Para obtener más información acerca de los modos de capacidad, consulte [Elegir el modo correcto para el flujo](how-do-i-size-a-stream.md). 1. En la sección **Etiquetas**, haga lo siguiente: 1. Elija **Añadir nueva etiqueta**. 1. En **Clave**, ingrese la etiqueta y seleccione, de manera opcional, un valor en el campo **Valor**. Si detecta un error, la clave o el valor de la etiqueta que especificó no cumple con las restricciones de la etiqueta. Para obtener más información, consulte [Comprender las restricciones de las etiquetas](#tagging-restrictions). 1. Elija **Create data stream (Crear flujo de datos)**. **Cómo agregar o actualizar una etiqueta en un flujo** 1. Abra la consola de Kinesis Data Streams. 1. En el panel de navegación izquierdo, elija **Flujos de datos**. 1. En la página **Flujos de datos**, elija el flujo en el que desee agregar o actualizar las etiquetas. 1. En la página de detalles de Stream, seleccione **Configuración**. 1. En la sección **Etiquetas**, elija **Administrar etiquetas**. 1. En **Etiquetas**, elija una de las siguientes opciones: + Para agregar una etiqueta, elija **Agregar nueva etiqueta** y, a continuación, ingrese la **Clave** de la etiqueta y los datos del**Valor**. Repita este paso tantas veces como sea necesario. El número máximo de etiquetas que puede agregar a cada flujo es de 50. + Para actualizar una etiqueta existente, ingrese un nuevo valor de etiqueta en el campo **Valor** de la **Clave** de esa etiqueta. Si detecta un error, la clave o el valor de la etiqueta que especificó no cumple con las restricciones de la etiqueta. Para obtener más información, consulte [Comprender las restricciones de las etiquetas](#tagging-restrictions). 1. Elija **Save changes (Guardar cambios)**. **Para eliminar una etiqueta de una secuencia** 1. Abra la consola de Kinesis Data Streams. 1. En el panel de navegación izquierdo, elija **Flujos de datos**. 1. En la página **Flujos de datos**, elija el flujo del que desea eliminar etiquetas. 1. En la página de detalles de Stream, seleccione **Configuración**. 1. En la sección **Etiquetas**, elija **Administrar etiquetas**. 1. Busque el par de etiqueta **Clave** y **Valor** que desea eliminar. Luego, seleccione **Eliminar**. 1. Seleccione **Save changes (Guardar cambios)**. ## Etiquete las transmisiones mediante el AWS CLI Puede agregar, enumerar y eliminar etiquetas de los flujos mediante la AWS CLI. Para ver ejemplos, consulte la documentación siguiente. [create-stream](https://docs.aws.amazon.com/cli/latest/reference/kinesis/create-stream.html) Crea un flujo con etiquetas. [add-tags-to-stream](https://docs.aws.amazon.com/cli/latest/reference/kinesis/add-tags-to-stream.html) Añade o actualiza las etiquetas para la secuencia especificada. [list-tags-for-stream](https://docs.aws.amazon.com/cli/latest/reference/kinesis/list-tags-for-stream.html) Enumera las etiquetas de la secuencia especificada. [remove-tags-from-stream](https://docs.aws.amazon.com/cli/latest/reference/kinesis/remove-tags-from-stream.html) Elimina las etiquetas de la secuencia especificada. ## Etiquete las transmisiones con Kinesis Data Streams APIs Puede añadir, enumerar y eliminar etiquetas de sus transmisiones mediante Kinesis Data APIs Streams. Para ver ejemplos, consulte la documentación siguiente: [CreateStream](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_CreateStream.html) Crea un flujo con etiquetas. [AddTagsToStream](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_AddTagsToStream.html) Añade o actualiza las etiquetas para la secuencia especificada. [ListTagsForStream](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_ListTagsForStream.html) Enumera las etiquetas de la secuencia especificada. [RemoveTagsFromStream](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_RemoveTagsFromStream.html) Elimina las etiquetas de la secuencia especificada. ## Etiquete a los consumidores mediante el AWS CLI Puede agregar, enumerar y eliminar etiquetas de sus consumidores mediante la AWS CLI. Para ver ejemplos, consulte la documentación siguiente: [register-stream-consumer](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kinesis/register-stream-consumer.html) Registra un consumidor para un flujo de datos de Kinesis con etiquetas [tag-resource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kinesis/tag-resource.html) Agrega o actualiza las etiquetas para el recurso de Kinesis especificado [list-tags-for-resource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kinesis/list-tags-for-resource.html) Muestra una lista de las etiquetas del recurso de Kinesis especificado [untag-resource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kinesis/untag-resource.html) Elimina las etiquetas del recurso de Kinesis especificado ## Etiquete a los consumidores mediante Kinesis Data Streams APIs Puede añadir, enumerar y eliminar etiquetas de sus consumidores mediante Kinesis Data APIs Streams. Para ver ejemplos, consulte la documentación siguiente: [RegisterStreamConsumer](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_RegisterStreamConsumer.html) Registra un consumidor para un flujo de datos de Kinesis con etiquetas [TagResource](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_TagResource.html) Agrega o actualiza las etiquetas para el recurso de Kinesis especificado [ListTagsForResource](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_ListTagsForResource.html) Muestra una lista de las etiquetas del recurso de Kinesis especificado [UntagResource](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_UntagResource.html) Elimina las etiquetas del recurso de Kinesis especificado # Gestión de registros de gran tamaño Amazon Kinesis Data Streams admite registros de hasta 10 MiBs mebibytes (). Esta capacidad se recomienda para procesar cargas útiles de datos intermitentes que superen el límite de tamaño de registro predeterminado de 1 MiB. El tamaño de registro máximo predeterminado para las transmisiones existentes y nuevas es de 1 MiB. Esta característica beneficia a las aplicaciones de Internet de las cosas (IoT), a los procesos de captura de datos de cambios (CDC) y a los flujos de trabajo de machine learning que requieren procesar cargas de datos eventuales de mayor tamaño. Si desea comenzar a utilizar registros de gran tamaño en su flujo, actualice el límite máximo de tamaño de registro del flujo. **importante** El límite de rendimiento de cada fragmento individual, de 1 MB/s para las escrituras y 2 MB/s para las lecturas, se mantiene sin cambios y admite registros de mayor tamaño. Kinesis Data Streams está diseñado para admitir registros intermitentes de gran tamaño, además de un tráfico base de registros inferior o igual a 1 MiB. Pero no para permitir la ingesta sostenida de grandes volúmenes de registros de gran tamaño. ## Actualice su flujo para usar registros de gran tamaño **Cómo procesar registros de gran tamaño con Kinesis Data Streams** 1. Vaya a la consola de Kinesis Data Streams. 1. Seleccione su flujo y vaya a la pestaña **Configuración**. 1. Haga clic en **Editar** junto a **Tamaño máximo de registro**. 1. Establezca el tamaño máximo de registro (hasta 10 MiB). 1. Guarde los cambios. Esta configuración solo ajusta el tamaño máximo de registro para este flujo de datos de Kinesis. Antes de aumentar este límite, compruebe que todas las aplicaciones posteriores puedan gestionar registros de mayor tamaño. También puede actualizar esta configuración mediante la AWS CLI: ``` aws kinesis update-max-record-size \ --stream-arn \ --max-record-size-in-ki-b 5000 ``` ## Optimice el rendimiento de su flujo con registros de gran tamaño Se recomienda que los registros de gran tamaño representen menos del 2 % del tráfico total. En un flujo, cada partición tiene una capacidad de rendimiento de 1 MiB por segundo. Para dar cabida a registros de gran tamaño, las transmisiones de Kinesis Data transmiten ráfagas de hasta 10 MiBs, con un promedio de 1 MiB por segundo. La capacidad para admitir registros de gran tamaño se recarga de forma continua en el flujo. La velocidad de recarga depende del tamaño de los registros de gran tamaño y del tamaño del registro base. Para obtener mejores resultados, utilice una clave de partición distribuida de manera uniforme. Para obtener más información sobre cómo se escala Kinesis bajo demanda, consulte [ Características y casos de uso del modo bajo demanda](how-do-i-size-a-stream.html#ondemandmode). ## Mitigue la limitación con los registros de gran tamaño **Cómo mitigar la limitación** 1. Implemente una lógica de reintento con un retroceso exponencial en su aplicación de producción. 1. Utilice claves de partición aleatorias para distribuir los registros de gran tamaño entre las particiones disponibles. 1. Almacene las cargas útiles en Amazon S3 y envíe solo referencias de metadatos al flujo para flujos continuos de registros de gran tamaño. Para obtener más información, consulte [Processing large records with Amazon Kinesis Data Streams](https://aws.amazon.com/blogs/big-data/processing-large-records-with-amazon-kinesis-data-streams/). ## Gestione registros de gran tamaño con Kinesis Data Streams APIs La compatibilidad con registros de gran tamaño introduce una nueva API y actualiza dos planos de control existentes APIs para gestionar hasta 10 MiBs registros. API para modificar el tamaño de los registros: + `UpdateMaxRecordSize`: configura el límite máximo de tamaño de registro para las transmisiones existentes de hasta 10 MiBs. Actualizaciones de las existentes APIs: + `CreateStream`: agrega el parámetro opcional `MaxRecordSizeInKiB` para establecer los límites de tamaño de los registros durante la creación del flujo. + `DescribeStreamSummary`: devuelve el campo `MaxRecordSizeInKiB` para mostrar la configuración del flujo actual. Todas las que APIs aparecen en la lista mantienen la compatibilidad con versiones anteriores de las transmisiones existentes. Para obtener la documentación completa de las API, consulte la [referencia de API del servicio de Amazon Kinesis Data Streams](https://docs.aws.amazon.com/kinesis/latest/APIReference/Welcome.html). ## AWS componentes compatibles con registros de gran tamaño Los siguientes AWS componentes son compatibles con registros de gran tamaño: | Componente | Description (Descripción) | | --- | --- | | AWS SDK | AWS El SDK admite el manejo de registros de gran tamaño. Puedes actualizar el tamaño máximo de registro de tu transmisión hasta 10 MiB mediante los métodos disponibles en. AWS SDKs Para obtener más información, consulta Cómo [usar este servicio con un SDK](https://docs.aws.amazon.com/streams/latest/dev/sdk-general-information-section.html). AWS | | Kinesis Consumer Library (KCL) | A partir de la versión 2.x, KCL permite la gestión de registros de gran tamaño. Para aprovechar la compatibilidad con los registros de gran tamaño, actualice el `maxRecordSize` de su flujo, y utilice KCL. Para obtener más información, consulte [Uso de Kinesis Client Library](https://docs.aws.amazon.com/streams/latest/dev/kcl.html) | | Kinesis Producer Library (KPL) | A partir de la versión 1.0.5, KPL permite la gestión de registros de gran tamaño. Para aprovechar la compatibilidad con los registros de gran tamaño, actualice el maxRecordSize de su flujo, y utilice KPL. Para obtener más información, consulte [Develop producers using the Amazon Kinesis Producer Library (KPL)](https://docs.aws.amazon.com/streams/latest/dev/developing-producers-with-kpl.html). | | Amazon EMR | Amazon EMR con Apache Spark permite gestionar registros de gran tamaño hasta el límite de Kinesis Data Streams (10). MiBs Para aprovechar la compatibilidad con los registros de gran tamaño, utilice la función `readStream`. Para obtener más información, consulte [Integración de Amazon EMR y Amazon Kinesis](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-kinesis.html). | | Amazon Data Firehose | Cuando se utiliza con Kinesis Data Streams, el comportamiento de Amazon Data Firehose con registros de gran tamaño depende del destino de la entrega: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/streams/latest/dev/large-records.html) En el caso de las aplicaciones que requieran la entrega a Snowflake o Redshift con registros de gran tamaño, entregue primero los datos a Amazon S3. Luego, utilice los procesos de extracción, transformación y carga (ETL) para cargar los datos. Para todos los demás destinos, pruebe el comportamiento con registros de gran tamaño en un proof-of-concept entorno antes de ampliarlo al uso de producción. La gestión de registros de gran tamaño varía según el destino. | | AWS Lambda | AWS Lambda admite cargas útiles de hasta 6 MiBs. Este límite incluye la carga útil de Kinesis convertida a codificación de base 64 y los metadatos asociados a la asignación de orígenes de eventos (ESM). Para registros de menos de 6 MiBs, Lambda los procesa mediante ESM sin necesidad de configuración adicional. Para los registros de más de 6 MiBs, Lambda los procesa utilizando un destino en caso de fallo. Debe configurar un destino en caso de fallo mediante ESM para gestionar registros que superen los límites de procesamiento de Lambda. Cada evento enviado al destino en caso de fallo es un documento JSON que contiene metadatos sobre la invocación fallida. Se recomienda crear un destino en caso de fallo en la ESM, independiente del tamaño del registro. Esto garantiza que no se descarte ningún registro. Para obtener más información, consulte [Configuración de destinos para invocaciones fallidas](https://docs.aws.amazon.com/lambda/latest/dg/kinesis-on-failure-destination.html#kinesis-on-failure-destination-console). | | Amazon Redshift | Amazon Redshift solo admite tamaños de registro inferiores a 1 MiB al transmitir datos desde Kinesis Data Streams. Los registros que superan este límite no se procesan. Los registros que no se procesan se registran como `sys_stream_scan_errors`. Para obtener más información, consulte [SYS\$1STREAM\$1SCAN\$1ERRORS](https://docs.aws.amazon.com/redshift/latest/dg/r_SYS_STREAM_SCAN_ERRORS.html). | | Conector Flink para Kinesis Data Streams | Existen dos enfoques para consumir datos de Kinesis Data Streams: el conector origen de Kinesis y el conector receptor de Kinesis. El conector de origen admite el manejo de registros de menos de 1 MiB y hasta 10. MiBs No utilice el conector receptor para registros de más de 1 MiB. Para obtener más información, consulte [Uso de conectores para mover datos en Amazon Managed Service for Apache Flink con la DataStream API](https://docs.aws.amazon.com/managed-flink/latest/java/how-connectors.html). | ## Regiones en las que se admiten registros de gran tamaño Esta función de Amazon Kinesis Data Streams solo está disponible en las AWS siguientes regiones: | AWS Región | Nombre de la región | | --- | --- | | eu-north-1 | Europa (Estocolmo) | | me-south-1 | Middle East (Bahrain) | | ap-south-1 | Asia-Pacífico (Mumbai) | | eu-west-3 | Europa (París) | | ap-southeast-3 | Asia-Pacífico (Yakarta) | | us-east-2 | Este de EE. UU. (Ohio) | | af-south-1 | África (Ciudad del Cabo) | | eu-west-1 | Europa (Irlanda) | | me-central-1 | Medio Oriente (EAU) | | eu-central-1 | Europa (Fráncfort) | | sa-east-1 | América del Sur (São Paulo) | | ap-east-1 | Asia-Pacífico (Hong Kong) | | ap-south-2 | Asia-Pacífico (Hyderabad) | | us-east-1 | Este de EE. UU. (Norte de Virginia) | | ap-northeast-2 | Asia-Pacífico (Seúl) | | ap-northeast-3 | Asia-Pacífico (Osaka) | | eu-west-2 | Europa (Londres) | | ap-southeast-4 | Asia-Pacífico (Melbourne) | | ap-northeast-1 | Asia-Pacífico (Tokio) | | us-west-2 | Oeste de EE. UU. (Oregón) | | us-west-1 | Oeste de EE. UU. (Norte de California) | | ap-southeast-1 | Asia-Pacífico (Singapur) | | ap-southeast-2 | Asia-Pacífico (Sídney) | | il-central-1 | Israel (Tel Aviv) | | ca-central-1 | Canadá (centro) | | ca-west-1 | Oeste de Canadá (Calgary) | | eu-south-2 | Europa (España) | | cn-northwest-1 | China (Ningxia) | | eu-central-2 | Europa (Zúrich) | | us-gov-east-1 | AWS GovCloud (Este de EE. UU.) | | us-gov-west-1 | AWS GovCloud (Estados Unidos-Oeste) | # Realice pruebas de resiliencia con AWS Fault Injection Service AWS Fault Injection Service es un servicio totalmente gestionado que le ayuda a realizar experimentos de inyección de errores en sus AWS cargas de trabajo. AWS FIS la integración con Amazon Kinesis Data Streams le permite probar la resiliencia de sus aplicaciones frente a errores comunes de la API de Amazon Kinesis Data Streams en un entorno controlado. Esta capacidad permite validar el manejo de errores, la lógica de reintentos y la supervisión de sistemas antes de que se produzcan errores. Para obtener más información, consulte [¿Qué es? AWS Fault Injection Service](https://docs.aws.amazon.com/fis/latest/userguide/what-is.html) . **Acciones** + Error interno de API: inyecta errores internos en las solicitudes realizadas por el rol de IAM de destino. La respuesta específica depende de cada servicio y API. La acción `aws:fis:inject-api-internal-error` crea errores de `InternalFailure` (HTTP 500). + Error de limitación de API: inyecta errores internos en las solicitudes realizadas por el rol de IAM de destino. La respuesta específica depende de cada servicio y API. La acción `aws:fis:inject-api-throttle-error` crea errores de `ThrottlingException` (HTTP 400). + Error de indisponibilidad de API: inyecta errores internos en las solicitudes realizadas por el rol de IAM de destino. La respuesta específica depende de cada servicio y API. La acción `aws:fis:inject-api-unavailable-error` crea errores de `ServiceUnavailable` (HTTP 503). + Excepción de rendimiento aprovisionado de API: inyecta errores internos en las solicitudes realizadas por el rol de IAM de destino. La respuesta específica depende de cada servicio y API. La acción `aws:kinesis:inject-api-provisioned-throughput-exception` crea errores de `ProvisionedThroughputExceededException` (HTTP 400). + Excepción del iterador caducado de API: inyecta errores internos en las solicitudes realizadas por el rol de IAM de destino. La respuesta específica depende de cada servicio y API. La acción `aws:kinesis:inject-api-expired-iterator-exception` crea errores de `ExpiredIteratorException` (HTTP 400). Para obtener más información, consulte las [acciones de Amazon Kinesis Data Streams](https://docs.aws.amazon.com/fis/latest/userguide/fis-actions-reference.html#aws-kinesis-actions). **Consideraciones** + Puede utilizar las acciones anteriores con las ofertas aprovisionadas y bajo demanda para Amazon Kinesis Data Streams. + El flujo se reanudará una vez finalizado el experimento, según la duración seleccionada. También puede detener un experimento en ejecución antes de que se complete. Como alternativa, puede definir una condición de parada para detener el experimento en función de las alarmas que definen el estado de la aplicación en Amazon CloudWatch Application Insights. + Es posible realizar pruebas con hasta 280 flujos. Para obtener más información sobre las regiones compatibles, consulte [puntos de enlace y cuotas de AWS Fault Injection Service](https://docs.aws.amazon.com/general/latest/gr/fis.html). # Errores de excepción de rendimiento aprovisionado Los errores de excepción de rendimiento aprovisionado superado (HTTP 400) se producen cuando la tasa de solicitudes de un flujo de Kinesis supera los límites de rendimiento de una o más particiones. Cada partición tiene límites de capacidad de lectura y escritura específicos, y si se superan, se produce esta excepción. Las situaciones que conducen a esta excepción son: aumentos repentinos en el consumo o la ingesta de datos, una capacidad de partición insuficiente para el volumen de datos que se está procesando o una distribución desigual de las claves de partición. **Recomendaciones para gestionar las excepciones** + Implemente mecanismos de retroceso exponencial y reintento. + Aumente el número de particiones para lograr un mayor rendimiento. + Asegúrese de que haya una distribución adecuada de las claves de partición. + Supervise las métricas de flujo. Además, el uso del modo de capacidad bajo demanda de Kinesis permite ajustar automáticamente las cargas de trabajo y minimizar la aparición de esta excepción. Para obtener más información, consulte [¿Qué es AWS Fault Injection Service?](https://docs.aws.amazon.com/fis/latest/userguide/what-is.html) **nota** Los problemas de distribución inadecuados están fuera de la capacidad de escalado automático del modo bajo demanda. **Cómo realizar un experimento básico** 1. Utilice métricas de referencia: registre los patrones de rendimiento normales antes de realizar la prueba. 1. Cree un experimento: utilice la acción `aws:kinesis:inject-api-provisioned-throughput-exception`. 1. Configure la intensidad: comience con una limitación del 25 % de las solicitudes. 1. Supervise las respuestas: verifique la lógica de reintento con una reducción exponencial. 1. Valide el escalado: confirme que el escalado automático desencadene la activación. 1. Compruebe las alarmas: asegúrese de que las alarmas de `CloudWatch` funcionen según lo previsto. Las aplicaciones deben implementar las estrategias, la supervisión de `WriteProvisionedThroughputExceeded` y las métricas de `ReadProvisionedThroughputExceeded`, y activar el escalado de las particiones cuando sea apropiado. **Detalles de la acción** + **Tipo de recurso**: ARN del rol de IAM + **Operaciones de destino**: `PutRecord`, `PutRecords`, `GetRecords` + ****Código de error****: `ProvisionedThroughputExceededException` (HTTP 400) + ****Descripción****: simula escenarios en los que la tasa de solicitudes supera los límites de capacidad de la partición, pone a prueba la limitación de las aplicaciones y escala las respuestas **Parameters** + **ARN del rol de IAM**: el rol que utiliza su aplicación para las operaciones de Kinesis Data Streams + **Operaciones**: operaciones de destino: `PutRecord`, `PutRecords`, `GetRecords` + **Lista de recursos**: los nombres de flujo específicos o los identificadores de particiones + **Duración**: la duración del experimento, que es de un minuto a 12 horas En la AWS FIS API, el valor es una cadena en formato ISO 8601. Por ejemplo, PT1 M representa un minuto. En la AWS FIS consola, se introduce el número de segundos, minutos u horas. + **Intensidad**: el porcentaje de solicitudes para limitar **Permisos necesarios** + `kinesis:InjectApiError` Ejemplo de plantilla de experimento El siguiente ejemplo muestra una excepción de rendimiento aprovisionada para todas las solicitudes de hasta 5 transmisiones de Kinesis Data con la etiqueta especificada. AWS FIS selecciona aleatoriamente las transmisiones a las que desea afectar. El error se elimina después de 5 minutos. ``` { "description": "Kinesis stream experiment", "targets": { "KinesisStreams-Target-1": { "resourceType": "aws:kinesis:stream", "resourceTags": { "tag-key": "tag-value" }, "selectionMode": "COUNT(5)" } }, "actions": { "kinesis": { "actionId": "aws:kinesis:stream-provisioned-throughput-exception", "description": "my-stream", "parameters": { "duration": "PT5M", "percentage": "100", "service": "kinesis" }, "targets": { "KinesisStreams": "KinesisStreams-Target-1" } } }, "stopConditions": [ { "source": "none" } ], "roleArn": "arn:aws:iam::111122223333:role/role-name", "tags": {}, "experimentOptions": { "accountTargeting": "single-account", "emptyTargetResolutionMode": "fail" } } ``` Ejemplo de permisos de roles de experimentos El siguiente permiso permite ejecutar las acciones `aws:kinesis:stream-provisioned-throughput-exception` y `aws:kinesis:stream-expired-iterator-exception` en un flujo específico que afecta al 50 % de las solicitudes. # Errores de excepción del iterador caducado Los errores de excepción del iterador caducado (HTTP 400) se producen cuando el iterador de particiones ha caducado y ya no se utiliza para recuperar registros de flujo al llamar a `GetRecords`. Esto ocurre cuando hay retrasos entre las operaciones de lectura, que se deben a tareas de procesamiento de datos que se ejecutan durante mucho tiempo, a problemas de red o al tiempo de inactividad de las aplicaciones. **nota** Un iterador de partición es válido durante 5 minutos después de su emisión. **Recomendaciones para gestionar las excepciones** + actualizar los iteradores de partición antes de que caduquen, + incorporar el manejo de errores para obtener nuevos iteradores, + utilizar Kinesis Client Library (KCL), que administra de forma automática la caducidad de los iteradores de particiones. Para obtener más información, consulte [¿Qué es AWS Fault Injection Service?](https://docs.aws.amazon.com/fis/latest/userguide/what-is.html) **Cómo realizar un experimento básico** 1. Cree una plantilla de experimento: utilice la AWS FIS consola. 1. Seleccione la acción `aws:kinesis:inject-api-expired-iterator-exception`. 1. Configure los destinos al especificar el rol de IAM y las operaciones de Kinesis Data Streams. 1. Establezca la duración de 5 a 10 minutos para la prueba inicial. 1. Añadir condiciones de parada: [condiciones de parada para AWS FIS](https://docs.aws.amazon.com/fis/latest/userguide/stop-conditions.html). 1. Ejecute el experimento para supervisar el comportamiento de la aplicación. **Detalles de la acción** + **Tipo de recurso**: ARN del rol de IAM + **Operaciones de destino**: `GetRecords` + ****Código de error****: `ExpiredIteratorException` (HTTP 400) + ****Descripción****: el iterador proporcionado supera la antigüedad máxima permitida y simula situaciones en las que el procesamiento de los registros es demasiado lento o la lógica de los puntos de control falla **Parameters** + **ARN del rol de IAM**: el rol que utiliza su aplicación para las operaciones de Kinesis Data Streams + **Operaciones**: operaciones de destino: `GetRecords` + **Lista de recursos**: los nombres de transmisión específicos o ARNs. + **Duración**: la duración del experimento. Esto se puede configurar + **Intensidad**: el porcentaje de solicitudes para limitar **Permisos necesarios** + `kinesis:InjectApiError`