As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # Criar e gerenciar fluxos de dados do Kinesis O Amazon Kinesis Data Streams ingere uma grande quantidade de dados em tempo real, armazena os dados de forma durável e os torna disponíveis para consumo. Um *registro de dados* é a unidade de dados armazenada pelo Kinesis Data Streams. Um *fluxo de dados* representa um grupo de registros de dados. Os registros de dados em um fluxo de dados são distribuídos em fragmentos. Um *fragmento* tem uma sequência de registros de dados em um fluxo. Ele serve como uma unidade base de throughput em um fluxo de dados do Kinesis. Um fragmento suporta 1 MB/s e 1.000 registros por segundo para *gravações* e 2 MB/s para *leituras nos modos* de capacidade sob demanda e provisionada. Os limites de fragmentos garantem prever a performance, facilitando o design e a operação de um fluxo de trabalho de fluxo de dados altamente confiável. Nesta seção, você aprende como definir o modo de capacidade do stream e como criar um stream usando o Console de gerenciamento da AWS ou APIs. Depois, podem ser realizadas ações adicionais no fluxo. **Topics** + [Escolha o modo certo para transmitir](how-do-i-size-a-stream.md) + [Crie um stream usando o Console de gerenciamento da AWS](how-do-i-create-a-stream.md) + [Crie um stream usando o APIs](kinesis-using-sdk-java-create-stream.md) + [Atualizar um fluxo](updating-a-stream.md) + [Listar fluxos](kinesis-using-sdk-java-list-streams.md) + [Listar fragmentos](kinesis-using-sdk-java-list-shards.md) + [Excluir um fluxo](kinesis-using-sdk-java-delete-stream.md) + [Refragmentar um fluxo](kinesis-using-sdk-java-resharding.md) + [Alterar o período de retenção de dados](kinesis-extended-retention.md) + [Marcar com tag seus recursos do Amazon Kinesis Data Streams](tagging.md) + [Gerenciar registros grandes](large-records.md) + [Realize testes de resiliência com AWS Fault Injection Service](kinesis-fis.md) # Escolha o modo certo para transmitir Os tópicos a seguir explicam como escolher o melhor modo de capacidade para sua aplicação e como alternar entre os modos, se necessário. **Topics** + [Quais são os diferentes modos no Kinesis Data Streams?](#diff-modes-kds) + [Atributos e casos de uso do modo On-demand Standard](#ondemandmode) + [Atributos e casos de uso do modo On-demand Advantage](#ondemand-advantage-mode) + [Casos de uso e atributos do modo provisionado](#provisionedmode) + [Alternar entre os modos](#switchingmodes) ## Quais são os diferentes modos no Kinesis Data Streams? Um modo determina como a capacidade de um fluxo de dados é gerenciada e como são geradas cobranças pelo uso do fluxo de dados. No Amazon Kinesis Data Streams, você pode escolher **On-demand Standard**, **On-demand Advantage** e **provisionado** como modo para os fluxos de dados. + **On-demand Standard**: os fluxos de dados no modo sob demanda não exigem planejamento de capacidade e escalam automaticamente para lidar com gigabytes de throughput de gravação e leitura por minuto. No modo sob demanda, o Kinesis Data Streams gerencia automaticamente os fragmentos para fornecer o throughput necessário. + **On-demand Advantage**: um modo de conta que permite mais recursos e fornece uma estrutura de preços mais simples para fluxos sob demanda. Nesse modo, você pode aquecer proativamente a capacidade de throughput de gravação de um stream a qualquer momento. Em termos de preços, não há mais uma cobrança fixa por fluxo, e a ingestão de dados, a recuperação de dados e o uso de retenção estendida em todos os fluxos sob demanda são pelo menos 60% menores do que os do **On-demand Standard**. + **Provisionado**: para fluxos de dados com um modo provisionado, é necessário especificar o número de fragmentos para o fluxo de dados. A capacidade total de um fluxo de dados é a soma das capacidades de seus fragmentos. É possível aumentar ou diminuir o número de fragmentos em um fluxo de dados de acordo com a necessidade. Você pode usar o Kinesis Data `PutRecords` APIs Streams e gravar `PutRecord` dados em seus streams de dados em qualquer modo. Para recuperar dados, todos os três oferecem suporte aos consumidores padrão, que usam a API `GetRecords`, e aos consumidores de Distribuição avançada (EFO), que usam a API `SubscribeToShard`. Todos os recursos do Kinesis Data Streams, incluindo modo de retenção, criptografia, métricas de monitoramento e outros, são compatíveis com os modos sob demanda e provisionado. O Kinesis Data Streams fornece alta durabilidade e disponibilidade nos modos de capacidade sob demanda e provisionada. ## Atributos e casos de uso do modo On-demand Standard Os fluxos de dados no modo sob demanda não exigem planejamento de capacidade e escalam automaticamente para lidar com gigabytes de throughput de gravação e leitura por minuto. O modo sob demanda simplifica a ingestão e o armazenamento de grandes volumes de dados com baixa latência, pois elimina o provisionamento e o gerenciamento de servidores, armazenamento ou throughput. É possível pode ingerir bilhões de registros por dia sem nenhuma sobrecarga operacional. O modo sob demanda é ideal para atender às necessidades de tráfego de aplicações altamente variável e imprevisível. Não é mais necessário provisionar essas cargas de trabalho na capacidade máxima, o que poderia resultar em custos mais altos devido à baixa utilização. O modo sob demanda é adequado para cargas de trabalho com padrões de tráfego imprevisíveis e altamente variáveis. Com o modo de capacidade sob demanda, a cobrança é feita por GB de dados gravados e lidos em seus fluxos de dados. Não é necessário especificar o throughput de leitura e gravação que espera que a aplicação execute. O Kinesis Data Streams ajusta-se instantaneamente ao crescimento e à redução das workloads. Para obter mais informações, consulte [Definição de preço do Amazon Kinesis Data Streams](https://aws.amazon.com/kinesis/data-streams/pricing/). Um fluxo de dados no modo sob demanda acomoda até o dobro do pico de throughput de gravação observado nos 30 dias anteriores. Quando o throughput de gravação do fluxo de dados atinge um novo pico, o Kinesis Data Streams escala automaticamente a capacidade do fluxo de dados. Por exemplo, se seu fluxo de dados tiver uma taxa de transferência de gravação que varia entre 10 MB/s e 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 da taxa de transferência de gravação. No entanto, poderá ocorrer controle de utilização se o tráfego aumentar para mais que o dobro do pico anterior em um período de 15 minutos. É necessário repetir as solicitações em controle de utilização. A capacidade de leitura de agregados de um fluxo de dados no modo sob demanda aumenta proporcionalmente com o throughput de gravação. Isso ajuda a garantir que as aplicações de consumo sempre tenham um throughput de leitura adequado para processar os dados recebidos em tempo real. Obtém-se pelo menos o dobro do throughput de gravação em comparação com os dados de leitura usando a API `GetRecords`. Recomenda-se o uso de uma aplicação de consumo com a API `GetRecord`, para permitir espaço suficiente quando a aplicação precisar se recuperar de tempo de inatividade. É recomendável usar o recurso de distribuição avançada do Kinesis Data Streams em cenários que exijam a adição de mais de uma aplicação de consumo. A distribuição avançada permite adicionar até 20 aplicações de consumo a um fluxo de dados usando a API `SubscribeToShard`, com um throughput dedicado para cada aplicação. ### Tratar exceções de throughput de leitura e gravação Com o modo sob demanda (da mesma forma que com o modo de capacidade provisionada), é necessário especificar uma chave de partição com cada registro para gravar dados no fluxo de dados. O Kinesis Data Streams usa suas chaves de partição para distribuir dados entre fragmentos. O Kinesis Data Streams monitora o tráfego de cada fragmento. Quando o tráfego de entrada excede 500 KB/s por fragmento, ele divide o fragmento em 15 minutos. Os valores da chave de hash do fragmento pai são redistribuídos uniformemente entre os fragmentos filho. Se o tráfego de entrada exceder o dobro do pico anterior, poderão ocorrer exceções de leitura ou gravação por cerca de 15 minutos, mesmo quando os dados forem distribuídos uniformemente entre os fragmentos. Recomenda-se repetir todas essas solicitações para que todos os registros sejam armazenados adequadamente no Kinesis Data Streams. As exceções de leitura e gravação podem ocorrer ao usar uma chave de partição que causa uma distribuição desigual de dados, e os registros atribuídos a um fragmento específico excedem seus limites. Com o modo sob demanda, o fluxo de dados se adapta automaticamente para lidar com padrões desiguais de distribuição de dados, a menos que uma única chave de partição exceda os limites de 1 MB/s taxa de transferência e 1.000 registros por segundo de um fragmento. No modo sob demanda, o Kinesis Data Streams divide os fragmentos uniformemente quando detecta um aumento no tráfego. No entanto, ele não detecta nem isola as chaves de hash que estão direcionando uma parte maior do tráfego de entrada para um fragmento específico. Ao usar chaves de partição altamente desiguais, as exceções de gravação poderão continuar ocorrendo. Para esses casos de uso, é recomendável usar o modo de capacidade provisionada que oferece suporte a divisões granulares de fragmentos. ## Atributos e casos de uso do modo On-demand Advantage On-demand Advantage é uma configuração de conta que permite mais recursos e fornece uma estrutura de preços diferentes para todos os fluxos sob demanda na região. Nesse modo, os fluxos sob demanda retêm sua funcionalidade e continuam a escalar automaticamente a capacidade com base no uso real dos dados. Se você quiser aquecer proativamente a capacidade de throughput de gravação de um fluxo, você pode configurar o throughput aquecido. Por exemplo, se seu fluxo de dados tiver uma taxa de transferência de gravação entre 10 MB/s e 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 garantir que a capacidade esteja disponível quando a taxa de transferência de dados chegar. O uso de um throughput aquecido não acarreta custos adicionais. Outro benefício do modo On-demand Advantage é que os fluxos sob demanda fazem a transição para uma estrutura de preços mais simples. Com o modo habilitado, a conta não verá mais cobranças fixas por fluxo e você lidará apenas com a ingestão de dados, a recuperação de dados e as cobranças opcionais de retenção estendida. Cada dimensão de preço também tem um desconto significativo em comparação com a dimensão correspondente no On-demand Standard. Para obter mais informações, consulte [Definição de preço do Amazon Kinesis Data Streams](https://aws.amazon.com/kinesis/data-streams/pricing/). As recuperações de dados com distribuição avançada também não têm um preço superior em comparação com as recuperações de dados padrão nesse modo. Além disso, com o modo On-demand Advantage, você pode registrar até 50 consumidores por stream para usar o fan-out aprimorado. A ativação do On-Demand Advantage compromete a conta com pelo menos 25% MiB/s of data ingest and 25MiB/s da recuperação de dados em todos os fluxos sob demanda. Para contas que atendem ao requisito mínimo de uso, o console do Kinesis Data Streams verifica se os padrões de uso da sua conta são adequados para usar o **modo On-demand Advantage**. Se o uso de dados da sua conta estiver abaixo do exigido, você pagará a diferença como um déficit, mas ainda assim terá a mesma taxa de desconto. A ativação do On-demand Advantage também tem um período mínimo de 24 horas antes que você possa desativar o modo. No geral, o On-demand Advantage é a melhor opção para fluxos com o Kinesis Data Streams se você tiver um uso consistente de throughput próximo ou acima do compromisso mínimo, se precisar de muitos consumidores distribuídos ou se operar com centenas de fluxos de dados. ## Casos de uso e atributos do modo provisionado Com o modo provisionado, depois de criar o fluxo de dados, você pode aumentar ou reduzir dinamicamente sua capacidade de fragmentos usando a ou a Console de gerenciamento da AWS API. [UpdateShardCount](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_UpdateShardCount.html) É possível fazer atualizações enquanto uma aplicação de produção ou de consumo do Kinesis Data Streams grava ou lê dados do fluxo. O modo provisionado é adequado para tráfego com requisitos de capacidade fáceis de prever. É possível usar o modo provisionado quando quiser ter um controle refinado da distribuição dos entre os fragmentos. No modo provisionado, é necessário especificar o número de fragmentos para o fluxo de dados. Para determinar o tamanho inicial de um fluxo de dados, os seguintes valores de entrada são necessários: + O tamanho médio do registro de dados gravado no fluxo em kilobytes (KB), arredondado para o 1 KB mais próximo (`average_data_size_in_KB`). + O número de registros de dados gravados e lidos no fluxo por segundo (`records_per_second`). + O número de consumidores, que são as aplicações do Kinesis Data Streams que consomem dados de forma simultânea e independente do fluxo (`number_of_consumers`). + A largura de banda de gravação de entrada em KB (`incoming_write_bandwidth_in_KB`), que é igual a `average_data_size_in_KB` multiplicado por `records_per_second`. + A largura de banda de leitura de saída em KB (`outgoing_read_bandwidth_in_KB`), que é igual a `incoming_write_bandwidth_in_KB` multiplicado por `number_of_consumers`. É possível calcular o número dos fragmentos (`number_of_shards`) necessários para o fluxo usando os valores de entrada na seguinte fórmula: ``` number_of_shards = ceiling(max(incoming_write_bandwidth_in_KiB/1024, outgoing_read_bandwidth_in_KiB/2048)) ``` Ainda será possível ocorrer exceções de throughput de leitura e gravação no modo provisionado se o fluxo de dados não for configurado para lidar com o throughput máximo. Nesse caso, será preciso escalar manualmente o fluxo para acomodar o tráfego de dados. As exceções de leitura e gravação também podem ocorrer ao usar uma chave de partição que causa uma distribuição desigual de dados, e os registros atribuídos a um fragmento excedem seus limites. Para resolver esse problema no modo provisionado, identifique esses fragmentos e divida-os manualmente para acomodar melhor o tráfego. Para obter mais informações, consulte [Resharding a Stream](https://docs.aws.amazon.com/streams/latest/dev/kinesis-using-sdk-java-resharding.html). ## Alternar entre os modos Para cada fluxo de dados em seu Conta da AWS, você pode alternar entre os modos sob demanda e provisionado duas vezes em 24 horas. Alternar entre os modos não causa nenhuma interrupção nas aplicações que usam esse fluxo de dados. É possível continuar gravando e lendo o fluxo de dados. Durante a alternância entre os modos, de sob demanda para provisionado ou vice-versa, o status do fluxo é definido como *Atualizando*. É necessário esperar que o status do fluxo de dados passe a *Ativo* antes de tentar modificar suas propriedades novamente. Ao mudar do modo de capacidade provisionada para o modo de capacidade sob demanda, o fluxo de dados retém inicialmente a quantidade de fragmentos que tinha antes da transição. A partir desse momento, o Kinesis Data Streams monitora o tráfego de dados e escala a contagem de fragmentos do fluxo de dados sob demanda de acordo com o throughput de gravação. Ao alternar do modo sob demanda para o provisionado, o fluxo de dados também retém inicialmente a quantidade de fragmentos que tinha antes da transição. Mas, a partir desse momento, você passa a ser responsável por monitorar e ajustar a contagem de fragmentos do fluxo de dados para acomodar o throughput de gravação da forma apropriada. Você pode alternar do modo **On-demand Standard** para o modo **On-demand Advantage** ativando uma configuração na conta. Quando ativada, a conta se compromete com pelo menos 25% MiB/s of data ingest and 25MiB/s do uso da recuperação de dados em todos os fluxos sob demanda na região. Depois de ativado, é necessário esperar pelo menos 24 horas antes de poder desativar o **On-demand Advantage**, mas você pode solicitar a alteração a qualquer momento. Se quiser mudar de **On-demand Advantage** para **On-demand Standard**, você deve primeiro remover qualquer throughput aquecido configurado com fluxos sob demanda. # Crie um stream usando o Console de gerenciamento da AWS É possível criar um fluxo usando o console do Kinesis Data Streams, a API do Kinesis Data Streams ou a AWS Command Line Interface (AWS CLI). **Para criar um fluxo de dados usando o console** 1. [Faça login no Console de gerenciamento da AWS e abra o console do Kinesis em https://console.aws.amazon.com /kinesis.](https://console.aws.amazon.com/kinesis) 1. Na barra de navegação, expanda o seletor de região e escolha uma região. 1. Selecione **Criar fluxo de dados**. 1. Na página **Criar fluxo do Kinesis**, insira um nome para o fluxo de dados e escolha o modo de capacidade **Sob demanda** ou **Provisionado**. O modo **Sob demanda** está selecionado por padrão. Para obter mais informações, consulte [Escolha o modo certo para transmitir](how-do-i-size-a-stream.md). No modo **sob demanda**, pode-se, em seguida, escolher **Criar fluxo do Kinesis** para criar o fluxo de dados. No modo **provisionado**, é necessário especificar o número de fragmentos necessários e, em seguida, escolher **Criar fluxo do Kinesis**. Na página **Fluxos do Kinesis**, o **Status** do fluxo é **Criando** enquanto o fluxo está sendo criado. Quando o fluxo estiver pronto para ser usado, o **Status** mudará para **Ativo**. 1. Escolha o nome do fluxo. A página **Detalhes do fluxo** exibe um resumo da configuração do fluxo com informações de monitoramento. **Para criar um fluxo usando a API do Kinesis Data Streams** + Para obter informações sobre a criação de um fluxo usando a API do Kinesis Data Streams, consulte [Crie um stream usando o APIs](kinesis-using-sdk-java-create-stream.md). **Para criar um stream usando o AWS CLI** + Para obter informações sobre como criar um stream usando o AWS CLI, consulte o comando [create-stream](https://docs.aws.amazon.com/cli/latest/reference/kinesis/create-stream.html). # Crie um stream usando o APIs Use as etapas a seguir para criar o fluxo de dados do Kinesis. ## Criar o cliente do Kinesis Data Streams Para trabalhar com fluxos de dados do Kinesis, é necessário criar um objeto de cliente. O seguinte código Java cria uma instância de um criador de cliente e a usa para definir a região, as credenciais e a configuração do cliente. Em seguida, ele cria um objeto do cliente. ``` AmazonKinesisClientBuilder clientBuilder = AmazonKinesisClientBuilder.standard(); clientBuilder.setRegion(regionName); clientBuilder.setCredentials(credentialsProvider); clientBuilder.setClientConfiguration(config); AmazonKinesis client = clientBuilder.build(); ``` Para obter mais informações, consulte [Kinesis Data Streams Regions and Endpoints](https://docs.aws.amazon.com/general/latest/gr/rande.html#ak_region) na *Referência geral da AWS*. ## Criar o fluxo Depois de criar o cliente do Kinesis Data Streams, é possível criar um fluxo no console ou de forma programática. Para criar um fluxo de forma programática, instancie um objeto `CreateStreamRequest`, depois especifique um nome para o fluxo. Se desejar usar o modo provisionado, especifique o número de fragmentos para o uso do fluxo de dados. + **Sob demanda**: ``` CreateStreamRequest createStreamRequest = new CreateStreamRequest(); createStreamRequest.setStreamName( myStreamName ); ``` + **Provisionado**: ``` CreateStreamRequest createStreamRequest = new CreateStreamRequest(); createStreamRequest.setStreamName( myStreamName ); createStreamRequest.setShardCount( myStreamSize ); ``` O nome do fluxo identifica o fluxo. O nome tem como escopo a AWS conta usada pelo aplicativo. Ele também é delimitado por região. Ou seja, dois fluxos em duas AWS contas diferentes podem ter o mesmo nome, e dois fluxos na mesma AWS conta, mas em duas regiões diferentes, podem ter o mesmo nome, mas não dois fluxos na mesma conta e na mesma região. O throughput do fluxo depende do número de fragmentos. Para obter um throughput mais provisionado, mais fragmentos são necessários. Mais fragmentos também aumentam o custo AWS cobrado pela transmissão. Para obter mais informações sobre como calcular um número apropriado de fragmentos para o aplicativo, consulte [Escolha o modo certo para transmitir](how-do-i-size-a-stream.md). Depois de configurar o objeto `createStreamRequest`, crie um fluxo chamando o método `createStream` para o cliente. Após chamar `createStream`, aguarde o fluxo alcançar o estado `ACTIVE` antes de executar qualquer operação nele. Para verificar o estado do fluxo, chame o método `describeStream`. Se o fluxo não existir, `describeStream` lançará uma exceção, portanto, coloque a chamada a `describeStream` em um bloco `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" ); } ``` # Atualizar um fluxo É possível atualizar os detalhes de um fluxo usando o console do Kinesis Data Streams, a API do Kinesis Data Streams ou a AWS CLI. **nota** Pode-se ativar a criptografia no lado do servidor para streams existentes ou para os recém-criados. ## Usar o console **Para atualizar um fluxo de dados usando o console** 1. Abra o console do Amazon Kinesis em. [https://console.aws.amazon.com/kinesis/](https://console.aws.amazon.com/kinesis/) 1. Na barra de navegação, expanda o seletor de região e escolha uma região. 1. Escolha o nome do fluxo na lista. A página **Detalhes do fluxo** exibe um resumo das informações de configuração e monitoramento do fluxo. 1. Para alternar entre os modos de capacidade sob demanda e provisionada para um fluxo de dados, escolha **Editar modo de capacidade** na guia **Configuração**. Para obter mais informações, consulte [Escolha o modo certo para transmitir](how-do-i-size-a-stream.md). **Importante** Para cada fluxo de dados em sua AWS conta, você pode alternar entre os modos sob demanda e provisionado duas vezes em 24 horas. 1. Para editar o número de fragmentos de um fluxo de dados no modo provisionado, escolha **Editar fragmentos provisionados** na guia **Configuração** e, em seguida, insira uma nova contagem de fragmentos. 1. Para ativar a criptografia de registros de dados no lado do servidor, selecione **Editar** na seção **Criptografia no lado do servidor**. Escolha uma chave do KMS para usar como a chave mestra de criptografia ou use a chave mestra padrão, **aws/kinesis**, gerenciada pelo Kinesis. Se você habilitar a criptografia para um stream e usar sua própria chave AWS KMS mestra, certifique-se de que seus aplicativos de produtor e consumidor tenham acesso à chave AWS KMS mestra que você usou. Para atribuir permissões a uma aplicação para acessar uma chave do AWS KMS gerada pelo usuário, consulte [Permissões para usar as chaves do KMS geradas pelo usuário](permissions-user-key-KMS.md). 1. Para editar o período de retenção de dados, selecione **Editar** na seção **Período de retenção de dados** e insira um novo período de retenção de dados. 1. Se métricas personalizadas estiverem habilitadas na conta, selecione **Editar** na seção **Métricas em nível de fragmento** e, em seguida, especifique as métricas de seu fluxo. Para obter mais informações, consulte [Monitore o serviço Amazon Kinesis Data Streams com a Amazon CloudWatch](monitoring-with-cloudwatch.md). ## Usar a API Para atualizar os detalhes do fluxo usando a API, consulte os seguintes 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) ## Use o AWS CLI Para obter informações sobre como atualizar um stream usando o AWS CLI, consulte a referência da [Kinesis CLI](https://docs.aws.amazon.com/cli/latest/reference/kinesis/index.html). # Listar fluxos Os streams têm como escopo a AWS conta associada às AWS credenciais usadas para instanciar o cliente Kinesis Data Streams e também a região especificada para o cliente. Uma conta da AWS pode ter vários fluxos ativos ao mesmo tempo. É possível listar os fluxos no console do Kinesis Data Streams ou de forma programática. O código nesta seção mostra como listar todos os streams da sua AWS conta. ``` ListStreamsRequest listStreamsRequest = new ListStreamsRequest(); listStreamsRequest.setLimit(20); ListStreamsResult listStreamsResult = client.listStreams(listStreamsRequest); List streamNames = listStreamsResult.getStreamNames(); ``` Este exemplo de código primeiro cria uma nova instância de `ListStreamsRequest` e chama seu método `setLimit` para especificar que um máximo de 20 fluxos devem ser retornados para cada chamada a `listStreams`. Se um valor não for especificado para `setLimit`, o Kinesis Data Streams retornará um número de fluxos menor ou igual ao número na conta. Em seguida, o código passa `listStreamsRequest` ao método `listStreams` do cliente. O valor de retorno `listStreams` é armazenado em um objeto `ListStreamsResult`. O código chama o método `getStreamNames` para esse objeto e armazena os nomes de fluxo retornados na lista `streamNames`. Observe que o Kinesis Data Streams pode retornar menos fluxos do que o limite especificado, mesmo quando houver um número maior de fluxos na conta e na região. Para garantir a recuperação de todos os fluxos, use o método `getHasMoreStreams` como descrito no próximo exemplo de código. ``` while (listStreamsResult.getHasMoreStreams()) { if (streamNames.size() > 0) { listStreamsRequest.setExclusiveStartStreamName(streamNames.get(streamNames.size() - 1)); } listStreamsResult = client.listStreams(listStreamsRequest); streamNames.addAll(listStreamsResult.getStreamNames()); } ``` Esse código chama o método `getHasMoreStreams` para `listStreamsRequest` a fim de verificar se há fluxos adicionais disponíveis além dos que foram retornados na chamada inicial a `listStreams`. Se houver, o código chamará o método `setExclusiveStartStreamName` com o nome do último fluxo que foi retornado na chamada anterior a `listStreams`. O método `setExclusiveStartStreamName` faz com que a próxima chamada a `listStreams` comece depois desse fluxo. Em seguida, o grupo de nomes de fluxo retornados pela chamada é adicionado à lista `streamNames`. Esse processo continua até que todos os nomes de fluxo tenham sido coletados na lista. Os streams retornados por `listStreams` podem estar em um dos seguintes estados: + `CREATING` + `ACTIVE` + `UPDATING` + `DELETING` É possível verificar o estado de um fluxo usando o método `describeStream`, como mostrado na seção anterior, [Crie um stream usando o APIs](kinesis-using-sdk-java-create-stream.md). # Listar fragmentos Um fluxo de dados pode ter um ou mais fragmentos. O método recomendado para listar ou recuperar os fragmentos de um stream de dados é usar a [ListShards](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_ListShards.html)API. O exemplo a seguir mostra como obter uma lista de fragmentos em um fluxo de dados. Para obter uma descrição completa da operação principal usada neste exemplo e de todos os parâmetros que você pode definir para a operação, 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 executar o exemplo de código anterior, é possível usar um arquivo POM, como o seguinte. ``` 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 ``` Com a `ListShards` API, você pode usar o [ShardFilter](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_ShardFilter.html)parâmetro para filtrar a resposta da API. Só é possível especificar um filtro de cada vez. Se você usar o `ShardFilter` parâmetro ao invocar a ListShards API, essa `Type` é a propriedade necessária e deve ser especificada. Se os tipos `AT_TRIM_HORIZON`, `FROM_TRIM_HORIZON` ou `AT_LATEST` forem especificados, não há necessidade de especificar as propriedades opcionais `ShardId` e `Timestamp`. Se o tipo `AFTER_SHARD_ID` for especificado, também é necessário fornecer o valor para a propriedade opcional `ShardId`. A `ShardId` propriedade é idêntica em termos de funcionalidade ao `ExclusiveStartShardId` parâmetro da ListShards API. Quando a propriedade `ShardId` é especificada, a resposta inclui os fragmentos a partir daquele cuja ID segue imediatamente a `ShardId` fornecida. Se os tipos `AT_TIMESTAMP` ou `FROM_TIMESTAMP_ID` forem especificados, também é necessário fornecer o valor para a propriedade opcional `Timestamp`. Se o tipo `AT_TIMESTAMP` for especificado, todos os fragmentos abertos no timestamp fornecido serão retornados. Se o tipo `FROM_TIMESTAMP` for especificado, todos os fragmentos do timestamp fornecido até a extremidade serão retornados. **Importante** `DescribeStreamSummary`e `ListShard` APIs forneça uma forma mais escalável de recuperar informações sobre seus fluxos de dados. Mais especificamente, as cotas da DescribeStream API podem causar limitação. Para obter mais informações, consulte [Cotas e limites](service-sizes-and-limits.md). Observe também que as `DescribeStream` cotas são compartilhadas em todos os aplicativos que interagem com todos os fluxos de dados em sua AWS conta. As cotas da ListShards API, por outro lado, são específicas para um único fluxo de dados. Portanto, você não apenas obtém um TPS mais alto com a ListShards API, mas a ação é melhor dimensionada à medida que você cria mais fluxos de dados. Recomendamos que você migre todos os produtores e consumidores que chamam a DescribeStream API para, em vez disso, invocar o DescribeStreamSummary e o. ListShard APIs Para identificar esses produtores e consumidores, recomendamos usar o Athena para analisar CloudTrail registros, pois os agentes de usuário para KPL e KCL são capturados nas chamadas de 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 ``` Também recomendamos que as integrações do AWS Lambda e do Amazon Firehose com o Kinesis Data Streams que invocam a API sejam reconfiguradas para que, em vez disso, `DescribeStream` as integrações invoquem e. `DescribeStreamSummary` `ListShards` Especificamente, para o AWS Lambda, você deve atualizar o mapeamento da fonte do evento. No Amazon Firehose, as permissões correspondentes do IAM precisam ser atualizadas para que incluam a permissão `ListShards` do IAM. # Excluir um fluxo É possível excluir um fluxo no console do Kinesis Data Streams ou de forma programática. Para excluir um fluxo de maneira programática, use `DeleteStreamRequest`, conforme mostrado no código a seguir. ``` DeleteStreamRequest deleteStreamRequest = new DeleteStreamRequest(); deleteStreamRequest.setStreamName(myStreamName); client.deleteStream(deleteStreamRequest); ``` Desative todos os aplicativos que estejam operando no fluxo antes de excluí-lo. Se um aplicativo tentar operar em um fluxo excluído, ele receberá exceções `ResourceNotFound`. Além disso, se um novo fluxo for criado com o mesmo nome do fluxo anterior e os aplicativos que operavam nele ainda estiverem em execução, esses aplicativos poderão tentar interagir com o fluxo novo como se fosse o anterior, com resultados imprevisíveis. # Refragmentar um fluxo **Importante** Você pode refragmentar seu stream usando a [UpdateShardCount](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_UpdateShardCount.html)API. Caso contrário, é possível continuar executando divisões e mesclagens, como explicado aqui. O Amazon Kinesis Data Streams oferece suporte à *refragmentação*, o que permite ajustar o número de fragmentos no fluxo para se adaptar a alterações na taxa de dados no fluxo. A refragmentação é considerada uma operação avançada. Se esta é a primeira experiência com o Kinesis Data Streams, volte a este tópico depois de se familiarizar com todos os outros aspectos do serviço. Há dois tipos de operações de refragmentação: divisão de fragmento e mesclagem de fragmento. Na divisão de fragmento, um único fragmento é dividido em dois. Na mesclagem de fragmento, dois fragmentos são combinados em um. A refragmentação sempre ocorre em *pares*, ou seja, não é possível dividir em mais de dois fragmentos em uma única operação, e não é possível mesclar mais de dois fragmentos em uma única operação. O fragmento (ou o par de fragmentos) que é objeto da operação de refragmentação é chamado de fragmento *pai*. O fragmento (ou o par de fragmentos) resultante da operação de refragmentação é chamado de fragmento *filho*. A divisão aumenta o número de fragmentos no fluxo e, portanto, aumenta a capacidade de dados do fluxo. Como a cobrança é feita por fragmento, a divisão aumenta o custo do fluxo. Comparativamente, a mesclagem reduz o número de fragmentos no fluxo e, portanto, diminui a capacidade de dados e o custo do fluxo. A refragmentação costuma ser executada por um aplicativo administrativo, que é diferente dos aplicativos de produtor (put) e dos aplicativos de consumidor (get). Esse aplicativo administrativo monitora o desempenho geral do stream com base nas métricas fornecidas pela Amazon CloudWatch ou com base nas métricas coletadas dos produtores e consumidores. O aplicativo administrativo também precisa de um conjunto mais amplo de permissões do IAM do que os consumidores ou produtores, porque os consumidores e produtores geralmente não precisam acessar o APIs usado para refragmentação. Para obter mais informações sobre as permissões do IAM para o Kinesis Data Streams, consulte [Controlar o acesso aos recursos do Amazon Kinesis Data Streams usando o IAM](controlling-access.md). Para obter mais informações sobre refragmentação, consulte [How do I change the number of open shards in Kinesis Data Streams?](https://aws.amazon.com/premiumsupport/knowledge-center/kinesis-data-streams-open-shards/) **Topics** + [Decidir uma estratégia para refragmentar](kinesis-using-sdk-java-resharding-strategies.md) + [Dividir um fragmento](kinesis-using-sdk-java-resharding-split.md) + [Mesclar dois fragmentos](kinesis-using-sdk-java-resharding-merge.md) + [Concluir a ação de refragmentação](kinesis-using-sdk-java-after-resharding.md) # Decidir uma estratégia para refragmentar A finalidade da refragmentação no Amazon Kinesis Data Streams é permitir que o fluxo se adapte a alterações na taxa do fluxo de dados. Fragmentos são divididos para aumentar a capacidade (e o custo) do fluxo. Fragmentos são mesclados para reduzir o custo (e a capacidade) do fluxo. Uma abordagem de refragmentação pode ser dividir cada fragmento do fluxo, o que dobraria sua capacidade. No entanto, isso pode fornecer mais capacidade adicional do que o realmente necessário e, portanto, gerar um custo desnecessário. Também é possível usar métricas para identificar os fragmentos *quentes* ou *frios*, ou seja, os fragmentos que estão recebendo muito mais ou muito menos dados do que o esperado. Em seguida, é possível seletivamente dividir os fragmentos quentes para aumentar a capacidade das chaves de hash que almejam esses fragmentos. Comparativamente, pode-se mesclar os fragmentos frios para dar uma melhor serventia à capacidade não usada. Você pode obter alguns dados de desempenho do seu stream a partir das CloudWatch métricas da Amazon que o Kinesis Data Streams publica. No entanto, também é possível coletar algumas métricas dos seus fluxos. Uma abordagem é registrar em log os valores de chave de hash gerados pelas chaves de partição dos seus registros de dados. Lembre-se de que a chave de partição é especificada no momento em que o registro é adicoinado ao fluxo. ``` putRecordRequest.setPartitionKey( String.format( "myPartitionKey" ) ); ``` O Kinesis Data [MD5](http://en.wikipedia.org/wiki/MD5)Streams usa para calcular a chave de hash a partir da chave de partição. Como você especifica a chave de partição para o registro, você pode MD5 usá-la para calcular o valor da chave de hash desse registro e registrá-lo. Você também pode registrar os IDs fragmentos aos quais seus registros de dados estão atribuídos. O ID do fragmento é obtido usando-se o método `getShardId` do objeto `putRecordResults` retornado pelo método `putRecords` e o objeto `putRecordResult` retornado pelo método `putRecord`. ``` String shardId = putRecordResult.getShardId(); ``` Com os valores do fragmento IDs e da chave de hash, você pode determinar quais fragmentos e chaves de hash estão recebendo mais ou menos tráfego. Em seguida, é possível usar a refragmentação para fornecer mais ou menos capacidade, conforme apropriado para essas chaves. # Dividir um fragmento Para dividir um fragmento no Amazon Kinesis Data Streams, é necessário especificar como os valores de chave de hash dos fragmentos pai devem ser redistribuídos para os fragmentos filho. Ao adicionar um registro de dados a um fluxo, ele é atribuído a um fragmento com base em um valor de chave de hash. O valor da chave de hash é o [MD5](http://en.wikipedia.org/wiki/MD5)hash da chave de partição que você especifica para o registro de dados no momento em que adiciona o registro de dados ao fluxo. Os registros de dados que têm a mesma chave de partição também têm o mesmo valor de chave de hash. Os valores possíveis de chave de hash de um determinado fragmento constituem um conjunto de números inteiros contíguos, não negativos e ordenados. Esse intervalo de possíveis valores de chave de hash é determinado pelo seguinte: ``` shard.getHashKeyRange().getStartingHashKey(); shard.getHashKeyRange().getEndingHashKey(); ``` Ao dividir o fragmento, um valor é especificado neste intervalo. Esse valor de chave de hash e todos os valores de chave de hash maiores são distribuídos para um dos fragmentos filhos. Todos os valores de chave de hash menores são distribuídos para os outros fragmentos filhos. O seguinte código demonstra uma operação de divisão de fragmento que redistribui as chaves de hash uniformemente entre cada um dos fragmentos filhos, basicamente, dividindo o fragmento pai no meio. Essa é apenas uma das maneiras possíveis de dividir o fragmento pai. É possível, por exemplo, dividir o fragmento de maneira que o terço inferior das chaves do pai vá para um fragmento filho e os dois terços superiores das chaves vão para o outro fragmento filho. No entanto, para muitos aplicativos, dividir os fragmentos no meio é uma abordagem eficiente. O código pressupõe que `myStreamName` contém o nome do seu fluxo e a variável de objeto `shard` contém o fragmento a dividir. Comece instanciando um novo objeto `splitShardRequest` e definindo o nome do fluxo e o ID do fragmento. ``` SplitShardRequest splitShardRequest = new SplitShardRequest(); splitShardRequest.setStreamName(myStreamName); splitShardRequest.setShardToSplit(shard.getShardId()); ``` Determine o valor da chave de hash que é meio caminho entre o maior valor e o menor valor no fragmento. Trata-se do valor de chave de hash inicial para o fragmento filho que conterá a metade superior das chaves de hash do fragmento pai. Especifique esse valor no método `setNewStartingHashKey`. Basta especificar esse valor. O Kinesis Data Streams distribui automaticamente as chaves de hash abaixo desse valor para os outros fragmentos filho criados pela divisão. A última etapa é chamar o método `splitShard` no cliente do 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); ``` A primeira etapa após este procedimento é mostrada em [Aguardar um fluxo ficar ativo novamente](kinesis-using-sdk-java-after-resharding.md#kinesis-using-sdk-java-resharding-wait-until-active). # Mesclar dois fragmentos Uma operação de mesclagem de fragmentos usa dois fragmentos especificados e combina-os em um único fragmento. Após a mesclagem, o único fragmento filho recebe dados para todos os valores de chave de hash cobertos pelos dois fragmentos pais. **Adjacência de fragmento** Para mesclar dois fragmentos, eles precisam estar *adjacentes*. Dois fragmentos são considerados adjacentes quando a união dos intervalos de chave de hash dos dois fragmentos forma um conjunto contíguo sem lacunas. Por exemplo, suponha que haja dois fragmentos, um com o intervalo de chaves de hash 276...381 e o outro com o intervalo de chaves de hash 382...454. É possível mesclar esses dois fragmentos em um só, que teria um intervalo de chaves de hash 276...454. Para usar outro exemplo, suponha que haja dois fragmentos, um com um intervalo de chaves de hash 276...381 e o outro com um intervalo de chaves de hash 455...560. Não seria possível mesclar esses dois fragmentos porque haveria um ou mais fragmentos entre eles que estariam no intervalo 382...454. O conjunto de todos os `OPEN` fragmentos em um fluxo, como um grupo, sempre abrange toda a faixa de valores da chave de hash. MD5 Para obter mais informações sobre esses estados de fragmento (como `CLOSED`), consulte [Considerar o roteamento de dados, a persistência de dados e o estado do fragmento após uma refragmentação](kinesis-using-sdk-java-after-resharding.md#kinesis-using-sdk-java-resharding-data-routing). Para identificar os fragmentos candidatos para mesclagem, deve-se filtrar todos os fragmentos que estão no estado `CLOSED`. Os fragmentos `OPEN` (ou seja, não `CLOSED`) têm um número de sequência final `null`. É possível testar o número sequencial de término de um fragmento usando: ``` if( null == shard.getSequenceNumberRange().getEndingSequenceNumber() ) { // Shard is OPEN, so it is a possible candidate to be merged. } ``` Após filtrar os fragmentos fechados, classifique os fragmentos restantes pelo valor de chave de hash mais alto aceito por cada fragmento. É possível recuperar esse valor usando: ``` shard.getHashKeyRange().getEndingHashKey(); ``` Se dois fragmentos são adjacentes nessa lista filtrada e classificada, eles podem ser mesclados. **Código da operação de mesclagem** O código a seguir mescla dois fragmentos. O código pressupõe que `myStreamName` contém o nome do seu fluxo e as variáveis de objeto `shard1` e `shard2` contém os dois fragmentos adjacentes a mesclar. Para a operação de mesclagem, comece instanciando um novo objeto `mergeShardsRequest`. Especifique o nome do fluxo com o método `setStreamName`. Em seguida, especifique os dois fragmentos a mesclar usando os métodos `setShardToMerge` e `setAdjacentShardToMerge`. Por fim, chame o método `mergeShards` no cliente do Kinesis Data Streams para executar a operação. ``` MergeShardsRequest mergeShardsRequest = new MergeShardsRequest(); mergeShardsRequest.setStreamName(myStreamName); mergeShardsRequest.setShardToMerge(shard1.getShardId()); mergeShardsRequest.setAdjacentShardToMerge(shard2.getShardId()); client.mergeShards(mergeShardsRequest); ``` A primeira etapa após este procedimento é mostrada em [Aguardar um fluxo ficar ativo novamente](kinesis-using-sdk-java-after-resharding.md#kinesis-using-sdk-java-resharding-wait-until-active). # Concluir a ação de refragmentação Após qualquer tipo de procedimento de refragmentação no Amazon Kinesis Data Streams e antes de retomar o processamento normal de registros, é necessário realizar outros procedimentos e fazer algumas considerações. As seções a seguir descrevem esses itens. **Topics** + [Aguardar um fluxo ficar ativo novamente](#kinesis-using-sdk-java-resharding-wait-until-active) + [Considerar o roteamento de dados, a persistência de dados e o estado do fragmento após uma refragmentação](#kinesis-using-sdk-java-resharding-data-routing) ## Aguardar um fluxo ficar ativo novamente Depois de chamar uma operação de refragmentação, `splitShard` ou `mergeShards`, deve-se esperar o fluxo ficar ativo novamente. O código a ser usado é o mesmo de quando espera-se que um fluxo se torne ativo após a [criação de um fluxo](kinesis-using-sdk-java-create-stream.md). Esse código é o seguinte: ``` 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" ); } ``` ## Considerar o roteamento de dados, a persistência de dados e o estado do fragmento após uma refragmentação O Kinesis Data Streams é um serviço de fluxo de dados em tempo real. Seus aplicativos devem pressupor que os dados fluem continuamente pelos fragmentos do fluxo. Ao refragmentar, os registros de dados que estavam fluindo para os fragmentos pais são re-roteados para fluírem para os fragmentos filhos com base nos valores de chave de hash para as quais são mapeadas as chaves de partição de registro de dados. No entanto, os registros de dados que estavam nos fragmentos pais antes da refragmentação permanecem nesses fragmentos. Os fragmentos principais não desaparecem quando a refragmentação ocorre. Eles persistem com os dados que continham antes da refragmentação. Os registros de dados nos fragmentos pai podem ser acessados usando as operações [`getShardIterator` e `getRecords`](developing-consumers-with-sdk.md#kinesis-using-sdk-java-get-data) na API do Kinesis Data Streams ou por meio da Kinesis Client Library. **nota** Os registros de dados podem ser acessados a partir do momento em que são adicionados ao fluxo até o período de retenção atual. Isso é verdadeiro independentemente de quaisquer alterações aos fragmentos no fluxo durante esse período. Para obter mais informações sobre o período de retenção de um stream, consulte [Alterar o período de retenção de dados](kinesis-extended-retention.md). No processo de refragmentação, um fragmento pai passa de um estado `OPEN` para um estado `CLOSED` para um estado `EXPIRED`. + **OPEN**: antes de uma operação de refragmentação, um fragmento pai está no estado `OPEN`, o que significa que os registros de dados podem ser adicionados ao fragmento e recuperados do fragmento. + **CLOSED**: após uma operação de refragmentação, o fragmento pai passa para um estado `CLOSED`. Isso significa que os registros de dados não são mais adicionados ao fragmento. Os registros de dados que foram adicionados a esse fragmento agora são adicionados a um fragmento filho. No entanto, os registros de dados ainda podem ser recuperados do fragmento por tempo limitado. + **EXPIRED**: após a expiração do período de retenção do fluxo, todos os registros de dados no fragmento pai expiraram e não estão mais acessíveis. Neste momento, o próprio fragmento muda para um estado `EXPIRED`. As chamadas a `getStreamDescription().getShards` para enumerar os fragmentos no fluxo não incluem os fragmentos `EXPIRED` na lista de fragmentos retornados. Para obter mais informações sobre o período de retenção de um stream, consulte [Alterar o período de retenção de dados](kinesis-extended-retention.md). Depois da refragmentação, com o fluxo novamente em um estado `ACTIVE`, é possível iniciar imediatamente a leitura de dados dos fragmentos filhos. No entanto, os fragmentos principais que permanecem após a refragmentação ainda podem conter dados que ainda não foram lidos e foram adicionados ao fluxo antes da refragmentação. Ao ler dados de fragmentos filhos antes ler todos os dados dos fragmentos pais, pode-se ler dados de uma determinada chave de hash fora da ordem determinada pelos números sequenciais dos registros de dados. Portanto, pressupondo que a ordem dos dados é importante, é necessário, após uma refragmentação, sempre continuar lendo dados dos fragmentos pais até esgotá-los. Só depois deve-se começar a ler dados dos fragmentos filhos. Quando `getRecordsResult.getNextShardIterator` retorna `null`, indica que todos os dados no fragmento pai foram lidos. # Alterar o período de retenção de dados O Amazon Kinesis Data Streams oferece suporte a alterações do período de retenção do registro de dados no fluxo de dados. Um fluxo de dados do Kinesis é uma sequência ordenada de registros de dados projetada para gravação e leitura em tempo real. Os registros de dados são, portanto, armazenados em fragmentos no fluxo temporariamente. O período entre o momento de adição de um registro e o momento em que ele deixa de estar acessível é chamado de *período de retenção*. Por padrão, um fluxo de dados do Kinesis armazena registros de 24 horas até 8.760 horas (365 dias). Você pode atualizar o período de retenção por meio do console do Kinesis Data Streams ou [IncreaseStreamRetentionPeriod](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_IncreaseStreamRetentionPeriod.html)usando as [DecreaseStreamRetentionPeriod](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_DecreaseStreamRetentionPeriod.html)operações e. No console do Kinesis Data Streams, pode-se editar em massa o período de retenção de mais de um fluxo de dados ao mesmo tempo. Você pode aumentar o período de retenção até um máximo de 8760 horas (365 dias) usando a [IncreaseStreamRetentionPeriod](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_IncreaseStreamRetentionPeriod.html)operação ou o console do Kinesis Data Streams. Você pode reduzir o período de retenção para um mínimo de 24 horas usando a [DecreaseStreamRetentionPeriod](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_DecreaseStreamRetentionPeriod.html)operação ou o console do Kinesis Data Streams. A sintaxe de solicitação das duas operações inclui o nome do fluxo e o período de retenção em horas. Finalmente, você pode verificar o período de retenção atual de um stream chamando a operação [DescribeStream](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_DescribeStream.html). Este é um exemplo de alteração do período de retenção que usa a AWS CLI: ``` aws kinesis increase-stream-retention-period --stream-name retentionPeriodDemo --retention-period-hours 72 ``` O Kinesis Data Streams para de tornar inacessíveis os registros no período de retenção antigo vários minutos após o aumento do período. Por exemplo, alterar o período de retenção de 24 horas para 48 horas significa que os registros adicionados ao fluxo 23 horas 55 minutos antes ainda estarão disponíveis depois de 24 horas. O Kinesis Data Streams torna inacessíveis os registros mais antigos que o novo período de retenção quase imediatamente após a diminuição do período. Portanto, deve-se tomar muito cuidado ao chamar a operação [DecreaseStreamRetentionPeriod](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_DecreaseStreamRetentionPeriod.html). Defina o período de retenção dos dados para garantir que os consumidores possam ler dados antes de expirar, se ocorrerem problemas. Deve-se considerar cuidadosamente todas as possibilidades, como um problema com a lógica de processamento de registro ou a inatividade de uma dependência de downstream por um longo período. Ideia do período de retenção como uma rede de segurança para dar mais tempo para os consumidores de dados se recuperarem. As operações da API de período de retenção permitem que isso seja configurado de forma proativa ou responda a eventos operacionais reativamente. Encargos adicionais incidem sobre streams com período de retenção definido acima de 24 horas. Para obter mais informações, consulte [Definição de preço do Amazon Kinesis Data Streams](https://aws.amazon.com/kinesis/data-streams/pricing/). # Marcar com tag seus recursos do Amazon Kinesis Data Streams É possível atribuir seus próprios metadados aos fluxos e aos consumidores de distribuição avançada criados no Amazon Kinesis Data Streams na forma de *tags*. Tag é um par de chave-valor definida para um fluxo. Usar tags é uma maneira simples, porém poderosa, de gerenciar AWS recursos e organizar dados, incluindo dados de faturamento. **Topics** + [Revisar conceitos básicos de tags](#tagging-basics) + [Monitorar custos usando tags](#tagging-billing) + [Compreender as restrições de tags](#tagging-restrictions) + [Atribuir tags a fluxos usando o console do Kinesis Data Streams](#tagging-console) + [Marque fluxos usando o AWS CLI](#tagging-cli) + [Marque streams usando o Kinesis Data Streams APIs](#tagging-api) + [Marque os consumidores usando o AWS CLI](#tagging-consumers-cli) + [Marque consumidores usando o Kinesis Data Streams APIs](#tagging-consumers-api) ## Revisar conceitos básicos de tags Os recursos do Kinesis Data Streams que você pode marcar com tags incluem fluxos de dados e consumidores de distribuição avançada. Você usa o AWS CLI console do Kinesis Data Streams ou a API do Kinesis Data Streams para concluir as seguintes tarefas: + Criar um recurso com tags + Adicionar tags a um recurso + Listar as tags para seus recursos + Remover as tags de um recurso **nota** Você não pode aplicar tags a consumidores de distribuição avançada usando o console do Kinesis Data Streams. Para aplicar tags aos consumidores, use AWS CLI nossa API Kinesis Data Streams. É possível usar tags para categorizar os recursos do . Por exemplo, você pode categorizar recursos por finalidade, proprietário ou ambiente. Como você define a chave e o valor para cada marca, é possível criar um conjunto de categorias personalizado para atender às suas necessidades específicas. Por exemplo, é possível definir um conjunto de tags que ajude a monitorar os recursos por proprietário e por aplicação associada. Aqui estão alguns exemplos de tags: + Projeto: nome do projeto + Proprietário: nome + Objetivo: testes de carga + Aplicação: nome da aplicação + Ambiente: produção **Importante** Para adicionar tags ao criar um fluxo, inclua as permissões `kinesis:CreateStream` e `kinesis:AddTagsToStream` para esse fluxo. Você **não pode usar** a permissão `kinesis:TagResource` para marcar fluxos ao criá-los. Para adicionar tags durante o registro do consumidor, inclua as permissões `kinesis:TagResource` e `kinesis:RegisterStreamConsumer`. ## Monitorar custos usando tags Você pode usar tags para categorizar e monitorar seus AWS custos. Quando você aplica tags aos seus recursos do Kinesis Data Streams AWS , seu relatório de alocação de custos inclui o uso e os custos agregados por tags. É possível aplicar tags que representem categorias de negócios, como centros de custos, nomes de aplicações ou proprietários, para organizar seus custos em vários serviços. Para obter mais informações, consulte [Usar tags de alocação de custos para relatórios de faturamento personalizados](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html) no *Manual do usuário do AWS Billing *. ## Compreender as restrições de tags As restrições a seguir se aplicam às tags: **Restrições básicas** + O número máximo de tags para cada recurso é 50. + As chaves e os valores de marcas diferenciam maiúsculas de minúsculas. + Não é possível alterar nem editar as tags de um recurso excluído. **Restrições de chaves de marcas** + Cada chave de tag deve ser exclusiva. Se uma tag for adicionada com uma chave que já estiver em uso, a nova tag substituirá o par de chave-valor existente. + Você não pode iniciar uma chave de tag com `aws:` porque esse prefixo é reservado para uso por AWS. AWS cria tags que começam com esse prefixo em seu nome, mas você não pode editá-las nem excluí-las. + As chaves de tag devem ter entre 1 e 128 caracteres Unicode. + As chaves de tag devem conter os seguintes caracteres: letras Unicode, dígitos, espaço em branco e os seguintes caracteres especiais: `_ . / = + - @`. **Restrições de valor das tags** + Os valores das tags devem ter entre 0 e 255 caracteres Unicode. + Os valores das tags podem estar em branco. Caso contrário, eles devem conter os seguintes caracteres: letras Unicode, dígitos, espaço em branco e qualquer um dos seguintes caracteres especiais: `_ . / = + - @`. ## Atribuir tags a fluxos usando o console do Kinesis Data Streams É possível adicionar, atualizar, listar e remover tags em seus fluxos usando o console do Kinesis Data Streams. **Para visualizar as tags de um fluxo** 1. [Faça login no Console de gerenciamento da AWS e abra o console do Kinesis em https://console.aws.amazon.com /kinesis.](https://console.aws.amazon.com/kinesis) 1. No painel de navegação à esquerda, selecione **Fluxos de dados**. 1. Na página **Fluxos de dados**, selecione o fluxo que deseja marcar com tag. 1. Na página Detalhes do fluxo, selecione **Configuração**. 1. Na seção **Tags**, visualize as tags aplicadas ao fluxo. **Como criar um fluxo de dados com uma tag** 1. Abra o console do Kinesis Data Streams. 1. No painel de navegação à esquerda, selecione **Fluxos de dados**. 1. Selecione **Criar fluxo de dados**. 1. Na página **Criar fluxo de dados**, insira um nome para seu fluxo de dados. 1. Para **Capacidade de fluxo de dados**, selecione o modo de capacidade **Sob demanda** ou **Provisionada**. Para obter mais informações sobre modos de capacidade, consulte [Escolha o modo certo para transmitir](how-do-i-size-a-stream.md). 1. Na seção **Tags**, faça o seguinte: 1. Selecione **Adicionar nova tag**. 1. Para **Chave**, insira a tag e, opcionalmente, especifique um valor no campo **Valor**. Se aparecer um erro, a chave ou o valor da tag especificado não atende às restrições da tag. Para obter mais informações, consulte [Compreender as restrições de tags](#tagging-restrictions). 1. Selecione **Criar fluxo de dados**. **Para adicionar ou atualizar uma tag em um fluxo** 1. Abra o console do Kinesis Data Streams. 1. No painel de navegação à esquerda, selecione **Fluxos de dados**. 1. Na página **Fluxos de dados**, selecione o fluxo ao qual você deseja adicionar ou atualizar as tags. 1. Na página Detalhes do fluxo, selecione **Configuração**. 1. Na seção **Tags**, escolha **Gerenciar tags**. 1. Em **Tags**, faça uma das seguintes opções: + Para adicionar uma tag, selecione **Adicionar nova tag** e insira os dados da tag **Chave** e **Valor**. Repita esta etapa quantas vezes for necessário. O número máximo de tags que podem ser adicionadas a cada fluxo é 50. + Para atualizar uma tag atual, insira um novo valor de tag no campo **Valor** da **Chave** dessa tag. Se aparecer um erro, a chave ou o valor da tag especificado não atende às restrições da tag. Para obter mais informações, consulte [Compreender as restrições de tags](#tagging-restrictions). 1. Escolha **Salvar alterações**. **Para remover uma tag de um fluxo** 1. Abra o console do Kinesis Data Streams. 1. No painel de navegação à esquerda, selecione **Fluxos de dados**. 1. Na página **Fluxos de dados**, selecione o fluxo do qual você deseja remover as tags. 1. Na página Detalhes do fluxo, selecione **Configuração**. 1. Na seção **Tags**, escolha **Gerenciar tags**. 1. Localize o par de tags **Chave** e **Valor** que você deseja remover. Em seguida, escolha **Remover**. 1. Escolha **Salvar alterações**. ## Marque fluxos usando o AWS CLI É possível adicionar, listar e remover tags em seus fluxos usando a AWS CLI. Para obter exemplos, consulte a seguinte documentação. [create-stream](https://docs.aws.amazon.com/cli/latest/reference/kinesis/create-stream.html) Cria um fluxo com tags. [add-tags-to-stream](https://docs.aws.amazon.com/cli/latest/reference/kinesis/add-tags-to-stream.html) Adiciona ou atualiza as tags para o fluxo especificado. [list-tags-for-stream](https://docs.aws.amazon.com/cli/latest/reference/kinesis/list-tags-for-stream.html) Lista as tags para o fluxo especificado. [remove-tags-from-stream](https://docs.aws.amazon.com/cli/latest/reference/kinesis/remove-tags-from-stream.html) Remove as tags do fluxo especificado. ## Marque streams usando o Kinesis Data Streams APIs Você pode adicionar, listar e remover tags em seus streams usando o Kinesis Data Streams. APIs Para obter exemplos, consulte a seguinte documentação: [CreateStream](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_CreateStream.html) Cria um fluxo com tags. [AddTagsToStream](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_AddTagsToStream.html) Adiciona ou atualiza as tags para o fluxo especificado. [ListTagsForStream](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_ListTagsForStream.html) Lista as tags para o fluxo especificado. [RemoveTagsFromStream](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_RemoveTagsFromStream.html) Remove as tags do fluxo especificado. ## Marque os consumidores usando o AWS CLI É possível adicionar, listar e remover tags em seus consumidores usando a AWS CLI. Para obter exemplos, consulte a seguinte documentação: [register-stream-consumer](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kinesis/register-stream-consumer.html) Registra um consumidor para um fluxo de dados do Kinesis com tags. [tag-resource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kinesis/tag-resource.html) Adiciona ou atualiza tags para o recurso do Kinesis especificado. [list-tags-for-resource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kinesis/list-tags-for-resource.html) Lista as tags do recurso do Kinesis especificado. [untag-resource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kinesis/untag-resource.html) Remove as tags do recurso do Kinesis especificado. ## Marque consumidores usando o Kinesis Data Streams APIs Você pode adicionar, listar e remover tags em seus consumidores usando o Kinesis APIs Data Streams. Para obter exemplos, consulte a seguinte documentação: [RegisterStreamConsumer](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_RegisterStreamConsumer.html) Registra um consumidor para um fluxo de dados do Kinesis com tags. [TagResource](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_TagResource.html) Adiciona ou atualiza tags para o recurso do Kinesis especificado. [ListTagsForResource](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_ListTagsForResource.html) Lista as tags do recurso do Kinesis especificado. [UntagResource](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_UntagResource.html) Remove as tags do recurso do Kinesis especificado. # Gerenciar registros grandes O Amazon Kinesis Data Streams suporta registros de até 10 MiBs mebibytes (). Esse recurso é recomendado para processar cargas úteis intermitentes de dados que excedam o limite padrão de tamanho de registro de 1 MiB. O tamanho de registro máximo padrão para fluxos existentes e recém-criados é definido como 1 MiB. Esse atributo beneficia aplicações de Internet das Coisas (IoT), pipelines de captura de dados de alteração (CDC) e fluxos de trabalho de machine learning que exigem o processamento ocasional de cargas úteis de dados de maior tamanho. Para começar a usar registros grandes em seu fluxo, atualize o limite máximo de tamanho de registro do seu fluxo. **Importante** O limite individual de taxa de transferência de fragmentos de 1 MB/s para gravações e 2 MB/s para leituras permanece inalterado com suporte para tamanhos de registro maiores. O Kinesis Data Streams foi projetado para acomodar grandes registros intermitentes junto com um tráfego básico de registros menores ou iguais a 1 MiB. Ele não foi projetado para acomodar a ingestão sustentada de registros grandes e de alto volume. ## Atualizar seu fluxo para usar registros grandes **Para processar registros maiores com o Kinesis Data Streams** 1. Vá para o console do Kinesis Data Streams. 1. Selecione seu fluxo e acesse a guia **Configuração**. 1. Clique em **Editar**, localizado ao lado de **Tamanho máximo do registro**. 1. Defina o tamanho máximo do registro (até 10 MiB). 1. Salve as alterações. Essa configuração ajusta somente o tamanho máximo do registro para esse fluxo de dados do Kinesis. Antes de aumentar esse limite, confirme se todas as aplicações downstream podem gerenciar registros maiores. Você também pode atualizar essa configuração usando a AWS CLI: ``` aws kinesis update-max-record-size \ --stream-arn \ --max-record-size-in-ki-b 5000 ``` ## Otimizar o desempenho do seu fluxo com registros grandes É recomendável manter registros grandes em menos de 2% do seu tráfego geral. Em um fluxo, cada fragmento tem uma capacidade de throughput de 1 MiB por segundo. Para acomodar registros grandes, os streams do Kinesis Data aumentam até 10 MiBs, com uma média de 1 MiB por segundo. Essa capacidade de ser compatível com registros grandes é continuamente recarregada no fluxo. A taxa de recarga depende do tamanho dos registros grandes e do tamanho do registro básico. Para obter melhores resultados, use uma chave de partição distribuída uniformemente. Para obter mais informações sobre como o Kinesis sob demanda escala, consulte [Atributos e casos de uso do modo sob demanda](how-do-i-size-a-stream.html#ondemandmode). ## Reduzir o controle de utilização com registros grandes **Para mitigar o controle de utilização** 1. Implemente a lógica de repetição com espera exponencial em sua aplicação produtora. 1. Use chaves de partição aleatórias para distribuir registros grandes pelos fragmentos disponíveis. 1. Armazene cargas úteis no Amazon S3 e envie somente referências de metadados ao fluxo para fluxos contínuos de registros grandes. Para obter mais informações, consulte [Processamento de registros grandes com o Amazon Kinesis Data Streams](https://aws.amazon.com/blogs/big-data/processing-large-records-with-amazon-kinesis-data-streams/). ## Gerencie registros grandes usando o Kinesis Data Streams APIs O suporte a registros grandes introduz uma nova API e atualiza dois planos de controle existentes APIs para lidar com registros de até 10 MiBs. API para modificar o tamanho do registro: + `UpdateMaxRecordSize`: configura o limite máximo de tamanho de registro para streams existentes de até 10. MiBs Atualizações para os existentes APIs: + `CreateStream`: adiciona o parâmetro `MaxRecordSizeInKiB` opcional para definir limites de tamanho de registro durante a criação do fluxo. + `DescribeStreamSummary`: retorna o campo `MaxRecordSizeInKiB` para mostrar a configuração atual do fluxo. Todos os APIs listados mantêm a compatibilidade com versões anteriores dos fluxos existentes. Para obter a documentação completa da API, consulte a [Referência da API do serviço do Amazon Kinesis Data Streams](https://docs.aws.amazon.com/kinesis/latest/APIReference/Welcome.html). ## AWS componentes compatíveis com registros grandes Os AWS componentes a seguir são compatíveis com registros grandes: | Componente | Description | | --- | --- | | AWS SDK | AWS O SDK suporta o gerenciamento de registros grandes. Você pode atualizar o tamanho máximo do registro do seu stream em até 10 MiB usando os métodos disponíveis no. AWS SDKs Para obter mais informações, consulte Como [usar esse serviço com um AWS SDK.](https://docs.aws.amazon.com/streams/latest/dev/sdk-general-information-section.html) | | Kinesis Consumer Library (KCL) | A KCL é compatível com o gerencimento de registros grandes a partir da versão 2.x. Para usar o suporte a registros grandes, atualize o `maxRecordSize` do seu fluxo e use a KCL. Para obter mais informações, consulte [Usar a Kinesis Client Library](https://docs.aws.amazon.com/streams/latest/dev/kcl.html). | | Kinesis Producer Library (KPL) | A partir da versão 1.0.5, a KPL é compatível com o gerenciamento de registros grandes. Para usar o suporte a registros grandes, atualize o maxRecordSize de seu fluxo e use a KPL. Para mais informações, consulte [Desenvolver produtores usando a Amazon Kinesis Producer Library (KPL)](https://docs.aws.amazon.com/streams/latest/dev/developing-producers-with-kpl.html). | | Amazon EMR | O Amazon EMR com Apache Spark oferece suporte ao tratamento de registros grandes até o limite do Kinesis Data Streams (10). MiBs Para usar o suporte a registros grandes, use a função `readStream`. Para mais informações, consulte [Integração do Amazon EMR com o Amazon Kinesis](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-kinesis.html). | | Amazon Data Firehose | Quando usado com o Kinesis Data Streams, o comportamento do Amazon Data Firehose com registros grandes depende do destino da entrega: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/streams/latest/dev/large-records.html) Para aplicativos que exigem entrega para o Snowflake ou Redshift com registros grandes, entregue primeiro os dados para o Amazon S3. Depois disso, use os processos de Extração, Transformação e Carregamento (ETL) para carregar os dados. Para todos os outros destinos, teste o comportamento com registros grandes em um proof-of-concept ambiente antes de escalar para o uso em produção. O gerenciamento de registros grandes varia de acordo com o destino. | | AWS Lambda | AWS Lambda suporta cargas úteis de até 6 MiBs. Esse limite inclui a carga útil do Kinesis convertida em codificação de base 64 e os metadados associados ao mapeamento da origem do evento (ESM). Para registros menores que 6 MiBs, o Lambda os processa usando o ESM sem necessidade de configuração adicional. Para registros maiores que 6 MiBs, o Lambda os processa usando um destino em caso de falha. É necessário configurar um destino em caso de falha usando o ESM para gerenciar registros que excedam os limites de processamento do Lambda. Cada evento enviado ao destino em caso de falha é um documento JSON que contém metadados sobre a invocação que falhou. É recomendável criar um destino em caso de falha no ESM, independentemente do tamanho do registro. Isso garante que nenhum registro seja descartado. Para obter mais informações, consulte [Configurar destinos para invocações com falha](https://docs.aws.amazon.com/lambda/latest/dg/kinesis-on-failure-destination.html#kinesis-on-failure-destination-console). | | banco de dados de origem | O Amazon Redshift só oferece suporte a tamanhos de registro menores que 1 MiB no fluxo de dados a partir do Kinesis Data Streams. Os registros que excederem esse limite não serão processados. Os registros não processados são registrados em log como `sys_stream_scan_errors`. Para obter mais informações, 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 | Há duas abordagens para consumir dados do Kinesis Data Streams: o conector de origem do Kinesis e o conector coletor do Kinesis. O conector de origem suporta o tratamento de registros menores que 1 MiB e até 10. MiBs Não use o conector do coletor para registros maiores que 1 MiB. Para obter mais informações, consulte [Usar conectores para mover dados no Amazon Managed Service para Apache Flink com](https://docs.aws.amazon.com/managed-flink/latest/java/how-connectors.html) a API. DataStream | ## Regiões em que grandes registros são compatíveis Esse recurso do Amazon Kinesis Data Streams está disponível somente nas AWS seguintes regiões: | AWS Região | Nome da região | | --- | --- | | eu-north-1 | Europa (Estocolmo) | | me-south-1 | Oriente Médio (Bahrein) | | ap-south-1 | Ásia-Pacífico (Mumbai) | | eu-west-3 | Europa (Paris) | | ap-southeast-3 | Ásia-Pacífico (Jacarta) | | us-east-2 | Leste dos EUA (Ohio) | | af-south-1 | África (Cidade do Cabo) | | eu-west-1 | Europa (Irlanda) | | me-central-1 | Oriente Médio (Emirados Árabes Unidos) | | eu-central-1 | Europa (Frankfurt) | | sa-east-1 | América do Sul (São Paulo) | | ap-east-1 | Ásia-Pacífico (Hong Kong) | | ap-south-2 | Ásia-Pacífico (Hyderabad) | | us-east-1 | Leste dos EUA (Norte da Virgínia) | | ap-northeast-2 | Ásia-Pacífico (Seul) | | ap-northeast-3 | Ásia-Pacífico (Osaka) | | eu-west-2 | Europa (Londres) | | ap-southeast-4 | Ásia-Pacífico (Melbourne) | | ap-northeast-1 | Ásia-Pacífico (Tóquio) | | us-west-2 | Oeste dos EUA (Oregon) | | us-west-1 | Oeste dos EUA (N. da Califórnia) | | ap-southeast-1 | Ásia-Pacífico (Singapura) | | ap-southeast-2 | Ásia-Pacífico (Sydney) | | il-central-1 | Israel (Tel Aviv) | | ca-central-1 | Canadá (Central) | | ca-west-1 | Oeste do Canadá (Calgary) | | eu-south-2 | Europa (Espanha) | | cn-northwest-1 | China (Ningxia) | | eu-central-2 | Europa (Zurique) | | us-gov-east-1 | AWS GovCloud (Leste dos EUA) | | us-gov-west-1 | AWS GovCloud (Oeste dos EUA) | # Realize testes de resiliência com AWS Fault Injection Service AWS Fault Injection Service é um serviço totalmente gerenciado que ajuda você a realizar experimentos de injeção de falhas em suas AWS cargas de trabalho. AWS FIS a integração com o Amazon Kinesis Data Streams permite que você teste a resiliência do seu aplicativo contra erros comuns da API do Amazon Kinesis Data Streams em um ambiente controlado. Esse recurso permite validar o tratamento de erros, a lógica de novas tentativas e também monitorar os sistemas antes de encontrar falhas. Para obter mais informações, consulte [O que é AWS Fault Injection Service?](https://docs.aws.amazon.com/fis/latest/userguide/what-is.html) . **Ações** + Erro interno da API: injeta erros internos nas solicitações feitas pelo perfil do IAM de destino. A resposta específica depende de cada serviço e API. A ação `aws:fis:inject-api-internal-error` cria erros `InternalFailure` (HTTP 500). + Erro de controle de utilização da API: injeta erros internos nas solicitações feitas pelo perfil do IAM de destino. A resposta específica depende de cada serviço e API. A ação `aws:fis:inject-api-throttle-error` cria erros `ThrottlingException` (HTTP 400). + Erro de API indisponível: injeta erros internos nas solicitações feitas pelo perfil do IAM de destino. A resposta específica depende de cada serviço e API. A ação `aws:fis:inject-api-unavailable-error` cria erros `ServiceUnavailable` (HTTP 503). + Exceção de throughput provisionada: injeta erros internos nas solicitações feitas pelo perfil do IAM de destino. A resposta específica depende de cada serviço e API. A ação `aws:kinesis:inject-api-provisioned-throughput-exception` cria erros `ProvisionedThroughputExceededException` (HTTP 400). + Exceção de iterador expirado da API: injeta erros internos nas solicitações feitas pelo perfil do IAM de destino. A resposta específica depende de cada serviço e API. A ação `aws:kinesis:inject-api-expired-iterator-exception` cria erros `ExpiredIteratorException` (HTTP 400). Para obter mais informações, consulte [Ações do Amazon Kinesis Data Streams](https://docs.aws.amazon.com/fis/latest/userguide/fis-actions-reference.html#aws-kinesis-actions). **Considerações** + Você pode usar as ações acima com ofertas provisionadas e sob demanda para o Amazon Kinesis Data Streams. + Seu fluxo é retomado quando o experimento é concluído, com base na duração selecionada. Também é possível interromper um experimento em andamento antes que ele seja concluído. Como alternativa, você pode definir uma condição de parada para interromper o experimento com base em alarmes que definem a integridade do aplicativo em um Amazon CloudWatch Application Insights. + Você pode testar até 280 fluxos. Para obter mais informações sobre suporte regional, consulte [Endpoints e quotas do AWS Fault Injection Service](https://docs.aws.amazon.com/general/latest/gr/fis.html). # Erros de exceção de throughput provisionada Os erros de exceção de throughput provisionado excedido (HTTP 400) ocorrem quando a taxa de solicitação de um fluxo do Kinesis ultrapassa os limites de throughput de um ou mais fragmentos. Cada fragmento tem limites específicos de capacidade de leitura e gravação e exceder esses limites aciona essa exceção. Os cenários que levam a essa exceção incluem: picos repentinos na ingestão ou no consumo de dados, capacidade insuficiente de fragmentos para o volume de dados processado ou distribuição desigual das chaves de partição. **Recomendações para lidar com exceções** + Implemente mecanismos exponenciais de espera e de novas tentativas. + Aumente o número de fragmentos para acomodar uma maior throughput. + Assegure que haja uma distribuição adequada das chaves de partição. + Monitore as métricas do fluxo. Além disso, o uso do modo de capacidade sob demanda do Kinesis ajuda a ajustar automaticamente workloads e minimizar a ocorrência dessa exceção. Para ter mais informações, consulte [O que é o AWS Fault Injection Service?](https://docs.aws.amazon.com/fis/latest/userguide/what-is.html) **nota** Os problemas de distribuição imprópria estão fora da capacidade de escalonamento automático no modo sob demanda. **Para realizar um experimento básico** 1. Use métricas básicas: registre os padrões de throughput normais antes do teste. 1. Crie um experimento: use a ação `aws:kinesis:inject-api-provisioned-throughput-exception`. 1. Configure a intensidade: comece com um controle de utilização de solicitações de 25%. 1. Monitore as respostas: verifique a lógica de novas tentativas com espera exponencial. 1. Valide o ajuste de escala: confirme se o ajuste de escala automático aciona a ativação. 1. Verifique os alarmes: confira se os alarmes `CloudWatch` estão funcionando conforme o esperado. As aplicações devem implementar estratégias de espera adequadas, monitorar as métricas `WriteProvisionedThroughputExceeded` e `ReadProvisionedThroughputExceeded` e acionar o ajuste de escala de fragmentos quando apropriado. **Detalhes da ação** + **Tipo de recurso**: ARN do perfil do IAM + **Operações de destino**: `PutRecord`, `PutRecords`, `GetRecords` + ****Código de erro****: `ProvisionedThroughputExceededException` (HTTP 400) + ****Descrição****: simula cenários em que a taxa de solicitação excede os limites de capacidade de fragmento, testando o controle de utilização de aplicações e ajustando a escala das respostas. **Parâmetros** + **ARN do perfil do IAM**: perfil usado por sua aplicação para as operações do Kinesis Data Streams. + **Operações**: operações de destino: `PutRecord`, `PutRecords`, `GetRecords`. + **Lista de recursos**: nomes específicos do fluxo ou identificadores de fragmentos. + **Duração**: duração do experimento, que varia de um minuto a 12 horas. Na AWS FIS API, o valor é uma string no formato ISO 8601. Por exemplo, PT1 M representa um minuto. No AWS FIS console, você insere o número de segundos, minutos ou horas. + **Intensidade**: a porcentagem de solicitações a serem submetidas a controle de utilização. **Permissões obrigatórias** + `kinesis:InjectApiError` Exemplo de modelo de experimento O exemplo a seguir mostra uma exceção de taxa de transferência provisionada para todas as solicitações de até 5 streams do Kinesis Data com a tag especificada. AWS FIS seleciona os fluxos a serem afetados aleatoriamente. Após 5 minutos, a falha é removida. ``` { "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" } } ``` Exemplo de permissões do perfil do experimento A permissão a seguir permite que você execute as ações `aws:kinesis:stream-provisioned-throughput-exception` e `aws:kinesis:stream-expired-iterator-exception` em um fluxo específico que afeta 50% das solicitações. # Erros de exceção do iterador expirado Os erros de exceção do iterador expirado (HTTP 400) ocorrem quando o iterador de fragmento expira e não é mais usado para recuperar os registros do fluxo durante a chamada de `GetRecords`. Isso ocorre quando há atrasos entre as operações de leitura, causados por tarefas de processamento de dados de longa duração, problemas de rede ou tempo de inatividade da aplicação. **nota** Um iterador de fragmento é válido por 5 minutos após o momento em que é emitido. **Recomendações para lidar com exceções** + Atualizar os iteradores de fragmento antes que eles expirem. + Incorporar o tratamento de erros para obter novos iteradores. + Utilizar a Kinesis Kinesis Client Library (KCL), que gerencia automaticamente a expiração do iterador de fragmento. Para obter mais informações, consulte [O que é AWS Fault Injection Service?](https://docs.aws.amazon.com/fis/latest/userguide/what-is.html) **Para realizar um experimento básico** 1. Crie um modelo de experimento: use o AWS FIS console. 1. Selecione a ação: use a ação `aws:kinesis:inject-api-expired-iterator-exception`. 1. Configure os destinos: especifique o perfil do IAM e as operações do Kinesis Data Streams. 1. Defina a duração: comece com 5 a 10 minutos para o teste inicial. 1. Adicionar condições de parada: [condições de parada para AWS FIS](https://docs.aws.amazon.com/fis/latest/userguide/stop-conditions.html). 1. Execute o experimento: monitore o comportamento da aplicação. **Detalhes da ação** + **Tipo de recurso**: ARN do perfil do IAM + **Operações de destino**: `GetRecords` + ****Código de erro****: `ExpiredIteratorException` (HTTP 400) + ****Descrição****: o iterador fornecido excede o período máximo permitido, simulando cenários em que o processamento de registros é muito lento ou a lógica de verificação falha. **Parâmetros** + **ARN do perfil do IAM**: perfil usado por sua aplicação para as operações do Kinesis Data Streams. + **Operações**: operações de destino: `GetRecords` + **Lista de recursos**: os nomes específicos do fluxo ou ARNs. + **Duração**: a duração do experimento. Isso é configurável. + **Intensidade**: a porcentagem de solicitações a serem submetidas a controle de utilização. **Permissões obrigatórias** + `kinesis:InjectApiError`