Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Crea e gestisci flussi di dati Kinesis Flusso di dati Amazon Kinesis ottiene grandi quantità di dati in tempo reale, li memorizza in modo durevole e li rende disponibili per il consumo. L'unità di dati archiviati dal flusso di dati Kinesis è un *record di dati*. Un *flusso di dati* rappresenta un gruppo di record di dati. I record di dati in un flusso di dati sono distribuiti in shard. Uno *shard* è una sequenza di record di dati in un flusso. Funge da unità di velocità di trasmissione effettiva di base di un flusso di dati Kinesis. Uno shard supporta da 1 MB/s a 1000 record al secondo per le *scritture* e 2 MB/s per le *letture* in modalità on-demand e con capacità fornita. I limiti delle partizioni garantiscono prestazioni prevedibili, semplificando la progettazione e la gestione di un flusso di lavoro di streaming di dati altamente affidabile. In questa sezione, imparerai come impostare la modalità di capacità per lo stream e come creare uno stream utilizzando o. Console di gestione AWS APIs Potrai quindi intraprendere azioni aggiuntive sullo stream. **Topics** + [Scegli la modalità giusta per lo streaming](how-do-i-size-a-stream.md) + [Crea uno stream utilizzando il Console di gestione AWS](how-do-i-create-a-stream.md) + [Crea uno stream utilizzando il APIs](kinesis-using-sdk-java-create-stream.md) + [Aggiorna uno stream](updating-a-stream.md) + [Visualizzazione dell'elenco di flussi](kinesis-using-sdk-java-list-streams.md) + [Elenca i frammenti](kinesis-using-sdk-java-list-shards.md) + [Eliminare uno stream](kinesis-using-sdk-java-delete-stream.md) + [Condividi nuovamente uno stream](kinesis-using-sdk-java-resharding.md) + [Modifica il periodo di conservazione dei dati](kinesis-extended-retention.md) + [Etichetta le tue risorse Amazon Kinesis Data Streams](tagging.md) + [Gestisci dischi di grandi dimensioni](large-records.md) + [Esegui test di resilienza con AWS Fault Injection Service](kinesis-fis.md) # Scegli la modalità giusta per lo streaming I seguenti argomenti spiegano come scegliere la modalità migliore per l'applicazione e come passare da una modalità all'altra, se necessario. **Topics** + [Quali sono le diverse modalità di Kinesis Data Streams?](#diff-modes-kds) + [Caratteristiche e casi d'uso della modalità Standard su richiesta](#ondemandmode) + [Caratteristiche e casi d'uso della modalità On-demand Advantage](#ondemand-advantage-mode) + [Caratteristiche e casi d'uso della modalità Provisioned Mode](#provisionedmode) + [Passa da una modalità all'altra](#switchingmodes) ## Quali sono le diverse modalità di Kinesis Data Streams? Una modalità determina come viene gestita la capacità di un flusso di dati e in che modo ti viene addebitato l'utilizzo del flusso di dati. In Amazon Kinesis Data Streams, **puoi scegliere** On-demand **Standard,** On-demand Advantage e Provisioned come modalità per **i** tuoi flussi di dati. + **On-demand Standard**: i flussi di dati con modalità on demand non richiedono alcuna pianificazione della capacità e si ridimensionano automaticamente per gestire gigabyte di velocità di scrittura e lettura al minuto. Con la modalità on demand, il flusso di dati Kinesis gestisce automaticamente le partizioni per fornire la velocità di trasmissione effettiva necessaria. + **On-demand Advantage**: una modalità a livello di account che abilita più funzionalità e fornisce una struttura dei prezzi più semplice per i flussi su richiesta. In questa modalità, puoi aumentare in modo proattivo la capacità di trasmissione di scrittura di uno stream in qualsiasi momento. **Per quanto riguarda i prezzi, non è più previsto un costo fisso per flusso e l'acquisizione, il recupero dei dati e l'utilizzo prolungato della conservazione in tutti i flussi on demand sono inferiori almeno del 60% rispetto a quelli di On-demand Standard.** + **Fornito**: per i flussi di dati con una modalità di provisioning, è necessario specificare il numero di shard per il flusso di dati. La capacità totale di un flusso di dati è la somma di capacità delle relative partizioni. È possibile aumentare o diminuire il numero di shard in un flusso di dati, in base alle esigenze. Puoi utilizzare Kinesis Data `PutRecords` APIs Streams e scrivere `PutRecord` dati nei tuoi flussi di dati in qualsiasi modalità. Per recuperare i dati, tutte e tre le modalità supportano i consumatori predefiniti che utilizzano l'`GetRecords`API e i consumatori Enhanced Fan-Out (EFO) che utilizzano l'API. `SubscribeToShard` Tutte le funzionalità del flusso di dati Kinesis, tra cui la modalità di conservazione, la crittografia, i parametri di monitoraggio e altre, sono supportate sia per la modalità on demand che per quella assegnata. Il flusso di dati Kinesis offre durabilità e disponibilità elevate sia in modalità di capacità on demand che in modalità di capacità assegnata. ## Caratteristiche e casi d'uso della modalità Standard su richiesta I flussi di dati in modalità on demand non richiedono alcuna pianificazione della capacità e si dimensionano automaticamente per gestire i gigabyte di velocità di trasmissione effettiva di scrittura e lettura al minuto. La modalità on demand semplifica l'acquisizione e l'archiviazione di grandi volumi di dati a bassa latenza perché elimina il provisioning e la gestione di server, spazio di archiviazione o velocità di trasmissione effettiva. È possibile importare miliardi di record al giorno senza alcun sovraccarico operativo. La modalità on demand è ideale per soddisfare le esigenze di traffico applicativo altamente variabile e imprevedibile. Non è più necessario effettuare il provisioning di questi carichi di lavoro per la massima capacità, il che può comportare costi più elevati a causa del basso utilizzo. La modalità on demand è adatta per carichi di lavoro con modelli di traffico imprevedibili e altamente variabili. Con la modalità di capacità on demand, si paga per i GB di dati scritti e letti dai flussi di dati. Non è necessario specificare la velocità di trasmissione effettiva di lettura e scrittura che si prevede l'applicazione esegua. Il flusso di dati Kinesis si adatta istantaneamente ai carichi di lavoro siano essi aumentati o diminuiti. Per ulteriori informazioni, consulta [Prezzi di Amazon Kinesis Data Streams](https://aws.amazon.com/kinesis/data-streams/pricing/). Un flusso di dati in modalità on demand supporta fino al doppio della velocità di trasmissione effettiva di scrittura di picco osservato nei 30 giorni precedenti. Man mano che la velocità trasmissione effettiva di scrittura del flusso di dati raggiunge un nuovo picco, il flusso di dati Kinesis dimensiona automaticamente la capacità del flusso di dati. Ad esempio, se il flusso di dati ha un throughput di scrittura che varia tra il 10 MB/s e il 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 di velocità di scrittura. Tuttavia, si può verificare una limitazione se il traffico aumenta fino a più del doppio del picco precedente nell'arco di 15 minuti. Dovrai riprovare a eseguire queste richieste limitate. La capacità di lettura aggregata di un flusso di dati con la modalità on demand aumenta proporzionalmente alla velocità di scrittura. Ciò contribuisce a garantire che le applicazioni consumer abbiano sempre una velocità di lettura adeguata per elaborare i dati in arrivo in tempo reale. Ottieni almeno il doppio della velocità di trasmissione effettiva di scrittura rispetto ai dati di lettura utilizzando l'API `GetRecords`. Ti consigliamo di utilizzare un'applicazione consumer con l'API `GetRecord` in modo che abbia abbastanza spazio per recuperare il ritardo dell'applicazione quando deve essere ripristinata dopo un periodo di inattività. Si consiglia di utilizzare la funzionalità di fan-out avanzato del flusso di dati Kinesis per scenari che richiedono l'aggiunta di più di un'applicazione consumer. Il fan-out avanzato supporta l'aggiunta di un massimo di 20 applicazioni consumer a un flusso di dati tramite l'API `SubscribeToShard`, con ogni applicazione consumer con una velocità di trasmissione effettiva dedicata. ### Gestisci le eccezioni della velocità effettiva di lettura e scrittura Con la modalità on-demand (la stessa della modalità di capacità fornita), è necessario specificare una chiave di partizione per ogni record per scrivere i dati nel flusso di dati. Il flusso di dati Kinesis utilizza le chiavi di partizione per distribuire i dati tra le partizioni. Il flusso di dati Kinesis monitora il traffico per ogni partizione. Quando il traffico in entrata supera i 500 KB/s per shard, lo divide entro 15 minuti. I valori della chiave hash della partizione principale vengono ridistribuiti in modo uniforme tra le partizioni secondarie. Se il traffico in entrata supera il doppio del picco precedente, è possibile che si verifichino eccezioni di lettura o scrittura per circa 15 minuti, anche quando i dati sono distribuiti uniformemente tra le partizioni. Ti consigliamo di riprovare tutte queste richieste in modo che tutti i record vengano archiviati correttamente nel flusso di dati Kinesis. Potrebbero verificarsi eccezioni di lettura e scrittura se si utilizza una chiave di partizione che causa una distribuzione non uniforme dei dati e se i record assegnati a una determinata partizione superano i limiti. Con la modalità on-demand, il flusso di dati si adatta automaticamente per gestire modelli di distribuzione dei dati non uniformi, a meno che una singola chiave di partizione non superi i limiti di 1 throughput e 1000 record al secondo di uno shard. MB/s Nella modalità on demand, il flusso di dati Kinesis divide le partizioni in modo uniforme quando rileva un aumento del traffico. Tuttavia, non rileva né isola le chiavi hash che indirizzano una parte maggiore del traffico in entrata verso una partizione particolare. Se si utilizzano chiavi di partizione molto irregolari, è possibile che continuino a ricevere eccezioni di scrittura. Per questi casi d'uso, si consiglia di utilizzare la modalità di capacità assegnata che supporta le suddivisioni di partizioni granulari. ## Caratteristiche e casi d'uso della modalità On-demand Advantage On-demand Advantage è un'impostazione a livello di account che sblocca più funzionalità e fornisce una struttura dei prezzi diversa per tutti gli stream on demand nella regione. In questa modalità, gli stream on demand mantengono le loro funzionalità e continuano a scalare automaticamente la capacità in base all'effettivo utilizzo dei dati. Se desideri riscaldare in modo proattivo la capacità di scrittura di uno stream, puoi configurare una velocità effettiva effettiva. Ad esempio, se il flusso di dati ha una velocità di scrittura compresa tra 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 per garantire che la capacità sia disponibile quando arriva la velocità effettiva dei dati. L'utilizzo della velocità effettiva a caldo non comporta costi aggiuntivi. Un altro vantaggio della modalità On-demand Advantage è che i flussi on-demand passano a una struttura tariffaria più semplice. Con la modalità abilitata, l'account non vedrà più addebiti fissi per flusso e tu dovrai occuparti solo dell'acquisizione e del recupero dei dati e dei costi opzionali di conservazione estesa. Ogni dimensione di prezzo offre inoltre uno sconto significativo rispetto alla dimensione corrispondente in On-demand Standard. Per ulteriori informazioni, consulta [Prezzi di Amazon Kinesis Data Streams](https://aws.amazon.com/kinesis/data-streams/pricing/). Inoltre, i recuperi dati avanzati in modalità fan-out non comportano un sovrapprezzo rispetto ai recuperi dati standard in questa modalità. Inoltre, con la modalità On-demand Advantage, puoi registrare fino a 50 utenti per streaming per utilizzare il fan-out avanzato. L'attivazione di On-demand Advantage impegna l'account a recuperare almeno il 25% MiB/s of data ingest and 25MiB/s dei dati su tutti i flussi on-demand. Per gli account che soddisfano i requisiti di utilizzo minimi, la console Kinesis Data Streams verifica se i modelli di utilizzo dell'account sono adatti **all'utilizzo** della modalità On-demand Advantage. Se l'utilizzo dei dati del tuo account è inferiore al requisito, ti verrà addebitata la differenza a titolo di deficit, ma sarà comunque applicata la stessa tariffa scontata. L'attivazione di On-demand Advantage prevede inoltre un periodo minimo di 24 ore prima di poter disattivare la modalità. Nel complesso, On-demand Advantage è il modo migliore per eseguire lo streaming con Kinesis Data Streams se hai un utilizzo costante del throughput vicino o superiore all'impegno minimo, hai bisogno di molti utenti che si divertono o gestisci con centinaia di flussi di dati. ## Caratteristiche e casi d'uso della modalità Provisioned Mode Con la modalità provisioning, dopo aver creato il flusso di dati, puoi aumentare o ridurre dinamicamente la capacità dello shard utilizzando o l' Console di gestione AWS API. [UpdateShardCount](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_UpdateShardCount.html) È possibile effettuare aggiornamenti mentre è presente un'applicazione producer o consumer del flusso di dati Kinesis che scrive o legge dati dal flusso. La modalità assegnata è adatta per un traffico prevedibile con requisiti di capacità facili da stimare. È possibile utilizzare la modalità assegnata se si desidera un controllo preciso su come i dati sono distribuiti tra le partizioni. Con la modalità assegnata, devi specificare il numero di partizioni per il flusso di dati. Per determinare le dimensioni iniziali di un flusso di dati, è necessario soddisfare i seguenti valori di input: + Le dimensioni medie del record di dati scritti nel flusso in kilobyte (KB), arrotondate al KB più vicino (`average_data_size_in_KB`). + Il numero di record di dati scritti e letti dal flusso al secondo (`records_per_second`). + Il numero di applicazioni consumer, che sono le applicazioni del flusso di dati Kinesis che elaborano i dati simultaneamente e indipendentemente dal flusso (`number_of_consumers`). + La larghezza di banda in scrittura in entrata in KB (`incoming_write_bandwidth_in_KB`), che è uguale a `average_data_size_in_KB` moltiplicato per `records_per_second`. + La larghezza di banda in lettura in uscita in KB (`outgoing_read_bandwidth_in_KB`), che è uguale a `incoming_write_bandwidth_in_KB` moltiplicato per `number_of_consumers`. Puoi calcolare il numero di partizioni (`number_of_shards`) di cui il flusso ha bisogno utilizzando i valori di input nella formula seguente: ``` number_of_shards = ceiling(max(incoming_write_bandwidth_in_KiB/1024, outgoing_read_bandwidth_in_KiB/2048)) ``` Nella modalità assegnata è possibile che si verifichino comunque eccezioni di velocità di trasmissione effettiva di lettura e scrittura se non si configura il flusso di dati per gestire i picchi di velocità di trasmissione effettiva. In questo caso, è necessario dimensionare manualmente il flusso di dati in modo da adattarlo al traffico di dati. Potrebbero verificarsi eccezioni di lettura e scrittura se si utilizza una chiave di partizione che causa una distribuzione non uniforme dei dati e se i record assegnati a una determinata partizione superano i limiti. Per risolvere questo problema nella modalità assegnata, identifica tali frammenti e dividili manualmente per adattarli meglio al traffico. Per ulteriori informazioni, consulta [Ripartizionamento di un flusso](https://docs.aws.amazon.com/streams/latest/dev/kinesis-using-sdk-java-resharding.html). ## Passa da una modalità all'altra Per ogni flusso di dati Account AWS, puoi passare dalla modalità on-demand a quella fornita due volte nell'arco di 24 ore. Il passaggio da una modalità all'altra non causa interruzioni alle applicazioni che utilizzano questo flusso di dati. È possibile continuare a scrivere e leggere da questo flusso di dati. *Quando passi da una modalità all'altra, da on-demand a provisioned o da provisioning a on-demand, lo stato dello stream viene impostato su Aggiornamento.* È necessario attendere che lo stato del flusso di dati diventi *Attivo* prima di poterne modificare nuovamente le proprietà. Quando si passa dalla modalità di capacità assegnata a quella on demand, il flusso di dati inizialmente conserva il numero di partizioni che aveva prima della transizione e, da questo momento in poi, il flusso di dati Kinesis monitorerà il traffico di dati e dimensionerà il numero di partizioni di questo flusso di dati on demand in base alla velocità di trasmissione effettiva di scrittura. Quando passi dalla modalità on demand a quella con provisioning, inizialmente il flusso di dati conserva anche il numero di shard che aveva prima della transizione, ma da questo momento in poi, sei responsabile del monitoraggio e della regolazione del numero di shard di questo flusso di dati per adattarlo adeguatamente al tuo throughput di scrittura. **Puoi passare dalla modalità On-demand Standard alla modalità **On-demand Advantage abilitando un'impostazione a livello** di account.** Se abilitato, l'account si impegna ad utilizzare almeno il 25% MiB/s of data ingest and 25MiB/s del recupero dei dati in tutti i flussi on-demand della regione. Una volta abilitato, è necessario attendere almeno 24 ore prima di poter disattivare **On-demand Advantage**, ma è possibile richiedere la modifica in qualsiasi momento. Se desideri passare da **On-demand Advantage a On-demand** **Standard**, devi prima rimuovere qualsiasi throughput caldo configurato con i flussi a richiesta. # Crea uno stream utilizzando il Console di gestione AWS È possibile creare un flusso utilizzando la console del flusso di dati Kinesis, l'API del flusso di dati Kinesis o la AWS Command Line Interface (AWS CLI). **Creazione di un flusso di dati tramite la console** 1. [Accedi Console di gestione AWS e apri la console Kinesis all'indirizzo https://console.aws.amazon.com /kinesis.](https://console.aws.amazon.com/kinesis) 1. Nella barra di navigazione, espandere il selettore delle regioni e selezionare una regione. 1. Selezionare **Create data stream (Crea flusso di dati)**. 1. Nella pagina **Crea flusso Kinesis**, inserisci un nome per il tuo flusso di dati, quindi scegli la modalità di capacità **On demand** o **Assegnata**. La modalità **On demand** è selezionata per impostazione predefinita. Per ulteriori informazioni, consulta [Scegli la modalità giusta per lo streaming](how-do-i-size-a-stream.md). Con la modalità **On demand**, puoi quindi scegliere **Crea flusso Kinesis** per creare il tuo flusso di dati. Con la modalità **Assegnata**, devi specificare il numero di partizioni necessarie e quindi scegliere **Crea flusso Kinesis**. Nella pagina **Kinesis streams (Flussi Kinesis)**, lo **Status (Stato)** del flusso è **Creating (Creazione in corso)** durante la creazione del flusso. Quando il flusso è pronto per essere usato, lo **Status (Stato)** passa su **Active (Attivo)**. 1. Seleziona il nome del flusso. La pagina **Stream Details** (Dettagli del flusso) visualizza un riepilogo della configurazione del flusso, oltre alle informazioni sul monitoraggio. **Creazione di un flusso tramite l'API del flusso di dati Kinesis** + Per informazioni sulla creazione di un flusso tramite l'API del flusso di dati Kinesis, consulta [Crea uno stream utilizzando il APIs](kinesis-using-sdk-java-create-stream.md). **Per creare uno stream utilizzando il AWS CLI** + Per informazioni sulla creazione di uno stream utilizzando AWS CLI, vedete il comando [create-stream](https://docs.aws.amazon.com/cli/latest/reference/kinesis/create-stream.html). # Crea uno stream utilizzando il APIs Utilizzare la procedura seguente per creare il tuo flusso di dati Kinesis. ## Crea il client Kinesis Data Streams Prima di utilizzare i flusso di dati Kinesis, è necessario creare un oggetto client. Il seguente codice Java avvia un'istanza da un generatore client e la utilizza per impostare la regione, le credenziali e la configurazione del client. Quindi crea un oggetto client. ``` AmazonKinesisClientBuilder clientBuilder = AmazonKinesisClientBuilder.standard(); clientBuilder.setRegion(regionName); clientBuilder.setCredentials(credentialsProvider); clientBuilder.setClientConfiguration(config); AmazonKinesis client = clientBuilder.build(); ``` Per ulteriori informazioni, consulta [Regioni ed endpoint del flusso di dati Kinesis](https://docs.aws.amazon.com/general/latest/gr/rande.html#ak_region) nella *Riferimenti generali di AWS*. ## Crea lo stream Ora che hai creato il tuo client Kinesis Data Streams, puoi creare uno stream utilizzando la console o a livello di codice. Per creare uno stream a livello di codice, crea un'istanza di un `CreateStreamRequest` oggetto e specifica un nome per lo stream. Se desideri utilizzare la modalità provisioned, specifica il numero di shard da utilizzare per lo stream. + **On demand**: ``` CreateStreamRequest createStreamRequest = new CreateStreamRequest(); createStreamRequest.setStreamName( myStreamName ); ``` + **Assegnata**: ``` CreateStreamRequest createStreamRequest = new CreateStreamRequest(); createStreamRequest.setStreamName( myStreamName ); createStreamRequest.setShardCount( myStreamSize ); ``` Il nome del flusso identifica il flusso. Il nome si riferisce all' AWS account utilizzato dall'applicazione. È inoltre definito in base alla regione. Cioè, due stream in due AWS account diversi possono avere lo stesso nome e due stream nello stesso AWS account ma in due regioni diverse possono avere lo stesso nome, ma non due stream sullo stesso account e nella stessa regione. La velocità effettiva dello stream è una funzione del numero di shard. Per una maggiore velocità effettiva assegnata, sono necessari più shard. Un numero maggiore di shard aumenta anche il costo AWS addebitato per lo streaming. Per ulteriori informazioni su come calcolare il numero appropriato di shard per la tua applicazione, vedere [Scegli la modalità giusta per lo streaming](how-do-i-size-a-stream.md). Dopo aver configurato l'`createStreamRequest`oggetto, create uno stream chiamando il `createStream` metodo sul client. Dopo la chiamata a `createStream`, attendere che il flusso raggiunga lo stato `ACTIVE` prima di eseguire qualunque operazione sul flusso. Per controllare lo stato del flusso, chiamare il metodo `describeStream`. Tuttavia, `describeStream` genera un'eccezione se il flusso non esiste. Pertanto, racchiudere la chiamata `describeStream` in un blocco `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" ); } ``` # Aggiorna uno stream È possibile aggiornare i dettagli di un flusso utilizzando la console del flusso di dati Kinesis, l'API del flusso di dati Kinesis o la AWS CLI. **Nota** Puoi abilitare la crittografia lato server per flussi esistenti o per flussi che hai creato di recente. ## Eliminare con la console **Aggiornamento di un flusso di dati tramite la console** 1. Apri la console Amazon Kinesis all'indirizzo. [https://console.aws.amazon.com/kinesis/](https://console.aws.amazon.com/kinesis/) 1. Nella barra di navigazione, espandere il selettore delle regioni e selezionare una regione. 1. Selezionare il nome del flusso nell'elenco. La pagina **Stream Details (Informazioni flusso)** visualizza un riepilogo della configurazione del flusso e informazioni sul monitoraggio. 1. Per passare dalla modalità di capacità on demand a quella assegnata per un flusso di dati, scegli **Modifica modalità di capacità** nella scheda **Configurazione**. Per ulteriori informazioni, consulta [Scegli la modalità giusta per lo streaming](how-do-i-size-a-stream.md). **Importante** Per ogni flusso di dati nel tuo AWS account, puoi passare dalla modalità on-demand a quella fornita due volte nell'arco di 24 ore. 1. Per un flusso di dati con la modalità assegnata, per modificare il numero di partizioni, scegli **Modifica partizioni assegnate** nella scheda **Configurazione**, quindi inserisci un nuovo numero di partizioni. 1. Per abilitare la crittografia lato server di record di dati, selezionare **Edit (Modifica)** nella sezione **Server-side encryption (Crittografia lato server)**. Seleziona una chiave KMS da utilizzare come chiave master per la crittografia oppure utilizza la chiave master predefinita **aws/kinesis** gestita da Kinesis. Se abiliti la crittografia per uno stream e utilizzi la tua chiave AWS KMS master, assicurati che le applicazioni di produzione e consumo abbiano accesso alla chiave AWS KMS master che hai utilizzato. Per assegnare le autorizzazioni a un'applicazione e accedere a una chiave AWS KMS generata dall'utente, consultare [Autorizzazioni per utilizzare le chiavi KMS generate dall'utente](permissions-user-key-KMS.md). 1. Per modificare il periodo di ritenzione dei dati, selezionare **Edit (Modifica)** nella sezione **Data retention period (Periodo di ritenzione dei dati)** e immettere un nuovo periodo di ritenzione dei dati. 1. Se sono stati attivati i parametri personalizzati nell'account, selezionare **Edit (Modifica)** nella sezione **Shard level metrics (Parametri a livello di shard)** e specificare i parametri per il flusso. Per ulteriori informazioni, consulta [Monitora il servizio Amazon Kinesis Data Streams con Amazon CloudWatch](monitoring-with-cloudwatch.md). ## Eliminare con l’API Per aggiornare le informazioni sul flusso utilizzando l'API, consulta i seguenti metodi: + [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 il AWS CLI Per informazioni sull'aggiornamento di uno stream utilizzando il AWS CLI, consulta il riferimento alla [CLI di Kinesis](https://docs.aws.amazon.com/cli/latest/reference/kinesis/index.html). # Visualizzazione dell'elenco di flussi Gli stream sono limitati all' AWS account associato alle AWS credenziali utilizzate per creare un'istanza del client Kinesis Data Streams e anche alla regione specificata per il client. Un account AWS può avere molti flussi attivi simultaneamente. È possibile creare un elenco dei flussi nella console del flusso di dati Kinesis, oppure in modo programmatico. Il codice in questa sezione mostra come elencare tutti gli stream per il tuo account. AWS ``` ListStreamsRequest listStreamsRequest = new ListStreamsRequest(); listStreamsRequest.setLimit(20); ListStreamsResult listStreamsResult = client.listStreams(listStreamsRequest); List streamNames = listStreamsResult.getStreamNames(); ``` Questo esempio di codice crea prima una nuova istanza di `ListStreamsRequest` e chiama il suo metodo `setLimit` per specificare che un massimo di 20 flussi deve essere restituito per ogni chiamata a `listStreams`. Se non si specifica un valore per `setLimit`, il flusso di dati Kinesis restituisce un numero di flussi minore o uguale al numero contenuto nell'account. Il codice quindi passa `listStreamsRequest` al metodo `listStreams` del client. Il valore restituito `listStreams` viene memorizzato in un oggetto `ListStreamsResult`. Il codice chiama il metodo `getStreamNames` su questo oggetto e memorizza i nomi di flusso restituiti nell'elenco `streamNames`. Si noti che il flusso di dati Kinesis può restituire un numero di flussi minore di quanto indicato dal limite specificato anche se non ci sono più flussi oltre quelli nell'account e nella regione. Per verificare di avere recuperato tutti i flussi, utilizzare il metodo `getHasMoreStreams` come descritto nel prossimo esempio di codice. ``` while (listStreamsResult.getHasMoreStreams()) { if (streamNames.size() > 0) { listStreamsRequest.setExclusiveStartStreamName(streamNames.get(streamNames.size() - 1)); } listStreamsResult = client.listStreams(listStreamsRequest); streamNames.addAll(listStreamsResult.getStreamNames()); } ``` Questo codice chiama il metodo `getHasMoreStreams` su `listStreamsRequest` per controllare se sono disponibili flussi aggiuntivi oltre a quelli restituiti nella chiamata iniziale a `listStreams`. In tal caso, il codice chiama il metodo `setExclusiveStartStreamName` con il nome dell'ultimo flusso restituito nella precedente chiamata a `listStreams`. Il metodo `setExclusiveStartStreamName` fa si che la chiamata successiva a `listStreams` inizi dopo il flusso. Il gruppo di nomi di flusso restituiti dalla chiamata viene quindi aggiunto all'elenco `streamNames`. Questo processo continua finché tutti i nomi di flusso sono stati raccolti nell'elenco. I flussi restituiti da `listStreams` possono essere in uno dei seguenti stati: + `CREATING` + `ACTIVE` + `UPDATING` + `DELETING` È possibile controllare lo stato di un flusso utilizzando il metodo `describeStream`, come illustrato nella sezione precedente [Crea uno stream utilizzando il APIs](kinesis-using-sdk-java-create-stream.md). # Elenca i frammenti Un flusso di dati può avere una o più partizioni. Il metodo consigliato per elencare o recuperare gli shard da un flusso di dati consiste nell'utilizzare l'API. [ListShards](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_ListShards.html) L'esempio seguente mostra in che modo è possibile ottenere un elenco di partizioni di un flusso di dati. Per una descrizione completa dell'operazione principale utilizzata in questo esempio e di tutti i parametri che è possibile impostare per l'operazione, vedere. [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()); } } } ``` Per eseguire il codice di esempio precedente è possibile utilizzare un file POM come il seguente. ``` 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 l'`ListShards`API, puoi utilizzare il [ShardFilter](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_ShardFilter.html)parametro per filtrare la risposta dell'API. È possibile specificare un solo filtro alla volta. Se si utilizza il `ShardFilter` parametro quando si richiama l' ListShardsAPI, `Type` è la proprietà richiesta e deve essere specificata. Se si specificano i tipi `AT_TRIM_HORIZON`, `FROM_TRIM_HORIZON` o `AT_LATEST`, non è necessario specificare né la proprietà `ShardId` né la proprietà `Timestamp` facoltative. Se si specifica il tipo `AFTER_SHARD_ID`, sarà necessario fornire anche il valore per la proprietà `ShardId` facoltativa. La `ShardId` proprietà ha funzionalità identiche al `ExclusiveStartShardId` parametro dell' ListShards API. Quando viene specificata la proprietà `ShardId`, la risposta includerà le partizioni che iniziano con la partizione il cui ID segue immediatamente la `ShardId` assegnata. Se si specifica il tipo `AT_TIMESTAMP` o `FROM_TIMESTAMP_ID`, sarà necessario fornire anche il valore per la proprietà `Timestamp` facoltativa. Se si specifica il tipo `AT_TIMESTAMP`, verranno restituite tutte le partizioni aperte nel timestamp fornito. Se si specifica il tipo `FROM_TIMESTAMP`, verranno restituite tutte le partizioni dal timestamp fornito al TIP. **Importante** `DescribeStreamSummary`e `ListShard` APIs forniscono un modo più scalabile per recuperare informazioni sui flussi di dati. Più specificamente, le quote per l' DescribeStream API possono causare limitazioni. Per ulteriori informazioni, consulta [Quote e limiti](service-sizes-and-limits.md). Tieni inoltre presente che le `DescribeStream` quote sono condivise tra tutte le applicazioni che interagiscono con tutti i flussi di dati del tuo account. AWS Le quote per l' ListShards API, invece, sono specifiche per un singolo flusso di dati. Quindi non solo ottieni un TPS più elevato con l' ListShards API, ma l'azione si adatta meglio man mano che crei più flussi di dati. Ti consigliamo di migrare tutti i produttori e i consumatori che chiamano l' DescribeStream API per invocare invece the and the. DescribeStreamSummary ListShard APIs Per identificare questi produttori e consumatori, consigliamo di utilizzare Athena per analizzare i CloudTrail log man mano che gli user agent per KPL e KCL vengono acquisiti nelle chiamate 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 ``` Consigliamo inoltre di riconfigurare le integrazioni AWS Lambda e Amazon Firehose con Kinesis Data Streams che richiamano l'API in modo che le integrazioni richiamino `DescribeStream` invece e. `DescribeStreamSummary` `ListShards` In particolare, per AWS Lambda, è necessario aggiornare la mappatura delle sorgenti degli eventi. Per Amazon Firehose, le autorizzazioni IAM corrispondenti devono essere aggiornate in modo da includere l'autorizzazione `ListShards` IAM. # Eliminare uno stream È possibile eliminare un flusso con la console del flusso di dati Kinesis oppure in modo programmatico. Per eliminare un flusso in modo programmatico, utilizzare `DeleteStreamRequest`, come illustrato nel codice seguente. ``` DeleteStreamRequest deleteStreamRequest = new DeleteStreamRequest(); deleteStreamRequest.setStreamName(myStreamName); client.deleteStream(deleteStreamRequest); ``` Arrestare tutte le applicazioni che operano nel flusso prima di eliminarlo. Se un'applicazione tenta di intervenire su un flusso eliminato, riceve le eccezioni `ResourceNotFound`. Inoltre, se successivamente si crea un nuovo flusso con lo stesso nome del flusso precedente, e le applicazioni che operavano sul flusso precedente sono ancora in esecuzione, queste applicazioni potrebbero tentare di interagire con il nuovo flusso come se si trovasse nel flusso precedente, con risultati imprevedibili. # Condividi nuovamente uno stream **Importante** Puoi condividere nuovamente il tuo stream utilizzando l'API. [UpdateShardCount](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_UpdateShardCount.html) Altrimenti, è possibile continuare a eseguire suddivisioni e unioni come illustrato qui. Flusso di dati Amazon Kinesis supporta il *ripartizionamento*, che consente di regolare il numero di partizioni nel flusso in modo da adattarsi alle modifiche alla velocità del flusso di dati tramite lo streaming. Il resharding è considerata un'operazione avanzata. Se non hai mai utilizzato il flusso di dati Kinesis, torna a questo argomento dopo aver acquisito familiarità con tutti gli altri aspetti del flusso di dati Kinesis. Esistono due tipi di operazioni di resharding: suddivisione di shard e unione di shard. In una suddivisione di shard, si divide un singolo shard in due shard. In una unione di shard, si uniscono due hard in un singolo shard. Il resharding è sempre *a livello di coppia* nel senso che non è possibile suddividere più di due shard in un'unica operazione e non è possibile unire più di due shard in un'unica operazione. Lo shard o la coppia di shard su cui agisce l'operazione di resharding viene definito shard *padre*. Lo shard o la coppia di shard, risultato dell'operazione di resharding, viene definito shard *figlio*. Il frazionamento aumenta il numero di shard nel tuo flusso e pertanto aumenta la capacità di dati del flusso. Poiché si riceverà un addebito per ogni shard, la suddivisione aumenta il costo del flusso. Analogamente, l'unione riduce il numero di shard nel tuo flusso e pertanto diminuisce la capacità, quindi il costo, dei dati del flusso. Il resharding viene in genere eseguito da un'applicazione di amministrazione che è distinta dall'applicazione producer (put) e dall'applicazione consumer (get). Tale applicazione amministrativa monitora le prestazioni complessive dello stream in base ai parametri forniti da Amazon CloudWatch o in base ai parametri raccolti dai produttori e dai consumatori. L'applicazione amministrativa necessita inoltre di un set più ampio di autorizzazioni IAM rispetto ai consumatori o ai produttori, poiché i consumatori e i produttori di solito non dovrebbero aver bisogno di accedere a ciò che viene utilizzato per il resharding. APIs Per ulteriori informazioni sulle autorizzazioni IAM per il flusso di dati Kinesis, consulta [Controllo dell'accesso alle risorse Amazon Kinesis Data Streams tramite IAM](controlling-access.md). Per ulteriori informazioni sul ripartizionamento, consulta [Come posso modificare il numero di partizioni aperte nel flusso di dati Kinesis?](https://aws.amazon.com/premiumsupport/knowledge-center/kinesis-data-streams-open-shards/) **Topics** + [Decidi una strategia per il resharding](kinesis-using-sdk-java-resharding-strategies.md) + [Dividere un frammento](kinesis-using-sdk-java-resharding-split.md) + [Unisci due frammenti](kinesis-using-sdk-java-resharding-merge.md) + [Completa l'azione di ricondivisione](kinesis-using-sdk-java-after-resharding.md) # Decidi una strategia per il resharding Lo scopo del ripartizionamento in Flusso di dati Amazon Kinesis è quello di consentire al flusso di adattarsi ai cambiamenti alla velocità del flusso di dati. Si esegue la suddivisione in shard per aumentare la capacità (e i costi) del flusso. Si esegue l'unione dei shard per ridurre i costi (e la capacità) del flusso. Un approccio al ripartizionamento potrebbe essere la suddivisione di ogni partizione nel flusso; tale operazione raddoppierebbe la capacità del flusso. Tuttavia, questo potrebbe fornire più capacità aggiuntiva a quella effettivamente necessaria e, di conseguenza, causare spese superflue. È inoltre possibile utilizzare i parametri per determinare quali sono le partizioni *calde* o *fredde*, ovvero le partizioni che ricevono più dati o meno dati del previsto. È possibile scegliere di suddividere gli shard hot per aumentare la capacità per le chiavi hash indirizzate a questi shard. Analogamente, è possibile unire shard cold per sfruttare al meglio la loro capacità inutilizzata. Puoi ottenere alcuni dati sulle prestazioni del tuo stream dai CloudWatch parametri Amazon pubblicati da Kinesis Data Streams. Tuttavia, è anche possibile raccogliere alcuni parametri per i tuoi flussi. Un approccio consiste nel registrare i valori chiave hash generati dalle chiavi di partizione per i tuoi record di dati. Tenere presente che una chiave di partizione è stata specificata nel momento in cui il record è stato aggiunto al flusso. ``` putRecordRequest.setPartitionKey( String.format( "myPartitionKey" ) ); ``` Kinesis Data [MD5](http://en.wikipedia.org/wiki/MD5)Streams utilizza per calcolare la chiave hash dalla chiave di partizione. Poiché si specifica la chiave di partizione per il record, è possibile utilizzarla per calcolare il valore della chiave hash MD5 per quel record e registrarlo. Puoi anche registrare gli IDs shard a cui sono assegnati i tuoi record di dati. L'ID shard è disponibile utilizzando il metodo `getShardId` dell'oggetto `putRecordResults` restituito dal metodo `putRecords` e l'oggetto `putRecordResult` restituito dal metodo `putRecord`. ``` String shardId = putRecordResult.getShardId(); ``` Con i valori dello shard IDs e delle chiavi hash, puoi determinare quali shard e hash key ricevono più o meno traffico. Quindi è possibile utilizzare il resharding per fornire più o meno capacità, a seconda della chiave. # Dividere un frammento Per suddividere una partizione in Flusso di dati Amazon Kinesis, è necessario specificare il modo in cui i valori della chiave hash devono essere ridistribuiti dalla partizione principale alle partizioni secondarie. Quando si aggiunge un record di dati al flusso, viene assegnato a uno shard in base al valore chiave hash. Il valore della chiave hash è l'[MD5](http://en.wikipedia.org/wiki/MD5)hash della chiave di partizione specificata per il record di dati nel momento in cui aggiungi il record di dati allo stream. I record di dati che hanno la stessa chiave di partizione, hanno anche lo stesso valore chiave hash. I possibili valori chiave hash per un determinato shard costituiscono un set ordinato e contiguo di numeri interi non negativi. Questo intervallo di possibili valori chiave hash è determinato da quanto segue: ``` shard.getHashKeyRange().getStartingHashKey(); shard.getHashKeyRange().getEndingHashKey(); ``` Quando si suddivide lo shard, è necessario specificare un valore in questo intervallo. Questo valore chiave hash e tutti i valori chiave hash più alti sono distribuiti a uno shard figlio. Tutti i valori chiave hash inferiori vengono distribuiti ad un altro shard figlio. Il seguente codice illustra un'operazione di suddivisione shard che ridistribuisce le chiavi hash in modo uniforme tra ciascuno degli shard figlio, essenzialmente suddividendo lo shard padre a metà. Questo è solo uno dei modi possibili di ripartire lo shard padre. È possibile, ad esempio, suddividere lo shard in modo che il terzo inferiore delle chiavi dal padre vada ad uno shard figlio e i due terzi superiori delle chiavi vadano all'altro shard figlio. Tuttavia, per molte applicazioni, la suddivisione degli shard a metà è un approccio efficace. Il codice presuppone che `myStreamName` contiene il nome del flusso e la variabile oggetto `shard` contiene lo shard da suddividere. Per cominciare, creare un nuovo oggetto `splitShardRequest` e impostare il nome del flusso e l'ID shard. ``` SplitShardRequest splitShardRequest = new SplitShardRequest(); splitShardRequest.setStreamName(myStreamName); splitShardRequest.setShardToSplit(shard.getShardId()); ``` Determinare il valore di chiave hash che si trova a metà tra i valori minimo e massimo contenuti nello shard. Questo è il valore chiave hash di partenza per lo shard figlio che conterrà la metà superiore delle chiavi hash dallo shard padre. Specificare questo valore nel metodo `setNewStartingHashKey`. È necessario specificare solo questo valore. ll flusso di dati Kinesis distribuisce automaticamente le chiavi hash sotto questo valore all'altra partizione secondaria creata dalla suddivisione. L'ultima fase è la chiamata del metodo `splitShard` sul client del flusso di dati Kinesis. ``` 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); ``` La prima fase dopo questa procedura è illustrata in [Attendi che uno stream torni ad essere attivo](kinesis-using-sdk-java-after-resharding.md#kinesis-using-sdk-java-resharding-wait-until-active). # Unisci due frammenti Un'operazione di unione shard prende due shard specificati e li combina in un singolo shard. Dopo l'unione, il singolo shard figlio riceve i dati per tutti i valori chiave hash coperti dai due shard padre. **Adiacenza di shard** Per unire due shard, gli shard devono essere *adiacenti*. Due shard sono considerati adiacenti se l'unione degli intervalli chiave hash per i due shard formano un set contiguo senza spazi. Ad esempio, supponiamo di avere due shard, uno con una gamma di chiavi hash di 276...381 e l'altro con una gamma di chiavi hash di 382...454. È possibile unire questi due shard in un singolo shard che avrebbe così una gamma di chiavi hash 276... 454. Per fare un altro esempio, supponiamo di avere due shard, uno con una gamma di chiavi hash di 276...381 e l'altro con una gamma di chiavi hash di 455...560. In questo caso non è possibile unire i due shard, poiché ci sarebbero uno o più shard tra questi due a copertura della gamma 382...454. L'insieme di tutti gli `OPEN` shard in un flusso, come gruppo, copre sempre l'intera gamma di valori delle chiavi hash. MD5 Per ulteriori informazioni sugli stati degli shard, come ad esempio `CLOSED`, vedere [Prendi in considerazione il routing dei dati, la persistenza dei dati e lo stato dello shard dopo una reshard](kinesis-using-sdk-java-after-resharding.md#kinesis-using-sdk-java-resharding-data-routing). Per identificare gli shard candidati per l'unione, è necessario filtrare tutti gli shard che sono in uno stato `CLOSED`. Le partizioni con stato `OPEN`, ossia non `CLOSED`, hanno un numero di sequenza finale pari a `null`. È possibile testare il numero di sequenza finale per un shard utilizzando: ``` if( null == shard.getSequenceNumberRange().getEndingSequenceNumber() ) { // Shard is OPEN, so it is a possible candidate to be merged. } ``` Dopo aver filtrato gli shard chiusi, ordinare i restanti shard dal valore chiave hash più alto supportato per ogni shard. È possibile recuperare questo valore utilizzando: ``` shard.getHashKeyRange().getEndingHashKey(); ``` Se due shard sono adiacenti in questo elenco filtrato e ordinato, allora possono essere uniti. **Codice dell'operazione di unione** Il seguente codice unisce due shard. Il codice presuppone che `myStreamName` contiene il nome del flusso e che le variabili oggetto `shard1` e `shard2` contengono due shard adiacenti da unire. Per l'operazione di unione, iniziare creando istanze di un nuovo oggetto `mergeShardsRequest`. Specificare il nome del flusso con il metodo `setStreamName`. Quindi specificare i due shard da unire utilizzando i metodi `setShardToMerge` e `setAdjacentShardToMerge`. Infine, chiama il metodo `mergeShards` sul client del flusso di dati Kinesis per eseguire l'operazione. ``` MergeShardsRequest mergeShardsRequest = new MergeShardsRequest(); mergeShardsRequest.setStreamName(myStreamName); mergeShardsRequest.setShardToMerge(shard1.getShardId()); mergeShardsRequest.setAdjacentShardToMerge(shard2.getShardId()); client.mergeShards(mergeShardsRequest); ``` La prima fase dopo questa procedura è illustrata in [Attendi che uno stream torni ad essere attivo](kinesis-using-sdk-java-after-resharding.md#kinesis-using-sdk-java-resharding-wait-until-active). # Completa l'azione di ricondivisione Dopo qualsiasi tipo di procedura di ripartizionamento in Flusso di dati Amazon Kinesis e prima della ripresa dell'elaborazione record normale, sono necessarie altre procedure e considerazioni. Le sezioni seguenti descrivono queste procedure. **Topics** + [Attendi che uno stream torni ad essere attivo](#kinesis-using-sdk-java-resharding-wait-until-active) + [Prendi in considerazione il routing dei dati, la persistenza dei dati e lo stato dello shard dopo una reshard](#kinesis-using-sdk-java-resharding-data-routing) ## Attendi che uno stream torni ad essere attivo Dopo aver chiamato un'operazione di resharding, `splitShard` o`mergeShards`, devi attendere che lo stream diventi nuovamente attivo. Il codice da usare è lo stesso di quando si attende che il flusso diventi attivo dopo [la creazione di un flusso](kinesis-using-sdk-java-create-stream.md). Il codice è il seguente: ``` 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" ); } ``` ## Prendi in considerazione il routing dei dati, la persistenza dei dati e lo stato dello shard dopo una reshard Kinesis Data Streams è un servizio di streaming di dati in tempo reale. Le tue applicazioni devono presupporre che i dati fluiscano continuamente attraverso gli shard del tuo stream. Quando si esegue il resharding, i record di dati che scorrevano verso gli shard padre vengono instradati agli shard figlio in base ai valori chiave hash che sono mappati dalle chiavi di partizione del record di dati. Tuttavia, qualsiasi record di dati presente negli shard padre prima del resharding rimane in tali shard. Gli shard principali non scompaiono quando si verifica un nuovo shard. Rimangono con i dati contenuti prima del resharding. I record di dati nelle partizioni principali sono accessibili tramite le operazioni [`getShardIterator` e `getRecords`](developing-consumers-with-sdk.md#kinesis-using-sdk-java-get-data) nelle API del flusso di dati Kinesis oppure tramite la Kinesis Client Library. **Nota** I record di dati sono accessibili dal momento in cui sono stati aggiunti al flusso fino al periodo di conservazione attuale. Questo vale indipendentemente da eventuali modifiche apportate agli shard nel flusso durante tale periodo di tempo. Per altre informazioni sul periodo di conservazione di un flusso, vedere [Modifica il periodo di conservazione dei dati](kinesis-extended-retention.md). Nel processo di resharding, uno shard padre passa dallo stato `OPEN` allo stato `CLOSED` allo stato `EXPIRED`. + **OPEN**: prima di un'operazione di resharding, uno shard padre è nello stato `OPEN`, il che significa che i record di dati possono essere sia aggiunti che recuperati dallo shard. + **CLOSED**: dopo un'operazione di resharding, lo shard padre passa allo stato `CLOSED`. Ciò significa che i record di dati non sono più aggiunti allo shard. I record di dati che dovevano essere aggiunti a questo shard sono ora aggiunti allo shard figlio. Tuttavia, i record di dati possono essere ancora recuperati dallo shard per un periodo di tempo limitato. + **EXPIRED**: dopo la scadenza del periodo di conservazione del flusso, tutti i record di dati nello shard padre sono scaduti e non sono più accessibili. In questo momento, lo stesso shard passa a uno stato `EXPIRED`. Le chiamate a `getStreamDescription().getShards` per enumerare gli shard nel flusso non includono gli shard `EXPIRED` nell'elenco degli shard restituiti. Per altre informazioni sul periodo di conservazione di un flusso, vedere [Modifica il periodo di conservazione dei dati](kinesis-extended-retention.md). Dopo che è stato eseguito il resharding e il flusso è nuovamente nello stato `ACTIVE`, è possibile iniziare immediatamente a leggere i dati dagli shard figlio. Tuttavia, gli shard principali che rimangono dopo la reshard potrebbero ancora contenere dati che non hai ancora letto e che sono stati aggiunti allo stream prima del reshard. Se si leggono i dati dagli shard figlio prima di aver letto tutti i dati dagli shard padre, è possibile leggere i dati per una determinata chiave hash che non rientra nell'ordine fornito dai numeri di sequenza dei record di dati. Pertanto, presupponendo che l'ordine dei dati è importante, è necessario, dopo il resharding, continuare sempre a leggere i dati dagli shard padre finché non è scaduto. Solo dopo si può iniziare a leggere i dati dagli shard figlio. Quando `getRecordsResult.getNextShardIterator` restituisce `null`, indica che sono stati letti tutti i dati nello shard padre. # Modifica il periodo di conservazione dei dati Flusso di dati Amazon Kinesis supporta le modifiche al periodo di conservazione dei record di dati del tuo flusso di dati. Un flusso di dati Kinesis è una sequenza ordinata di record di dati che deve essere utilizzata per la scrittura e la lettura in tempo reale. I record di dati vengono quindi memorizzati negli shard del flusso temporaneamente. Il periodo di tempo dall'aggiunta di un record all'inaccessibilità viene chiamato il *periodo di conservazione*. Un flusso di dati Kinesis archivia i record da 24 ore per impostazione predefinita, fino a 8.760 ore (365 giorni). È possibile aggiornare il periodo di conservazione tramite la console Kinesis Data Streams o [IncreaseStreamRetentionPeriod](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_IncreaseStreamRetentionPeriod.html)utilizzando e le [DecreaseStreamRetentionPeriod](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_DecreaseStreamRetentionPeriod.html)operazioni. Con la console del flusso di dati Kinesis, puoi modificare in blocco il periodo di conservazione di più di un flusso di dati contemporaneamente. È possibile aumentare il periodo di conservazione fino a un massimo di 8760 ore (365 giorni) utilizzando l'[IncreaseStreamRetentionPeriod](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_IncreaseStreamRetentionPeriod.html)operazione o la console Kinesis Data Streams. È possibile ridurre il periodo di conservazione fino a un minimo di 24 ore utilizzando l'[DecreaseStreamRetentionPeriod](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_DecreaseStreamRetentionPeriod.html)operazione o la console Kinesis Data Streams. La sintassi di richiesta per entrambe le operazioni include il nome del flusso e il periodo di conservazione in ore. Infine, è possibile controllare l'attuale periodo di conservazione di un flusso chiamando l'operazione [DescribeStream](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_DescribeStream.html). Di seguito è riportato un esempio di modifica del periodo di conservazione utilizzando la AWS CLI: ``` aws kinesis increase-stream-retention-period --stream-name retentionPeriodDemo --retention-period-hours 72 ``` Il flusso di dati Kinesis smette di rendere inaccessibili i record al vecchio periodo di conservazione entro alcuni minuti dall'aumentare del periodo di conservazione. Ad esempio, modificando il periodo di conservazione da 24 ore a 48 ore significa che i record aggiunti al flusso 23 ore 55 minuti prima sono ancora disponibili dopo 24 ore. Il flusso di dati Kinesis quasi immediatamente rende i record più vecchi del nuovo periodo di conservazione inaccessibili diminuendo il periodo di conservazione. Pertanto, fare attenzione nel richiamare l'operazione [DecreaseStreamRetentionPeriod](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_DecreaseStreamRetentionPeriod.html). Impostare il periodo di conservazione dei dati per assicurarsi che i consumatori siano in grado di leggere i dati prima della scadenza, se sorgono problemi. È consigliabile valutare attentamente tutte le possibilità, ad esempio un problema con la logica di elaborazione dei record o una dipendenza downstream inattiva per un lungo periodo di tempo. Il periodo di conservazione deve essere considerato come una rete di sicurezza che consente più tempo ai consumatori di dati per il recupero. Le operazioni API del periodo di conservazione consentono di eseguire questa operazione in modo proattivo o di rispondere a eventi operativi in modo reattivo. Sono applicabili costi aggiuntivi per flussi con un periodo di conservazione impostato sopra le 24 ore. Per ulteriori informazioni, consulta [Prezzi dei flussi di dati per Amazon Kinesis](https://aws.amazon.com/kinesis/data-streams/pricing/). # Etichetta le tue risorse Amazon Kinesis Data Streams *Puoi assegnare i tuoi metadati agli stream e ai fan-out consumer avanzati che crei in Amazon Kinesis Data Streams sotto forma di tag.* Un tag è un valore-chiave che definisci per un flusso. L'uso dei tag è un modo semplice ma efficace per gestire le AWS risorse e organizzare i dati, inclusi i dati di fatturazione. **Topics** + [Rivedi le nozioni di base sui tag](#tagging-basics) + [Tieni traccia dei costi utilizzando i tag](#tagging-billing) + [Comprendi le restrizioni relative ai tag](#tagging-restrictions) + [Etichetta i flussi utilizzando la console Kinesis Data Streams](#tagging-console) + [Contrassegna i flussi utilizzando il AWS CLI](#tagging-cli) + [Etichetta i flussi utilizzando Kinesis Data Streams APIs](#tagging-api) + [Tagga i consumatori utilizzando il AWS CLI](#tagging-consumers-cli) + [Tagga i consumatori utilizzando Kinesis Data Streams APIs](#tagging-consumers-api) ## Rivedi le nozioni di base sui tag Le risorse Kinesis Data Streams che puoi etichettare includono flussi di dati e consumatori fan-out avanzati. Utilizzi la AWS CLI console Kinesis Data Streams o l'API Kinesis Data Streams per completare le seguenti attività: + Crea una risorsa con tag + Aggiungere tag a una risorsa + Elenca i tag per le tue risorse + Rimuovi i tag da una risorsa **Nota** Non puoi applicare tag ai consumatori con fan-out avanzato utilizzando la console Kinesis Data Streams. Per applicare i tag ai consumatori, usa l' AWS CLI API Kinesis Data Streams. Puoi utilizzare i tag per categorizzare le risorse . Ad esempio, puoi categorizzarle in base a scopo, proprietario o ambiente. Poiché definisci una chiave e un valore per ogni tag, puoi creare un set di categorie personalizzate per soddisfare esigenze specifiche. Ad esempio, potresti definire un set di tag che ti aiuti a tenere traccia delle risorse per proprietario e applicazione associata. Di seguito sono riportati vari esempi di tag: + Progetto: nome del progetto + Proprietario: nome + Scopo: test di carico + Applicazione: nome dell'applicazione + Ambiente: produzione **Importante** Per aggiungere tag durante la creazione di uno stream, devi includere le `kinesis:AddTagsToStream` autorizzazioni `kinesis:CreateStream` e le relative autorizzazioni. **Non puoi utilizzare l'**`kinesis:TagResource`autorizzazione per taggare gli stream durante la creazione. Per aggiungere tag durante la registrazione dei consumatori, devi includere le `kinesis:RegisterStreamConsumer` autorizzazioni `kinesis:TagResource` e. ## Tieni traccia dei costi utilizzando i tag Puoi utilizzare i tag per classificare e tenere traccia AWS dei costi. Quando applichi i tag alle tue risorse Kinesis Data Streams AWS , il report sull'allocazione dei costi include l'utilizzo e i costi aggregati per tag. Puoi applicare tag che rappresentano categorie aziendali, come centri di costo, nomi delle applicazioni o proprietari, per organizzare i costi su più servizi. Per ulteriori informazioni, consulta [Utilizzo dei tag per l'allocazione dei costi ai fini dei report di fatturazione personalizzati](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html) nella *AWS Billing User Guide (Guida per l'utente di Amazon API Gateway)*. ## Comprendi le restrizioni relative ai tag Ai tag si applicano le limitazioni seguenti: **Limitazioni di base** + Il numero massimo di tag per ogni risorsa è 50. + Per le chiavi e i valori dei tag viene fatta la distinzione tra maiuscole e minuscole. + Non è possibile cambiare o modificare i tag di una risorsa eliminata. **Limitazioni applicate alle chiavi di tag** + Ogni chiave di tag deve essere univoca. Se aggiungi un tag con una chiave già in uso, il nuovo tag sovrascrive la coppia chiave-valore esistente. + Non puoi iniziare una chiave di tag con `aws:` perché questo prefisso è riservato all'uso di AWS. AWS crea tag che iniziano con questo prefisso per tuo conto, ma non puoi modificarli o eliminarli. + Le chiavi di tag devono avere una lunghezza compresa tra 1 e 128 caratteri Unicode. + Le chiavi di tag devono contenere i seguenti caratteri: lettere Unicode, cifre, spazio e i seguenti caratteri speciali: `_ . / = + - @`. **Limitazioni applicate ai valori dei tag** + I valori dei tag devono avere una lunghezza compresa tra 0 e 255 caratteri Unicode. + I valori dei tag possono essere vuoti. In caso contrario, devono contenere i seguenti caratteri: lettere Unicode, cifre, spazio e i seguenti caratteri speciali: `_ . / = + - @`. ## Etichetta i flussi utilizzando la console Kinesis Data Streams Puoi aggiungere, aggiornare, elencare e rimuovere tag dai tuoi stream utilizzando la console Kinesis Data Streams. **Visualizzazione di tag per un flusso** 1. [Accedi Console di gestione AWS e apri la console Kinesis all'indirizzo https://console.aws.amazon.com /kinesis.](https://console.aws.amazon.com/kinesis) 1. **Nel riquadro di navigazione a sinistra, scegli Flussi di dati.** 1. Nella pagina **Flussi di dati**, scegli lo stream a cui vuoi taggare. 1. Nella pagina dei dettagli dello stream, scegli **Configurazione**. 1. Nella sezione **Tag**, visualizza i tag applicati allo stream. **Per creare un flusso di dati con un tag** 1. Apri la console del flusso di dati Kinesis. 1. Nel riquadro di navigazione a sinistra, scegli **Flussi di dati**. 1. Selezionare **Create data stream (Crea flusso di dati)**. 1. Nella pagina **Crea flusso di dati**, inserisci un nome per il tuo flusso di dati. 1. Per la **capacità del flusso di dati**, scegli la modalità di capacità **On-demand** o **Provisioned**. Per ulteriori informazioni sulle modalità di capacità, vedere. [Scegli la modalità giusta per lo streaming](how-do-i-size-a-stream.md) 1. Nella sezione **Tag**, effettuate le seguenti operazioni: 1. Scegli **Aggiungi nuovo tag**. 1. Per **Chiave**, inserite il tag e, facoltativamente, specificate un **valore nel campo Valore**. Se visualizzi un errore, significa che la chiave o il valore del tag che hai specificato non soddisfano le restrizioni relative ai tag. Per ulteriori informazioni, consulta [Comprendi le restrizioni relative ai tag](#tagging-restrictions). 1. Selezionare **Create data stream (Crea flusso di dati)**. **Per aggiungere o aggiornare un tag in uno stream** 1. Apri la console del flusso di dati Kinesis. 1. Nel riquadro di navigazione a sinistra, scegli **Flussi di dati**. 1. Nella pagina **Flussi di dati**, scegli lo stream a cui desideri aggiungere o aggiornare i tag. 1. Nella pagina dei dettagli dello stream, scegli **Configurazione**. 1. Nella sezione **Tag** scegli **Gestisci tag**. 1. In **Tag**, esegui una delle seguenti operazioni: + Per aggiungere un nuovo tag, scegli **Aggiungi nuovo tag**, quindi inserisci i dati **Chiave** e **Valore** del tag. Ripetere questa operazione tutte le volte necessarie. Il numero massimo di tag che puoi aggiungere per ogni stream è 50. + Per aggiornare un tag esistente, inserisci un nuovo valore di tag nel campo **Valore** della **chiave** di quel tag. Se visualizzi un errore, la chiave o il valore del tag che hai specificato non soddisfa le restrizioni del tag. Per ulteriori informazioni, consulta [Comprendi le restrizioni relative ai tag](#tagging-restrictions). 1. Scegli **Salva modifiche**. **Rimozione di un tag da un flusso** 1. Apri la console del flusso di dati Kinesis. 1. Nel riquadro di navigazione a sinistra, scegli **Flussi di dati**. 1. Nella pagina **Flussi di dati**, scegli il flusso da cui desideri rimuovere i tag. 1. Nella pagina dei dettagli dello stream, scegli **Configurazione**. 1. Nella sezione **Tag** scegli **Gestisci tag**. 1. Trova la coppia di tag **Chiave** e **Valore** che desideri rimuovere. Quindi scegli **Rimuovi**. 1. Scegli **Save changes** (Salva modifiche). ## Contrassegna i flussi utilizzando il AWS CLI Puoi aggiungere, elencare e rimuovere tag dai tuoi stream utilizzando. AWS CLI Per alcuni esempi, consultare la seguente documentazione. [crea-stream](https://docs.aws.amazon.com/cli/latest/reference/kinesis/create-stream.html) Crea uno stream con tag. [add-tags-to-stream](https://docs.aws.amazon.com/cli/latest/reference/kinesis/add-tags-to-stream.html) Aggiunge o aggiorna i tag per il flusso specificato. [list-tags-for-stream](https://docs.aws.amazon.com/cli/latest/reference/kinesis/list-tags-for-stream.html) Elenca i tag per il flusso specificato. [remove-tags-from-stream](https://docs.aws.amazon.com/cli/latest/reference/kinesis/remove-tags-from-stream.html) Rimuove i tag dal flusso specificato. ## Etichetta i flussi utilizzando Kinesis Data Streams APIs Puoi aggiungere, elencare e rimuovere tag dai tuoi stream utilizzando Kinesis Data Streams. APIs Per alcuni esempi, consultare la seguente documentazione: [CreateStream](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_CreateStream.html) Crea uno stream con tag. [AddTagsToStream](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_AddTagsToStream.html) Aggiunge o aggiorna i tag per il flusso specificato. [ListTagsForStream](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_ListTagsForStream.html) Elenca i tag per il flusso specificato. [RemoveTagsFromStream](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_RemoveTagsFromStream.html) Rimuove i tag dal flusso specificato. ## Tagga i consumatori utilizzando il AWS CLI Puoi aggiungere, elencare e rimuovere tag sui tuoi consumatori utilizzando il AWS CLI. Per alcuni esempi, consultare la seguente documentazione: [register-stream-consumer](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kinesis/register-stream-consumer.html) Registra un consumatore per un flusso di dati Kinesis con tag. [tag-resource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kinesis/tag-resource.html) Aggiunge o aggiorna i tag per la risorsa Kinesis specificata. [list-tags-for-resource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kinesis/list-tags-for-resource.html) Elenca i tag per la risorsa Kinesis specificata. [untag-resource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kinesis/untag-resource.html) Rimuove i tag dalla risorsa Kinesis specificata. ## Tagga i consumatori utilizzando Kinesis Data Streams APIs Puoi aggiungere, elencare e rimuovere tag sui tuoi consumatori utilizzando Kinesis APIs Data Streams. Per alcuni esempi, consultare la seguente documentazione: [RegisterStreamConsumer](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_RegisterStreamConsumer.html) Registra un consumatore per un flusso di dati Kinesis con tag. [TagResource](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_TagResource.html) Aggiunge o aggiorna i tag per la risorsa Kinesis specificata. [ListTagsForResource](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_ListTagsForResource.html) Elenca i tag per la risorsa Kinesis specificata. [UntagResource](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_UntagResource.html) Rimuove i tag dalla risorsa Kinesis specificata. # Gestisci dischi di grandi dimensioni Amazon Kinesis Data Streams supporta record fino a 10 MiBs mebibyte (). Questa funzionalità è consigliata per l'elaborazione di payload di dati intermittenti che superano il limite predefinito di dimensione del record di 1 MiB. La dimensione massima di registrazione predefinita per gli stream esistenti e quelli appena creati è impostata su 1 MiB. Questa funzionalità offre vantaggi alle applicazioni Internet of Things (IoT), alle pipeline di acquisizione dei dati di modifica (CDC) e ai flussi di lavoro di apprendimento automatico che richiedono l'elaborazione di payload di dati occasionali più grandi. Per iniziare a utilizzare record di grandi dimensioni nel tuo stream, aggiorna il limite massimo di dimensione dei record dello stream. **Importante** Il limite di velocità effettiva dei singoli shard, pari a 1 MB/s per le scritture e 2 MB/s per le letture, rimane invariato e supporta record di dimensioni maggiori. Kinesis Data Streams è progettato per ospitare record intermittenti di grandi dimensioni insieme a un traffico di record di base inferiore o uguale a 1 MiB. Non è progettato per consentire l'ingestione sostenuta di record di grandi dimensioni e ad alto volume. ## Aggiorna lo stream per utilizzare record di grandi dimensioni **Per elaborare record di grandi dimensioni con Kinesis Data Streams** 1. Accedere alla console Kinesis Data Streams. 1. Seleziona il tuo stream e vai alla scheda **Configurazione**. 1. Fai clic su **Modifica**, che si trova accanto a **Dimensione massima del record**. 1. Imposta la dimensione massima del record (fino a 10 MiB). 1. Salvare le modifiche. Questa impostazione regola solo la dimensione massima del record per questo flusso di dati Kinesis. Prima di aumentare questo limite, verifica che tutte le applicazioni downstream siano in grado di gestire record più grandi. Puoi anche aggiornare questa impostazione utilizzando la AWS CLI: ``` aws kinesis update-max-record-size \ --stream-arn \ --max-record-size-in-ki-b 5000 ``` ## Ottimizza le prestazioni dello streaming con record di grandi dimensioni Si consiglia di mantenere record di grandi dimensioni, inferiori al 2% del traffico complessivo. In uno stream, ogni shard ha una capacità di throughput di 1 MiB al secondo. Per ospitare record di grandi dimensioni, Kinesis Data trasmette fino a 10 raffiche MiBs, con una media di 1 MiB al secondo. Questa capacità di supportare record di grandi dimensioni viene continuamente inserita nel flusso. La velocità di ricarica dipende dalla dimensione dei dischi di grandi dimensioni e dalla dimensione del record di base. Per ottenere risultati ottimali, utilizzate una chiave di partizione distribuita uniformemente. Per ulteriori informazioni sulla scalabilità on-demand di Kinesis, consulta Funzionalità e casi d'uso [della modalità On-demand](how-do-i-size-a-stream.html#ondemandmode). ## Riduci le limitazioni con dischi di grandi dimensioni **Per mitigare la limitazione** 1. Implementa la logica dei tentativi con back-off esponenziale nella tua applicazione di produzione. 1. Usa chiavi di partizione randomizzate per distribuire record di grandi dimensioni tra gli shard disponibili. 1. Archivia i payload in Amazon S3 e invia solo riferimenti di metadati allo stream per flussi continui di record di grandi dimensioni. Per ulteriori informazioni, consulta [Elaborazione di record di grandi dimensioni con Amazon Kinesis Data Streams](https://aws.amazon.com/blogs/big-data/processing-large-records-with-amazon-kinesis-data-streams/). ## Gestisci record di grandi dimensioni utilizzando Kinesis Data Streams APIs Il supporto per record di grandi dimensioni introduce una nuova API e aggiorna due piani di controllo esistenti APIs per gestire record fino a 10. MiBs API per modificare la dimensione dei record: + `UpdateMaxRecordSize`: configura il limite massimo di dimensione dei record per gli stream esistenti fino a 10. MiBs Aggiornamenti a quelli esistenti: APIs + `CreateStream`: aggiunge il `MaxRecordSizeInKiB` parametro opzionale per impostare i limiti di dimensione dei record durante la creazione dello stream. + `DescribeStreamSummary`: restituisce il `MaxRecordSizeInKiB` campo per mostrare la configurazione corrente dello stream. Tutti gli APIs elenchi mantengono la compatibilità con le versioni precedenti per gli stream esistenti. Per la documentazione completa sulle API, consulta il riferimento alle API del servizio [Amazon Kinesis Data Streams](https://docs.aws.amazon.com/kinesis/latest/APIReference/Welcome.html). ## AWS componenti compatibili con record di grandi dimensioni I seguenti AWS componenti sono compatibili con dischi di grandi dimensioni: | Componente | Description | | --- | --- | | AWS SDK | AWS L'SDK supporta la gestione di record di grandi dimensioni. Puoi aggiornare la dimensione massima di registrazione del tuo stream fino a 10 MiB utilizzando i metodi disponibili in. AWS SDKs Per ulteriori informazioni, consulta [Usare questo servizio con un SDK](https://docs.aws.amazon.com/streams/latest/dev/sdk-general-information-section.html). AWS | | Libreria per consumatori Kinesis (KCL) | A partire dalla versione 2.x, KCL supporta la gestione di record di grandi dimensioni. Per utilizzare il supporto per record `maxRecordSize` di grandi dimensioni, aggiorna il tuo stream e usa KCL. Per ulteriori informazioni, consulta [Utilizzare la libreria client Kinesis](https://docs.aws.amazon.com/streams/latest/dev/kcl.html). | | Libreria Kinesis Producer (KPL) | A partire dalla versione 1.0.5, KPL supporta la gestione di record di grandi dimensioni. Per utilizzare il supporto per record maxRecordSize di grandi dimensioni, aggiorna il tuo stream e usa KPL. Per ulteriori informazioni, consulta [Sviluppare produttori utilizzando 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 supporta la gestione di record di grandi dimensioni fino al limite di Kinesis Data Streams (10). MiBs Per utilizzare il supporto per record di grandi dimensioni, usa la funzione. `readStream` Per ulteriori informazioni, consulta l'integrazione tra [Amazon EMR e Amazon Kinesis](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-kinesis.html). | | Amazon Data Firehose | Se utilizzato con Kinesis Data Streams, il comportamento di Amazon Data Firehose con record di grandi dimensioni dipende dalla destinazione di consegna: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/streams/latest/dev/large-records.html) Per le applicazioni che richiedono la consegna a Snowflake o Redshift con record di grandi dimensioni, invia prima i dati ad Amazon S3. Successivamente, utilizza i processi Extract, Transform, Load (ETL) per caricare i dati. Per tutte le altre destinazioni, testate il comportamento con record di grandi dimensioni in un proof-of-concept ambiente prima di passare all'utilizzo in produzione. La gestione di record di grandi dimensioni varia in base alla destinazione. | | AWS Lambda | AWS Lambda supporta carichi utili fino a 6 MiBs. Questo limite include il payload Kinesis convertito in codifica base-64 e i metadati associati a Event Source Mapping (ESM). Per i record inferiori a 6 MiBs, Lambda li elabora utilizzando ESM senza richiedere alcuna configurazione aggiuntiva. Per i record superiori a 6 MiBs, Lambda li elabora utilizzando una destinazione in caso di errore. È necessario configurare una destinazione in caso di errore utilizzando ESM per gestire i record che superano i limiti di elaborazione di Lambda. Ogni evento inviato alla destinazione in caso di errore è un documento JSON che contiene metadati relativi alla chiamata non riuscita. Si consiglia di creare una destinazione in caso di errore nell'ESM, indipendentemente dalla dimensione del record. Ciò garantisce che nessun record venga eliminato. Per ulteriori informazioni, vedere [Configurazione delle destinazioni per](https://docs.aws.amazon.com/lambda/latest/dg/kinesis-on-failure-destination.html#kinesis-on-failure-destination-console) le chiamate non riuscite. | | Amazon Redshift | Amazon Redshift supporta solo record di dimensioni inferiori a 1 MiB durante lo streaming di dati da Kinesis Data Streams. I record che superano questo limite non vengono elaborati. I record che non vengono elaborati vengono registrati come`sys_stream_scan_errors`. Per ulteriori informazioni, vedere [SYS\$1STREAM\$1SCAN\$1ERRORS](https://docs.aws.amazon.com/redshift/latest/dg/r_SYS_STREAM_SCAN_ERRORS.html). | | Connettore Flink per Kinesis Data Streams | Esistono due approcci per consumare i dati da Kinesis Data Streams: il connettore sorgente Kinesis e il connettore sink Kinesis. Il connettore sorgente supporta la gestione di record inferiori a 1 MiB e fino a 10. MiBs Non utilizzare il connettore sink per dischi di dimensioni superiori a 1 MiB. Per ulteriori informazioni, consulta [Usare i connettori per spostare i dati in Amazon Managed Service for Apache Flink con l' DataStream](https://docs.aws.amazon.com/managed-flink/latest/java/how-connectors.html)API. | ## Regioni in cui sono supportati record di grandi dimensioni Questa funzionalità di Amazon Kinesis Data Streams è disponibile solo nelle AWS seguenti regioni: | AWS Regione | Nome della regione | | --- | --- | | eu-north-1 | Europa (Stoccolma) | | me-south-1 | Medio Oriente (Bahrein) | | ap-south-1 | Asia Pacifico (Mumbai) | | eu-west-3 | Europa (Parigi) | | ap-southeast-3 | Asia Pacifico (Giacarta) | | us-east-2 | Stati Uniti orientali (Ohio) | | af-south-1 | Africa (Città del Capo) | | eu-west-1 | Europa (Irlanda) | | me-central-1 | Medio Oriente (Emirati Arabi Uniti) | | eu-central-1 | Europa (Francoforte) | | sa-east-1 | Sud America (San Paolo) | | ap-east-1 | Asia Pacifico (Hong Kong) | | ap-south-2 | Asia Pacifico (Hyderabad) | | us-east-1 | Stati Uniti orientali (Virginia settentrionale) | | ap-northeast-2 | Asia Pacifico (Seul) | | ap-northeast-3 | Asia Pacifico (Osaka) | | eu-west-2 | Europa (Londra) | | ap-southeast-4 | Asia Pacifico (Melbourne) | | ap-northeast-1 | Asia Pacifico (Tokyo) | | us-west-2 | Stati Uniti occidentali (Oregon) | | us-west-1 | Stati Uniti occidentali (California settentrionale) | | ap-southeast-1 | Asia Pacifico (Singapore) | | ap-southeast-2 | Asia Pacifico (Sydney) | | il-central-1 | Israele (Tel Aviv) | | ca-central-1 | Canada (Centrale) | | ca-west-1 | Canada occidentale (Calgary) | | eu-south-2 | Europa (Spagna) | | cn-northwest-1 | Cina (Ningxia) | | eu-central-2 | Europa (Zurigo) | | us-gov-east-1 | AWS GovCloud (Stati Uniti orientali) | | us-gov-west-1 | AWS GovCloud (Stati Uniti occidentali) | # Esegui test di resilienza con AWS Fault Injection Service AWS Fault Injection Service è un servizio completamente gestito che ti aiuta a eseguire esperimenti di iniezione dei guasti sui tuoi AWS carichi di lavoro. AWS FIS l'integrazione con Amazon Kinesis Data Streams consente di testare la resilienza delle applicazioni contro i comuni errori dell'API Amazon Kinesis Data Streams in un ambiente controllato. Questa funzionalità consente di convalidare la gestione degli errori, riprovare la logica e monitorare i sistemi prima che si verifichino guasti. [Per ulteriori informazioni, consulta Cos'è? AWS Fault Injection Service](https://docs.aws.amazon.com/fis/latest/userguide/what-is.html) . **Azioni** + Errore interno dell'API: questo inserisce errori interni nelle richieste effettuate dal ruolo IAM di destinazione. La risposta specifica dipende da ogni servizio e API. L'azione `aws:fis:inject-api-internal-error` crea `InternalFailure` errori (HTTP 500). + Errore di limitazione dell'API: questo inserisce errori interni nelle richieste effettuate dal ruolo IAM di destinazione. La risposta specifica dipende da ogni servizio e API. L'azione `aws:fis:inject-api-throttle-error` crea `ThrottlingException` errori (HTTP 400). + Errore API non disponibile: questo inserisce errori interni nelle richieste effettuate dal ruolo IAM di destinazione. La risposta specifica dipende da ogni servizio e API. L'azione `aws:fis:inject-api-unavailable-error` crea `ServiceUnavailable` errori (HTTP 503). + Eccezione di throughput fornita dall'API: inserisce errori interni nelle richieste effettuate dal ruolo IAM di destinazione. La risposta specifica dipende da ogni servizio e API. L'azione `aws:kinesis:inject-api-provisioned-throughput-exception` crea `ProvisionedThroughputExceededException` errori (HTTP 400). + Eccezione iterativa scaduta per l'API: inserisce errori interni nelle richieste effettuate dal ruolo IAM di destinazione. La risposta specifica dipende da ogni servizio e API. L'azione `aws:kinesis:inject-api-expired-iterator-exception` crea `ExpiredIteratorException` errori (HTTP 400). Per ulteriori informazioni, consulta le azioni di [Amazon Kinesis Data Streams](https://docs.aws.amazon.com/fis/latest/userguide/fis-actions-reference.html#aws-kinesis-actions). **Considerazioni** + Puoi utilizzare le azioni sopra descritte con offerte fornite e su richiesta per Amazon Kinesis Data Streams. + Lo streaming riprende una volta completato l'esperimento in base alla durata selezionata. Puoi anche interrompere un esperimento in corso prima che sia completato. In alternativa, puoi definire una condizione di arresto per interrompere l'esperimento sulla base di allarmi che definiscono lo stato dell'applicazione in Amazon CloudWatch Application Insights. + Puoi testare fino a 280 stream. Per ulteriori informazioni sul supporto regionale, consulta [AWS Fault Injection Service endpoint e quote](https://docs.aws.amazon.com/general/latest/gr/fis.html). # Errori di eccezione del throughput assegnato Il throughput assegnato ha superato gli errori di eccezione (HTTP 400) si verificano quando la frequenza di richiesta per uno stream Kinesis supera i limiti di throughput di uno o più shard. Ogni shard ha limiti di capacità di lettura e scrittura specifici e il superamento di tali limiti attiva questa eccezione. Gli scenari che portano a questa eccezione includono: picchi improvvisi nell'inserimento o nel consumo di dati, capacità insufficiente degli shard per il volume di dati in elaborazione o distribuzione non uniforme delle chiavi di partizione. **Consigli per la gestione delle eccezioni** + Implementa meccanismi esponenziali di back-off e re-try. + Aumenta il numero di shard per garantire un throughput più elevato. + Assicuratevi che vi sia una corretta distribuzione delle chiavi di partizione. + Monitora le metriche dello stream. Inoltre, l'utilizzo della modalità di capacità on-demand di Kinesis aiuta a regolare automaticamente i carichi di lavoro e a ridurre al minimo il verificarsi di questa eccezione. Per maggiori informazioni, consulta [Che cos’è AWS Fault Injection Service?](https://docs.aws.amazon.com/fis/latest/userguide/what-is.html) **Nota** I problemi di distribuzione impropria non rientrano nella funzionalità di scalabilità automatica della modalità on demand. **Per eseguire un esperimento di base** 1. Utilizza le metriche di base: registra i normali modelli di throughput prima del test. 1. Crea un esperimento: usa l'azione. `aws:kinesis:inject-api-provisioned-throughput-exception` 1. Configura l'intensità: inizia con una limitazione delle richieste del 25%. 1. Monitora le risposte: verifica la logica dei tentativi ripetuti con un back-off esponenziale. 1. Convalida il ridimensionamento: verifica che l'auto-scaling attivi l'attivazione. 1. Controlla gli allarmi: assicurati che gli allarmi funzionino come previsto. `CloudWatch` Le applicazioni devono implementare strategie, monitor `WriteProvisionedThroughputExceeded` e `ReadProvisionedThroughputExceeded` metriche di back-off adeguati e attivare lo shard scaling quando appropriato. **Dettagli dell'azione** + **Tipo di risorsa**: IAM Role ARN + **Operazioni target**:`PutRecord`,, `PutRecords` `GetRecords` + ****Codice di errore****: `ProvisionedThroughputExceededException` (HTTP 400) + ****Descrizione****: simula scenari in cui la frequenza di richiesta supera i limiti di capacità degli shard, testando la limitazione delle applicazioni e scalando le risposte. **Parameters** + **IAM Role ARN**: il ruolo utilizzato dall'applicazione per le operazioni di Kinesis Data Streams. + **Operazioni: operazioni** target:,,. `PutRecord` `PutRecords` `GetRecords` + **Elenco delle risorse**: i nomi o gli identificatori di frammenti specifici dei flussi. + **Durata**: la durata dell'esperimento, che è compresa tra un minuto e 12 ore. Nell' AWS FIS API, il valore è una stringa in formato ISO 8601. Ad esempio, PT1 M rappresenta un minuto. Nella AWS FIS console, si immette il numero di secondi, minuti o ore. + **Intensità**: la percentuale di richieste da limitare. **Autorizzazioni richieste** + `kinesis:InjectApiError` Esempio di modello di esperimento L'esempio seguente mostra un'eccezione di throughput assegnato per tutte le richieste fino a 5 flussi di dati Kinesis con il tag specificato. AWS FIS seleziona casualmente gli stream da influenzare. Dopo 5 minuti l'errore viene rimosso. ``` { "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" } } ``` Sperimenta un esempio di autorizzazioni di ruolo La seguente autorizzazione consente di eseguire `aws:kinesis:stream-expired-iterator-exception` azioni `aws:kinesis:stream-provisioned-throughput-exception` and su un flusso specifico che influiscono sul 50% delle richieste. # Errori di eccezione dell'iteratore scaduti Gli errori di eccezione dell'iteratore scaduto (HTTP 400) si verificano quando lo shard iterator è scaduto e non vengono più utilizzati per recuperare i record di stream durante la chiamata. `GetRecords` Ciò si verifica quando si verificano ritardi tra le operazioni di lettura, causati da attività di elaborazione dati di lunga durata, problemi di rete o tempi di inattività delle applicazioni. **Nota** Uno shard iterator è valido per 5 minuti dal momento in cui viene emesso. **Consigli per la gestione delle eccezioni** + Aggiornamento degli iteratori di shard prima che scadano. + Incorpora la gestione degli errori per ottenere nuovi iteratori. + Utilizzo della Kinesis Kinesis Client Library (KCL) che gestisce automaticamente la scadenza degli shard iterator. [Per ulteriori informazioni, consulta What is? AWS Fault Injection Service](https://docs.aws.amazon.com/fis/latest/userguide/what-is.html) **Per eseguire un esperimento di base** 1. Crea un modello di esperimento: usa la AWS FIS console. 1. Seleziona l'azione: usa l'`aws:kinesis:inject-api-expired-iterator-exception`azione. 1. Configura gli obiettivi: specifica il ruolo IAM e le operazioni di Kinesis Data Streams. 1. Imposta la durata: inizia con 5-10 minuti per il test iniziale. 1. Aggiungi condizioni di arresto: [condizioni di arresto per AWS FIS](https://docs.aws.amazon.com/fis/latest/userguide/stop-conditions.html). 1. Esegui l'esperimento: monitora il comportamento dell'applicazione. **Dettagli dell'azione** + **Tipo di risorsa**: IAM Role ARN + **Operazioni mirate**: `GetRecords` + ****Codice di errore****: `ExpiredIteratorException` (HTTP 400) + ****Descrizione****: l'iteratore fornito supera l'età massima consentita, simulando scenari in cui l'elaborazione dei record è troppo lenta o la logica di checkpoint fallisce. **Parameters** + **IAM Role ARN**: il ruolo utilizzato dall'applicazione per le operazioni di Kinesis Data Streams. + **Operazioni: operazioni mirate**: `GetRecords` + **Elenco delle risorse**: i nomi specifici dei flussi o ARNs. + **Durata**: la durata dell'esperimento. È configurabile. + **Intensità**: la percentuale di richieste da limitare. **Autorizzazioni richieste** + `kinesis:InjectApiError`