Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra. # Création et gestion de flux de données Kinesis Amazon Kinesis Data Streams ingère une grande quantité de données en temps réel, stocke durablement les données et rend les données disponibles pour leur utilisation. L'unité de données stockée par Kinesis Data Streams est un *enregistrement de données*. Un *flux de données* représente un groupe d'enregistrements de données. Les enregistrements de données figurant dans un flux de données sont répartis dans des partitions. Une *partition* comporte une séquence d'enregistrements de données dans un flux. Elle sert d'unité de débit de base d'un flux de données Kinesis. Une partition prend en charge 1 MB/s et 1 000 enregistrements par seconde pour les *écritures* et 2 MB/s pour les *lectures en mode* à la demande et en mode capacité provisionnée. Les limites de partition garantissent des performances prévisibles, ce qui facilite la conception et l'exploitation d'un flux de données en continu très fiable. Dans cette section, vous apprendrez à définir le mode de capacité du flux et à créer un flux à l'aide du AWS Management Console ou APIs. Vous pouvez ensuite effectuer des actions supplémentaires sur le stream. **Topics** + [Choisissez le bon mode pour diffuser](how-do-i-size-a-stream.md) + [Créez un flux à l'aide du AWS Management Console](how-do-i-create-a-stream.md) + [Créez un flux à l'aide du APIs](kinesis-using-sdk-java-create-stream.md) + [Mettre à jour un stream](updating-a-stream.md) + [Afficher la liste des flux](kinesis-using-sdk-java-list-streams.md) + [Répertorier les fragments](kinesis-using-sdk-java-list-shards.md) + [Supprimer un stream](kinesis-using-sdk-java-delete-stream.md) + [Revisionner un stream](kinesis-using-sdk-java-resharding.md) + [Modifier la période de conservation des données](kinesis-extended-retention.md) + [Étiquetez vos ressources Amazon Kinesis Data Streams](tagging.md) + [Gérez de gros disques](large-records.md) + [Réalisez des tests de résilience avec AWS Fault Injection Service](kinesis-fis.md) # Choisissez le bon mode pour diffuser Les rubriques suivantes expliquent comment choisir le mode le mieux adapté à votre application et comment passer d'un mode à l'autre, si nécessaire. **Topics** + [Quels sont les différents modes de Kinesis Data Streams ?](#diff-modes-kds) + [Fonctionnalités et cas d'utilisation du mode standard à la demande](#ondemandmode) + [Fonctionnalités et cas d'utilisation du mode Advantage à la demande](#ondemand-advantage-mode) + [Fonctionnalités et cas d'utilisation du mode provisionné](#provisionedmode) + [Basculer entre les modes](#switchingmodes) ## Quels sont les différents modes de Kinesis Data Streams ? Un mode détermine comment la capacité d'un flux de données est gérée et comment vous êtes facturé pour l'utilisation de votre flux de données. Dans Amazon Kinesis Data Streams, vous pouvez **choisir le mode On-Demand** Standard**, On-Demand** Advantage **et** le mode provisionné pour vos flux de données. + **Norme à la demande** : les flux de données dotés d'un mode à la demande ne nécessitent aucune planification de capacité et s'adaptent automatiquement pour gérer des gigaoctets de débit d'écriture et de lecture par minute. En mode à la demande, Kinesis Data Streams gère automatiquement les partitions afin de fournir le débit nécessaire. + **Avantage à la demande** : mode au niveau du compte qui offre davantage de fonctionnalités et fournit une structure tarifaire plus simple pour les flux à la demande. Dans ce mode, vous pouvez augmenter de manière proactive la capacité de débit d'écriture d'un flux à tout moment. **En ce qui concerne la tarification, il n'y a plus de frais fixes par flux, et les frais d'ingestion, de récupération des données et de rétention prolongée pour tous les flux à la demande sont inférieurs d'au moins 60 % à ceux de la norme On-Demand.** + **Provisionné** : pour les flux de données dotés d'un mode provisionné, vous devez spécifier le nombre de partitions pour le flux de données. La capacité totale d'un flux de données est la somme des capacités de ses partitions. Vous pouvez augmenter ou diminuer le nombre de partitions dans un flux de données, selon vos besoins. Vous pouvez utiliser Kinesis Data `PutRecord` Streams pour écrire `PutRecords` APIs des données dans vos flux de données dans n'importe quel mode. Pour récupérer des données, les trois modes prennent en charge les consommateurs par défaut qui utilisent l'`GetRecords`API et les consommateurs EFO (Enhanced Fan-Out) qui utilisent l'API. `SubscribeToShard` Toutes les fonctionnalités de Kinesis Data Streams, y compris le mode de rétention, le chiffrement, les mesures de surveillance et autres, sont prises en charge à la fois pour le mode à la demande et le mode provisionné. Kinesis Data Streams garantit une durabilité et une disponibilité élevées à la fois en mode de capacité à la demande et en mode de capacité provisionnée. ## Fonctionnalités et cas d'utilisation du mode standard à la demande Les flux de données en mode à la demande ne nécessitent aucune planification de la capacité et se mettent automatiquement à l'échelle pour gérer des gigaoctets de débit d'écriture et de lecture par minute. Le mode à la demande simplifie l'ingestion et le stockage de gros volumes de données avec une faible latence, car il élimine le provisionnement et la gestion des serveurs, du stockage ou du débit. Vous pouvez ingérer des milliards d'enregistrements par jour sans aucune surcharge opérationnelle. Le mode à la demande est idéal pour répondre aux besoins d'un trafic d'application très variable et imprévisible. Il n'est plus nécessaire de provisionner ces charges de travail pour une capacité maximale, ce qui peut entraîner des coûts plus élevés pour une faible utilisation. Le mode à la demande convient aux charges de travail caractérisées par des modèles de trafic imprévisibles et très variables. En mode de capacité à la demande, vous payez par gigaoctet de données écrites et lues à partir de vos flux de données. Il n'est pas nécessaire de spécifier le débit de lecture et d'écriture que vous attendez de votre application. Kinesis Data Streams s'adapte instantanément à vos charges de travail lorsqu'elles augmentent ou diminuent. Pour plus d’informations, consultez la [Tarification d’Amazon Kinesis Data Streams](https://aws.amazon.com/kinesis/data-streams/pricing/). Un flux de données en mode à la demande peut atteindre le double du débit d'écriture maximal observé au cours des 30 jours précédents. Lorsque le débit d'écriture de votre flux de données atteint un nouveau maximum, Kinesis Data Streams adapte automatiquement la capacité du flux de données. Par exemple, si le débit d'écriture de votre flux de données varie entre 10 MB/s et 40 % du débit 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 d'écriture. Toutefois, une limitation du nombre d'écritures peut se produire si votre trafic augmente jusqu'à plus du double du maximum précédent dans un délai de 15 minutes. Vous devez réessayer ces demandes limitées. La capacité de lecture agrégée d'un flux de données en mode à la demande augmente proportionnellement au débit d'écriture. Cela permet de garantir que les applications consommateur disposent toujours d'un débit de lecture suffisant pour traiter les données entrantes en temps réel. Vous obtenez un débit d'écriture au moins deux fois supérieur à celui des données lues à l'aide de l'API `GetRecords`. Nous vous recommandons d'utiliser une seule application consommateur avec l'API `GetRecord`, afin qu'elle dispose d'assez de marge pour rattraper son retard en cas de nécessité de récupération après une interruption. Il est recommandé d'utiliser la fonctionnalité de débit amélioré Enhanced Fan-Out de Kinesis Data Streams pour les scénarios nécessitant l'ajout de plusieurs applications consommateur. La fonctionnalité de débit amélioré Enhanced Fan-Out permet d'ajouter jusqu'à 20 consommateurs à un flux de données à l'aide de l'API `SubscribeToShard`, chaque application consommateur bénéficiant d'un débit dédié. ### Gérer les exceptions de débit de lecture et d'écriture Avec le mode à la demande (identique au mode capacité provisionnée), vous devez spécifier une clé de partition pour chaque enregistrement afin d'écrire des données dans votre flux de données. Kinesis Data Streams utilise vos clés de partition pour répartir les données entre les partitions. Kinesis Data Streams surveille le trafic de chaque partition. Lorsque le trafic entrant dépasse 500 KB/s par partition, il divise la partition en 15 minutes. Les valeurs de la clé de hachage de la partition parent sont redistribuées uniformément sur les partitions enfants. Si votre trafic entrant dépasse le double du maximum précédent, vous pouvez rencontrer des exceptions de lecture ou d'écriture pendant environ 15 minutes, même si vos données sont réparties de manière uniforme sur l'ensemble des partitions. Nous vous recommandons de réessayer toutes ces demandes afin que tous les enregistrements soient correctement stockés dans Kinesis Data Streams. Il est possible que vous rencontriez des exceptions de lecture et d'écriture si vous utilisez une clé de partition qui entraîne une distribution inégale des données et que les enregistrements attribués à une partition particulière dépassent les limites de cette dernière. Avec le mode à la demande, le flux de données s'adapte automatiquement pour gérer les modèles de distribution de données inégaux, sauf si une clé de partition dépasse les limites de 1 MB/s débit et de 1 000 enregistrements par seconde d'une partition. En mode à la demande, Kinesis Data Streams fractionne les partitions de manière égale lorsqu'il détecte une augmentation du trafic. Toutefois, il ne détecte ni n'isole les clés de hachage qui acheminent une plus grande partie du trafic entrant vers une partition donnée. Si vous utilisez des clés de partition très inégales, il se peut que vous continuiez à recevoir des exceptions d'écriture. Pour de tels cas d'utilisation, nous vous recommandons d'utiliser le mode de capacité provisionnée qui prend en charge les fractionnements granulaires des partitions. ## Fonctionnalités et cas d'utilisation du mode Advantage à la demande On-Demand Advantage est un paramètre au niveau du compte qui débloque davantage de fonctionnalités et fournit une structure tarifaire différente pour tous les flux à la demande de la région. Dans ce mode, les flux à la demande conservent leurs fonctionnalités et continuent à adapter automatiquement la capacité en fonction de l'utilisation réelle des données. Si vous souhaitez réchauffer de manière proactive la capacité de débit d'écriture d'un flux, vous pouvez configurer le débit chaud. Par exemple, si votre flux de données a un débit d'écriture compris entre 10 MB/s et 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 pour garantir que la capacité est disponible lorsque le débit de données arrive. L'utilisation du débit à chaud n'entraîne pas de frais supplémentaires. Un autre avantage du mode On-Demand Advantage est que les flux à la demande passent à une structure tarifaire plus simple. Lorsque le mode est activé, le compte ne sera plus soumis à des frais fixes par stream, et vous ne vous occuperez que de l'ingestion et de la récupération des données, ainsi que des frais de rétention prolongés facultatifs. Chaque dimension tarifaire bénéficie également d'une réduction significative par rapport à la dimension correspondante dans On-Demand Standard. Pour plus d’informations, consultez la [Tarification d’Amazon Kinesis Data Streams](https://aws.amazon.com/kinesis/data-streams/pricing/). Les extractions de données améliorées par ventilateur ne sont pas non plus coûteuses par rapport aux extractions de données standard dans ce mode. De plus, avec le mode On-Demand Advantage, vous pouvez enregistrer jusqu'à 50 consommateurs par stream afin de bénéficier d'un fan-out amélioré. L'activation de On-Demand Advantage engage le compte à récupérer au moins 25 % MiB/s of data ingest and 25MiB/s des données sur tous les flux à la demande. Pour les comptes qui répondent aux exigences d'utilisation minimale, la console Kinesis Data Streams vérifie si les habitudes d'utilisation de votre compte sont adaptées à l'utilisation du mode **On-Demand Advantage**. Si la consommation de données de votre compte est inférieure aux exigences, la différence vous sera facturée à titre de déficit, mais le tarif réduit restera le même. L'activation de On-Demand Advantage dispose également d'un délai minimum de 24 heures avant de pouvoir désactiver le mode. Dans l'ensemble, On-Demand Advantage est le meilleur moyen de diffuser avec Kinesis Data Streams si vous avez une utilisation constante du débit proche ou supérieure à l'engagement minimum, si vous avez besoin de nombreux clients fans ou si vous travaillez avec des centaines de flux de données. ## Fonctionnalités et cas d'utilisation du mode provisionné En mode provisionné, après avoir créé le flux de données, vous pouvez augmenter ou diminuer dynamiquement la capacité de votre partition à l'aide de l'API AWS Management Console ou de l'[UpdateShardCount](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_UpdateShardCount.html)API. Vous pouvez effectuer des mises à jour pendant qu'une application producteur ou consommateur de Kinesis Data Streams écrit ou lit des données dans le flux. Le mode provisionné est adapté à un trafic prévisible dont les besoins en capacité sont faciles à prévoir. Vous pouvez utiliser le mode provisionné si vous souhaitez un contrôle précis sur la manière dont les données sont distribuées à travers les partitions. En mode provisionné, vous devez spécifier le nombre de partitions du flux de données. Pour déterminer la taille d'un flux de données en mode provisionné, vous avez besoin des valeurs d'entrée suivantes : + Taille moyenne des enregistrements de données écrits dans le flux en kilo-octets (Ko), arrondie au Ko le plus proche (`average_data_size_in_KB`). + Nombre d'enregistrements de données devant être ajoutés au flux et lus depuis celui-ci, par seconde (`records_per_second`). + Nombre de consommateurs, c'est-à-dire d'applications Kinesis Data Streams qui consomment des données simultanément et indépendamment du flux (`number_of_consumers`). + Bande passante d'écriture entrante en Ko (`incoming_write_bandwidth_in_KB`), qui est égale à la taille `average_data_size_in_KB` multipliée par la valeur de `records_per_second`. + Bande passante de lecture sortante en Ko (`outgoing_read_bandwidth_in_KB`), qui est égale à la taille `incoming_write_bandwidth_in_KB` multipliée par la valeur de `number_of_consumers`. Vous pouvez calculer le nombre initial de partitions (`number_of_shards`) dont votre flux a besoin en utilisant les valeurs d'entrée de la formule ci-dessous. ``` number_of_shards = ceiling(max(incoming_write_bandwidth_in_KiB/1024, outgoing_read_bandwidth_in_KiB/2048)) ``` Vous pouvez toujours rencontrer des exceptions de débit de lecture et d'écriture en mode provisionné si vous ne configurez pas votre flux de données pour gérer votre débit maximal. Dans ce cas, vous devez mettre à l'échelle manuellement votre flux de données pour l'adapter à votre trafic de données. Il est également possible que vous rencontriez des exceptions de lecture et d'écriture si vous utilisez une clé de partition qui entraîne une distribution inégale des données et que les enregistrements attribués à une partition dépassent les limites de cette dernière. Pour résoudre ce problème en mode provisionné, identifiez ces partitions et fractionnez-les manuellement afin de mieux s'adapter à votre trafic. PoPour plus d'informations, consultez la rubrique [Repartitionnement d'un flux](https://docs.aws.amazon.com/streams/latest/dev/kinesis-using-sdk-java-resharding.html) (français non garanti). ## Basculer entre les modes Pour chaque flux de données de votre appareil Compte AWS, vous pouvez passer du mode à la demande au mode provisionné deux fois en 24 heures. Le passage d'un mode à l'autre ne perturbe pas vos applications qui utilisent ce flux de données. Vous pouvez continuer à écrire et à lire dans ce flux de données. *Lorsque vous passez d'un mode à l'autre, du mode à la demande au mode provisionné ou du mode provisionné au mode à la demande, le statut du flux est défini sur Mise à jour.* Vous devez attendre que l'état du flux de données passe à *Actif* afin de pouvoir modifier à nouveau ses propriétés. Lorsque vous passez du mode capacité provisionnée au mode capacité à la demande, votre flux de données conserve initialement le nombre de partitions qu'il possédait avant la transition. À partir de ce moment, Kinesis Data Streams surveille votre trafic de données et adapte le nombre de partitions de ce flux de données à la demande en fonction de votre débit d'écriture. Lorsque vous passez du mode à la demande au mode provisionné, votre flux de données conserve initialement le nombre de partitions qu'il possédait avant la transition, mais à partir de ce moment, il vous incombe de surveiller et d'ajuster le nombre de partitions de ce flux de données afin de l'adapter correctement à votre débit d'écriture. Vous pouvez passer du mode **On-Demand Standard** au mode **On-Demand Advantage** en activant un paramètre au niveau du compte. Lorsqu'il est activé, le compte s'engage à utiliser au moins 25 MiB/s of data ingest and 25MiB/s % de la récupération de données sur tous les flux à la demande de la région. Une fois activé, vous devez attendre au moins 24 heures avant de pouvoir désactiver **On-Demand Advantage**, mais vous pouvez demander la modification à tout moment. Si vous souhaitez passer d'**On-Demand Advantage** à **On-Demand Standard, vous devez d'abord supprimer tout débit chaud configuré avec des flux à la demande**. # Créez un flux à l'aide du AWS Management Console Vous pouvez créer un flux à l'aide de la console Kinesis Data Streams, de l'API Kinesis Data Streams ou de la AWS Command Line Interface (AWS CLI). **Pour créer un flux de données avec la console** 1. [Connectez-vous à la console Kinesis AWS Management Console et ouvrez-la à https://console.aws.amazon.com l'adresse /kinesis.](https://console.aws.amazon.com/kinesis) 1. Dans la barre de navigation, développez le sélecteur de région et choisissez une région. 1. Choisissez **Create data stream (Créer un flux de données)**. 1. Sur la page **Créer un flux Kinesis**, saisissez le nom de votre flux de données, puis choisissez le mode de capacité **à la demande** ou **provisionné**. Le mode **à la demande** est sélectionné par défaut. Pour de plus amples informations, veuillez consulter [Choisissez le bon mode pour diffuser](how-do-i-size-a-stream.md). En mode **à la demande**, vous pouvez ensuite choisir **Créer un flux Kinesis** pour créer votre flux de données. En mode **provisionné**, vous devez ensuite spécifier le nombre de partitions dont vous avez besoin, puis choisir **Créer un flux Kinesis**. Dans la page **Flux Kinesis**, la valeur **Statut** de votre flux est **En création** lorsque le flux est en cours de création. Lorsque le flux est à prêt à être utilisé, le **statut** passe à **Actif**. 1. Choisissez le nom de votre flux. La page **Détails du flux** affiche un récapitulatif de la configuration de flux, ainsi que des informations de surveillance. **Création d'un flux à l'aide de l'API Kinesis Data Streams** + Pour plus d'informations sur la création d'un flux à l'aide de l'API Kinesis Data Streams, consultez [Créez un flux à l'aide du APIs](kinesis-using-sdk-java-create-stream.md). **Pour créer un flux à l'aide du AWS CLI** + Pour plus d'informations sur la création d'un flux à l'aide de AWS CLI, consultez la commande [create-stream](https://docs.aws.amazon.com/cli/latest/reference/kinesis/create-stream.html). # Créez un flux à l'aide du APIs Suivez les étapes ci-dessous pour créer votre flux de données Kinesis. ## Création du client Kinesis Data Streams Afin de pouvoir travailler avec les flux de données Kinesis, vous devez créer un objet client. Le code Java suivant instancie un générateur client et l'utilise pour définir la région, les informations d'identification et la configuration du client. Il génère ensuite un objet client. ``` AmazonKinesisClientBuilder clientBuilder = AmazonKinesisClientBuilder.standard(); clientBuilder.setRegion(regionName); clientBuilder.setCredentials(credentialsProvider); clientBuilder.setClientConfiguration(config); AmazonKinesis client = clientBuilder.build(); ``` Pour plus d'informations, consultez la rubrique [Régions et points d'extrémité des flux de données Kinesis](https://docs.aws.amazon.com/general/latest/gr/rande.html#ak_region) dans *Références générales AWS*. ## Créez le stream Maintenant que vous avez créé votre client Kinesis Data Streams, vous pouvez créer un flux à l'aide de la console ou par programmation. Pour créer un flux par programmation, instanciez un `CreateStreamRequest` objet et attribuez un nom au flux. Si vous souhaitez utiliser le mode provisionné, spécifiez le nombre de partitions que le flux doit utiliser. + **À la demande** : ``` CreateStreamRequest createStreamRequest = new CreateStreamRequest(); createStreamRequest.setStreamName( myStreamName ); ``` + **Provisionné** : ``` CreateStreamRequest createStreamRequest = new CreateStreamRequest(); createStreamRequest.setStreamName( myStreamName ); createStreamRequest.setShardCount( myStreamSize ); ``` Le nom du flux identifie le flux. Le nom est limité au AWS compte utilisé par l'application. Il est également défini pour chaque région. En d'autres termes, deux flux provenant de deux AWS comptes différents peuvent porter le même nom, et deux flux appartenant au même AWS compte mais situés dans deux régions différentes peuvent porter le même nom, mais pas deux flux sur le même compte et dans la même région. Le débit du flux est fonction du nombre de partitions. Pour augmenter le débit provisionné, vous avez besoin d'un plus grand nombre de partitions. L'augmentation du nombre de partitions augmente également le AWS coût du stream. Pour plus d'informations sur le calcul d'un nombre approprié de partitions pour votre application, consultez [Choisissez le bon mode pour diffuser](how-do-i-size-a-stream.md). Après avoir configuré l'`createStreamRequest`objet, créez un flux en appelant la `createStream` méthode sur le client. Après avoir appelé `createStream`, attendez que le flux passe à l'état `ACTIVE` avant d'effectuer des opérations sur le flux. Pour vérifier l'état du flux, appelez la méthode `describeStream`. Cependant, `describeStream` lève une exception si le flux n'existe pas. Par conséquent, intégrez l'appel `describeStream` dans un bloc `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" ); } ``` # Mettre à jour un stream Vous pouvez mettre à jour les détails d'un flux à l'aide de la console Kinesis Data Streams, de l'API Kinesis Data Streams ou de la AWS CLI. **Note** Vous pouvez activer un chiffrement côté serveur pour des flux de données existants ou pour des flux que vous avez créé récemment. ## Utilisation de la console **Pour mettre à jour un flux de données avec la console** 1. Ouvrez la console Amazon Kinesis à l'adresse. [https://console.aws.amazon.com/kinesis/](https://console.aws.amazon.com/kinesis/) 1. Dans la barre de navigation, développez le sélecteur de région et choisissez une région. 1. Choisissez le nom de votre flux dans la liste. La page **Détails du flux** affiche un récapitulatif de la configuration de flux, ainsi que des informations de surveillance. 1. Pour passer du mode de capacité à la demande au mode de capacité provisionnée pour un flux de données, choisissez le **mode Modifier la capacité** dans l'onglet **Configuration**. Pour de plus amples informations, veuillez consulter [Choisissez le bon mode pour diffuser](how-do-i-size-a-stream.md). **Important** Pour chaque flux de données de votre AWS compte, vous pouvez passer du mode à la demande au mode provisionné deux fois en 24 heures. 1. Pour un flux de données en mode provisionné, pour modifier le nombre de partitions, choisissez **Modifier les partitions provisionnées** dans l'onglet **Configuration**, puis saisissez un nouveau nombre de partitions. 1. Pour activer le chiffrement côté serveur d'enregistrements de données, choisissez **Modifier** dans la section **Server-side encryption (Chiffrement côté serveur)**. Choisissez une clé KMS à utiliser en tant que clé principale pour le chiffrement, ou utilisez la clé principale par défaut, **aws/kinesis**, gérée par Kinesis. Si vous activez le chiffrement d'un flux et que vous utilisez votre propre clé AWS KMS principale, assurez-vous que vos applications de production et de consommation ont accès à la clé AWS KMS principale que vous avez utilisée. Pour attribuer des autorisations à une application afin qu'elle puisse accéder à une clé AWS KMS générée par un utilisateur, consultez [Autorisations d'utilisation des clés KMS générées par l'utilisateur](permissions-user-key-KMS.md). 1. Pour modifier la période de conservation des données, choisissez **Modifier** dans la section **Durée de conservation des données**, puis saisissez une nouvelle durée de conservation des données. 1. Si vous avez activé les métriques personnalisées sur votre compte, choisissez **Modifier** dans la section **Mesures au niveau des partitions**, puis spécifiez les métriques pour votre flux. Pour de plus amples informations, veuillez consulter [Surveillez le service Amazon Kinesis Data Streams avec Amazon CloudWatch](monitoring-with-cloudwatch.md). ## Utilisation de l’API Pour mettre à jour les détails d'un flux à l'aide de l'API, consultez les méthodes suivantes : + [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) ## Utilisez le AWS CLI Pour plus d'informations sur la mise à jour d'un flux à l'aide du AWS CLI, consultez le manuel de référence de la [Kinesis CLI](https://docs.aws.amazon.com/cli/latest/reference/kinesis/index.html). # Afficher la liste des flux Les flux sont limités au AWS compte associé aux AWS informations d'identification utilisées pour instancier le client Kinesis Data Streams ainsi qu'à la région spécifiée pour le client. Un compte  AWS peut avoir plusieurs flux actifs à la fois. Vous pouvez répertorier vos flux dans la console Kinesis Data Streams ou par programmation. Le code de cette section indique comment répertorier tous les streams de votre AWS compte. ``` ListStreamsRequest listStreamsRequest = new ListStreamsRequest(); listStreamsRequest.setLimit(20); ListStreamsResult listStreamsResult = client.listStreams(listStreamsRequest); List streamNames = listStreamsResult.getStreamNames(); ``` Cet exemple de code crée d'abord une nouvelle instance de `ListStreamsRequest` et appelle sa méthode `setLimit` pour spécifier que 20 flux au maximum doivent être renvoyés pour chaque appel de `listStreams`. Si vous ne spécifiez pas de valeur pour `setLimit`, Kinesis Data Streams renvoie un nombre de flux inférieur ou égal au nombre de flux présents dans le compte. Le code passe ensuite `listStreamsRequest` à la méthode `listStreams` du client. La valeur de retour `listStreams` est stockée dans un objet `ListStreamsResult`. Le code appelle la méthode `getStreamNames` sur cet objet et stocke les noms de flux renvoyés dans la liste `streamNames`. Notez que Kinesis Data Streams peut renvoyer un nombre de flux inférieur à celui qui est spécifié par la limite définie même si le compte et la région contiennent un nombre de flux supérieur. Pour être sûr d'extraire tous les flux, utilisez la méthode `getHasMoreStreams` comme il est décrit dans l'exemple de code suivant. ``` while (listStreamsResult.getHasMoreStreams()) { if (streamNames.size() > 0) { listStreamsRequest.setExclusiveStartStreamName(streamNames.get(streamNames.size() - 1)); } listStreamsResult = client.listStreams(listStreamsRequest); streamNames.addAll(listStreamsResult.getStreamNames()); } ``` Ce code appelle la méthode `getHasMoreStreams` sur `listStreamsRequest` pour vérifier s'il y a des flux supplémentaires disponibles en plus de ceux qui ont été renvoyés dans l'appel initial de `listStreams`. Si c'est le cas, le code appelle la méthode `setExclusiveStartStreamName` en indiquant le nom du dernier flux qui a été renvoyé dans l'appel précédent de `listStreams`. La méthode `setExclusiveStartStreamName` fait que l'appel suivant de `listStreams` démarre après ce flux. Le groupe de noms de flux renvoyé par cet appel est ensuite ajouté à la liste `streamNames`. Ce processus continue jusqu'à ce que tous les noms de flux aient été recueillis dans la liste. Les flux renvoyés par `listStreams` peuvent avoir l'un des états suivants : + `CREATING` + `ACTIVE` + `UPDATING` + `DELETING` Vous pouvez vérifier l'état d'un flux à l'aide de la méthode `describeStream`, comme illustré dans la section précédente [Créez un flux à l'aide du APIs](kinesis-using-sdk-java-create-stream.md). # Répertorier les fragments Un flux de données peut comporter une ou plusieurs partitions. La méthode recommandée pour répertorier ou récupérer les fragments d'un flux de données consiste à utiliser l'[ListShards](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_ListShards.html)API. L'exemple suivant montre comment vous pouvez obtenir une liste des partitions d'un flux de données. Pour une description complète de l'opération principale utilisée dans cet exemple et de tous les paramètres que vous pouvez définir pour l'opération, consultez [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()); } } } ``` Pour exécuter l'exemple de code précédent, vous pouvez utiliser un fichier POM comme celui qui suit. ``` 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 ``` Avec l'`ListShards`API, vous pouvez utiliser le [ShardFilter](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_ShardFilter.html)paramètre pour filtrer la réponse de l'API. Vous ne pouvez spécifier qu'un seul filtre à la fois. Si vous utilisez le `ShardFilter` paramètre lors de l'appel de l' ListShardsAPI, `Type` il s'agit de la propriété requise qui doit être spécifiée. Si vous spécifiez les types `AT_TRIM_HORIZON`, `FROM_TRIM_HORIZON` ou `AT_LATEST`, vous n'avez pas besoin d'indiquer le `ShardId` ou les propriétés optionnelles `Timestamp`. Si vous spécifiez le type `AFTER_SHARD_ID`, vous devez également indiquer la valeur de la propriété optionnelle `ShardId`. La fonctionnalité de la `ShardId` propriété est identique à celle du `ExclusiveStartShardId` paramètre de l' ListShards API. Lorsque la propriété `ShardId` est indiquée, la réponse inclut les partitions en commençant par la partition dont l'identifiant suit immédiatement le `ShardId` que vous avez indiqué. Si vous spécifiez le type `AT_TIMESTAMP` ou `FROM_TIMESTAMP_ID`, vous devez également indiquer la valeur de la propriété optionnelle `Timestamp`. Si vous spécifiez le type `AT_TIMESTAMP`, toutes les partitions ouvertes à l'horodatage indiqué sont renvoyées. Si vous spécifiez le type `FROM_TIMESTAMP`, toutes les partitions commençant à partir de l'horodatage indiqué jusqu'à TIP sont renvoyées. **Important** `DescribeStreamSummary`et `ListShard` APIs offrez un moyen plus évolutif de récupérer des informations sur vos flux de données. Plus précisément, les quotas de l' DescribeStream API peuvent provoquer un ralentissement. Pour de plus amples informations, veuillez consulter [Quotas et limites](service-sizes-and-limits.md). Notez également que les `DescribeStream` quotas sont partagés entre toutes les applications qui interagissent avec tous les flux de données de votre AWS compte. Les quotas de l' ListShards API, en revanche, sont spécifiques à un seul flux de données. Ainsi, non seulement vous obtenez un TPS plus élevé avec l' ListShards API, mais l'action s'adapte mieux à mesure que vous créez davantage de flux de données. Nous vous recommandons de migrer tous vos producteurs et consommateurs qui appellent l' DescribeStream API pour qu'ils invoquent plutôt le DescribeStreamSummary et le ListShard APIs. Pour identifier ces producteurs et consommateurs, nous recommandons d'utiliser Athena pour analyser les CloudTrail journaux, car les agents utilisateurs de KPL et KCL sont capturés dans les appels d'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 ``` Nous recommandons également que les intégrations AWS Lambda et Amazon Firehose avec Kinesis Data Streams qui invoquent l'API soient reconfigurées afin que `DescribeStream` les intégrations invoquent plutôt et. `DescribeStreamSummary` `ListShards` Plus précisément, pour AWS Lambda, vous devez mettre à jour le mappage de votre source d'événements. Pour Amazon Firehose, les autorisations IAM correspondantes doivent être mises à jour afin qu'elles incluent l'autorisation IAM `ListShards`. # Supprimer un stream Vous pouvez supprimer un flux à l'aide de la console Kinesis Data Streams ou par programmation. Pour supprimer un flux par programmation, utilisez `DeleteStreamRequest`, comme illustré dans le code suivant. ``` DeleteStreamRequest deleteStreamRequest = new DeleteStreamRequest(); deleteStreamRequest.setStreamName(myStreamName); client.deleteStream(deleteStreamRequest); ``` Fermez toutes les applications qui opèrent sur le flux avant de supprimer ce dernier. Si une application tente d'opérer sur un flux supprimé, elle reçoit les exceptions `ResourceNotFound`. En outre, si vous créez ensuite un flux ayant le même nom que votre flux précédent et que les applications qui opéraient sur le flux précédent sont toujours en cours d'exécution, ces applications peuvent essayer d'interagir avec le nouveau flux comme si c'était le précédent, ce qui entraîne des résultats imprévisibles. # Revisionner un stream **Important** Vous pouvez redéfinir votre stream à l'aide de l'[UpdateShardCount](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_UpdateShardCount.html)API. Sinon, vous pouvez continuer à diviser et à fusionner comme expliqué ici. Amazon Kinesis Data Streams prend en charge le *repartitionnement*, ce qui vous permet d'ajuster le nombre de partitions dans votre flux afin de répondre aux modifications du débit de données dans le flux. Le repartitionnement est considéré comme une opération avancée. Si vous utilisez Kinesis Data Streams pour la première fois, revenez à ce sujet après vous être familiarisé avec tous les autres aspects de Kinesis Data Streams. Il existe deux types d'opérations de repartitionnement : les fusions et les divisions de partitions. Lorsque vous fractionnez une partition, vous divisez une seule partition en deux partitions. Lorsque vous fusionnez une partition, vous combinez deux partitions en une seule partition. Le repartitionnement s'effectue toujours *par paire*, car vous ne pouvez ni fractionner en plus de deux partitions dans une seule opération, ni fusionner plus de deux partitions en une seule opération. La partition ou la paire de partitions qui fait l'objet du repartitionnement s'appelle les partitions *parent*. La partition ou la paire de partitions générée par le repartitionnement s'appelle les partitions *enfant*. Le fractionnement augmente le nombre de partitions dans votre flux et donc la capacité de données du flux. Etant donné que vous êtes facturé par partition, le fractionnement augmente le coût de votre flux. De même, la fusion réduit le nombre de partitions dans votre flux et diminue ainsi la capacité de données, et donc le coût du flux. En général, le repartitionnement est effectué par une application administrative qui est distincte des applications producteur (put) et des applications consommateur (get). Une telle application administrative surveille les performances globales du flux sur la base des métriques fournies par Amazon CloudWatch ou sur la base des métriques collectées auprès des producteurs et des consommateurs. L'application administrative a également besoin d'un ensemble d'autorisations IAM plus large que celui des consommateurs ou des producteurs, car les consommateurs et les producteurs ne devraient généralement pas avoir besoin d'accéder aux autorisations APIs utilisées pour le repartage. Pour plus d'informations sur les autorisations IAM pour Kinesis Data Streams, consultez [Contrôle de l'accès aux ressources Amazon Kinesis Data Streams à l'aide d'IAM](controlling-access.md) (français non garanti). Pour plus d'informations sur le repartitionnement, consultez la rubrique [Comment modifier le nombre de partitions ouvertes dans Kinesis Data Streams ?](https://aws.amazon.com/premiumsupport/knowledge-center/kinesis-data-streams-open-shards/) **Topics** + [Décidez d'une stratégie de repartage](kinesis-using-sdk-java-resharding-strategies.md) + [Séparer un fragment](kinesis-using-sdk-java-resharding-split.md) + [Fusionner deux partitions](kinesis-using-sdk-java-resharding-merge.md) + [Terminez l'action de repartage](kinesis-using-sdk-java-after-resharding.md) # Décidez d'une stratégie de repartage L'objectif du repartitionnement dans Amazon Kinesis Data Streams est de permettre à votre flux de s'adapter aux changements de débit des données. Vous fractionnez les partitions pour accroître la capacité (et le coût) de votre flux. Vous fusionnez les partitions pour réduire le coût (et la capacité) de votre flux. Une approche du partitionnement peut consister à fractionner chaque partition du flux et à doubler ainsi la capacité du flux. Cependant, cela peut fournir une capacité supplémentaire supérieure à celle dont vous avez réellement besoin et donc engendrer des coûts inutiles. Vous pouvez également utiliser des métriques pour déterminer quelles sont vos partitions *chaudes* et vos partitions *froides*, c'est-à-dire les partitions qui reçoivent plus de données que prévu et les partitions qui reçoivent moins de données que prévu. Vous pouvez ensuite fractionner les partitions chaudes de manière sélective afin d'augmenter la capacité des clés de hachage qui ciblent ces partitions. De même, vous pouvez fusionner les partitions froides afin de mieux utiliser leurs capacités inutilisées. Vous pouvez obtenir certaines données de performance pour votre flux à partir des CloudWatch métriques Amazon publiées par Kinesis Data Streams. Cependant, vous pouvez également collecter certaines de vos propres métriques pour vos flux. Pour cela, vous pouvez consigner les valeurs de clé de hachage générées par les clés de partition pour vos enregistrements de données. N'oubliez pas que vous spécifiez la clé de partition lorsque vous ajoutez l'enregistrement au flux. ``` putRecordRequest.setPartitionKey( String.format( "myPartitionKey" ) ); ``` Kinesis Data Streams calcule la [MD5](http://en.wikipedia.org/wiki/MD5)clé de hachage à partir de la clé de partition. Comme vous spécifiez la clé de partition pour l'enregistrement, vous pouvez l'utiliser MD5 pour calculer la valeur de la clé de hachage pour cet enregistrement et l'enregistrer. Vous pouvez également enregistrer IDs les partitions auxquelles vos enregistrements de données sont affectés. L'ID de partition s'obtient en utilisant la méthode `getShardId` de l'objet `putRecordResults` renvoyé par la méthode `putRecords` et l'objet `putRecordResult` renvoyé par la méthode `putRecord`. ``` String shardId = putRecordResult.getShardId(); ``` Avec les valeurs de la partition IDs et de la clé de hachage, vous pouvez déterminer quelles partitions et quelles clés de hachage reçoivent le plus ou le moins de trafic. Vous pouvez ensuite utiliser le repartitionnement pour augmenter ou diminuer les capacités, de manière appropriée pour ces clés. # Séparer un fragment Pour fractionner une partition dans Amazon Kinesis Data Streams, vous devez spécifier comment les valeurs de clé de hachage de la partition parent doivent être redistribuées aux partitions enfants. Lorsque vous ajoutez un enregistrement de données à un flux, il est affecté à une partition suivant une valeur de clé de hachage. La valeur de la clé de hachage est le [MD5](http://en.wikipedia.org/wiki/MD5)hachage de la clé de partition que vous spécifiez pour l'enregistrement de données au moment où vous ajoutez l'enregistrement de données au flux. Les données des enregistrements ayant la même clé de partition disposent également de la même valeur de clé de hachage. Les valeurs de clé de hachage admises pour une partition donnée constituent un ensemble d'entiers non négatifs contigus ordonnés. Cette gamme de valeurs de clé de hachage admises est donnée par ce qui suit : ``` shard.getHashKeyRange().getStartingHashKey(); shard.getHashKeyRange().getEndingHashKey(); ``` Lorsque vous fractionnez la partition, vous spécifiez une valeur comprise dans cette plage. Cette valeur de clé de hachage et toutes les valeurs de clé de hachage supérieures sont distribuées à l'une des partitions enfant. Toutes les valeurs de clé de hachage inférieures sont distribuées à l'autre partition enfant. Le code suivant illustre une opération de fractionnement de partition qui répartit de nouveau les clés de hachage uniformément entre chaque partition enfant, en fractionnant principalement en deux la partition parent. Il présente simplement une des manières possibles de diviser la partition parent. Vous pouvez, par exemple, diviser la partition de façon à ce que le tiers inférieur des clés issues de la partition parent passe dans une partition enfant et que les deux tiers supérieurs des clés passent dans l'autre partition enfant. Cependant, pour de nombreuses applications, le fractionnement des partitions en deux est une approche efficace. Le code suppose que `myStreamName` contient le nom de votre flux et que la variable d'objet `shard` contient la partition à fractionner. Commencez par instancier un nouvel objet `splitShardRequest` et définir le nom de flux et l'ID de partition. ``` SplitShardRequest splitShardRequest = new SplitShardRequest(); splitShardRequest.setStreamName(myStreamName); splitShardRequest.setShardToSplit(shard.getShardId()); ``` Déterminez la valeur de clé de hachage qui se trouve à mi-chemin entre les valeurs inférieures et supérieures de la partition. Il s'agit de la valeur de clé de hachage de départ de la partition enfant qui contient la partie supérieure des clés de hachage de la partition parent. Spécifiez cette valeur dans la méthode `setNewStartingHashKey`. Vous ne devez spécifier que cette valeur. Kinesis Data Streams distribue automatiquement les clés de hachage inférieures à cette valeur à l'autre partition enfant créée par le fractionnement. La dernière étape consiste à appeler la méthode `splitShard` sur le client 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); ``` La première étape qui suit cette procédure est présentée dans [Attendre qu'un stream redevienne actif](kinesis-using-sdk-java-after-resharding.md#kinesis-using-sdk-java-resharding-wait-until-active). # Fusionner deux partitions Dans une fusion de partitions, deux partitions spécifiées sont combinées en une seule partition. Après la fusion, la partition enfant unique reçoit des données pour toutes les valeurs de clé de hachage couvertes par les deux partitions parent. **Partitions adjacentes** Pour fusionner deux partitions, celles-ci doivent être *adjacentes*. Deux partitions sont considérées adjacentes si l'union des plages de clés de hachage des deux partitions forme un ensemble contigu sans interruption. Par exemple, supposons que vous avez deux partitions, l'un avec une plage de clé de hachage de 276...381 et l'autre avec une plage de clé de hachage de 382...454. Vous pouvez fusionner ces deux partitions dans une seule partition qui aurait une plage de clé de hachage de 276...454. Pour un exemple supplémentaire, supposons que vous avez deux partitions, dont une avec une plage de clé de hachage de 276...381 et l'autre avec une plage de clé de hachage de 455...560. Vous ne pouvez pas fusionner ces deux partitions, car il y a une ou plusieurs partitions entre celles-ci qui couvrent la plage 382...454. L'ensemble de toutes les `OPEN` partitions d'un flux, en tant que groupe, couvre toujours l'ensemble des valeurs des clés de hachage. MD5 Pour plus d'informations sur les états des partitions, par exemple `CLOSED`, consultez [Tenez compte du routage des données, de la persistance des données et de l'état de la partition après une refonte](kinesis-using-sdk-java-after-resharding.md#kinesis-using-sdk-java-resharding-data-routing) (français non garanti). Pour identifier les partitions qui sont candidates à la fusion, vous devez filtrer toutes les partitions qui ont l'état `CLOSED`. Les partitions qui ont l'état `OPEN`, c'est-à-dire qui n'ont pas l'état `CLOSED`, ont un numéro de séquence de fin de `null`. Vous pouvez tester le numéro de séquence de fin d'une partition en utilisant : ``` if( null == shard.getSequenceNumberRange().getEndingSequenceNumber() ) { // Shard is OPEN, so it is a possible candidate to be merged. } ``` Après avoir filtré les partitions fermées, triez les partitions restantes sur la valeur de clé de hachage maximale prise en charge par chaque partition. Vous pouvez extraire cette valeur en utilisant : ``` shard.getHashKeyRange().getEndingHashKey(); ``` Si deux partitions sont adjacentes dans cette liste filtrée et triée, elles peuvent être fusionnées. **Code pour l'opération de fusion** Le code ci-après fusionne deux partitions. Ce code suppose que `myStreamName` contient le nom de votre flux et que les variables d'objet `shard1` et `shard2` contiennent les deux partitions adjacentes à fusionner. Pour l'opération de fusion, commencez par instancier un nouvel objet `mergeShardsRequest`. Spécifiez le nom du flux avec la méthode `setStreamName`. Spécifiez ensuite les deux partitions à fusionner à l'aide des méthodes `setShardToMerge` et `setAdjacentShardToMerge`. Pour finir, appelez la méthode `mergeShards` sur le client Kinesis Data Streams pour effectuer l'opération. ``` MergeShardsRequest mergeShardsRequest = new MergeShardsRequest(); mergeShardsRequest.setStreamName(myStreamName); mergeShardsRequest.setShardToMerge(shard1.getShardId()); mergeShardsRequest.setAdjacentShardToMerge(shard2.getShardId()); client.mergeShards(mergeShardsRequest); ``` La première étape qui suit cette procédure est présentée dans [Attendre qu'un stream redevienne actif](kinesis-using-sdk-java-after-resharding.md#kinesis-using-sdk-java-resharding-wait-until-active). # Terminez l'action de repartage Après tout type de procédure de repartitionnement dans Amazon Kinesis Data Streams et avant la reprise du traitement normal des enregistrements, d'autres procédures doivent être effectuées et d'autres éléments doivent être pris en compte. Les sections suivantes décrivent ces procédures et considérations. **Topics** + [Attendre qu'un stream redevienne actif](#kinesis-using-sdk-java-resharding-wait-until-active) + [Tenez compte du routage des données, de la persistance des données et de l'état de la partition après une refonte](#kinesis-using-sdk-java-resharding-data-routing) ## Attendre qu'un stream redevienne actif Après avoir appelé une opération de repartage`mergeShards`, `splitShard` vous devez attendre que le flux redevienne actif. Le code à utiliser est le même que lorsque vous attendez qu'un flux devienne actif après la [création d'un flux](kinesis-using-sdk-java-create-stream.md). Ce code se présente comme suit : ``` 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" ); } ``` ## Tenez compte du routage des données, de la persistance des données et de l'état de la partition après une refonte Kinesis Data Streams est un service de streaming de données en temps réel. Vos applications doivent partir du principe que les données circulent en continu à travers les fragments de votre flux. Lorsque vous repartitionnez, les enregistrements de données qui étaient acheminés vers les partitions parent sont réacheminés vers les partitions enfant en se basant sur les valeurs de clé de hachage auxquelles sont mappées les clés de partition des enregistrements de données. Toutefois, les enregistrements de données qui se trouvaient dans les partitions parent avant le repartitionnement demeurent dans ces partitions. Les partitions parentes ne disparaissent pas lors du remaniement. Elles demeurent avec les données qu'elles contiennent avant le repartitionnement. Les enregistrements de données figurant dans les partitions parent sont accessibles à l'aide des opérations [`getShardIterator` et `getRecords`](developing-consumers-with-sdk.md#kinesis-using-sdk-java-get-data) dans l'API Kinesis Data Streams, ou via la Kinesis Client Library. **Note** Les enregistrements de données sont accessibles à partir du moment où ils sont ajoutés au flux jusqu'à la période de conservation actuelle. Cette constatation demeure vraie, quelles que soient les modifications apportées aux partitions du flux au cours de cette période. Pour plus d'informations sur la période de conservation d'un flux, consultez la page [Modifier la période de conservation des données](kinesis-extended-retention.md). Au cours du processus de repartitionnement, une partition parent passe de l'état `OPEN` à l'état `CLOSED`, puis à l'état `EXPIRED`. + **OPEN (OUVERT)** : avant une opération de repartitionnement, une partition parent a l'état `OPEN`, qui signifie que des enregistrements de données peuvent être à la fois ajoutés à la partition et extraits de celle-ci. + **CLOSED (FERMÉ)** : après une opération de repartitionnement, la partition parent passe à l'état `CLOSED`. Cela signifie qu'aucun enregistrement de données n'est plus ajouté à la partition. Les enregistrements de données qui auraient été ajoutés à cette partition sont maintenant ajoutés à une partition enfant. Toutefois, des enregistrements de données peuvent encore être extraits de la partition pendant une durée limitée. + **EXPIRED (EXPIRÉ)** : une fois que la période de conservation du flux a expiré, tous les enregistrements de données de la partition parent ont expiré et ne sont plus accessibles. À ce stade, la partition elle-même passe à l'état `EXPIRED`. Les appels de `getStreamDescription().getShards` pour énumérer les partitions du flux n'incluent pas les partitions à l'état `EXPIRED` dans la liste des partitions renvoyées. Pour plus d'informations sur la période de conservation d'un flux, consultez la page [Modifier la période de conservation des données](kinesis-extended-retention.md). Lorsque le repartitionnement est terminé et que le flux a de nouveau l'état `ACTIVE`, vous pouvez commencer immédiatement à lire les données dans les partitions enfant. Cependant, les partitions parentes qui restent après la refonte peuvent toujours contenir des données que vous n'avez pas encore lues et qui ont été ajoutées au flux avant la refonte. Si vous lisez les données des partitions enfant avant d'avoir lu toutes les données des partitions parent, vous pouvez lire les données pour une clé de hachage spécifique sans respecter l'ordre donné par les numéros de séquence des enregistrements de données. Par conséquent, en supposant que l'ordre des données soit important, après un repartitionnement, vous devez toujours continuer à lire les données des partitions parentes jusqu'à leur épuisement. Ensuite seulement, vous devez commencer à lire les données des partitions enfants. Lorsque `getRecordsResult.getNextShardIterator` renvoie `null`, cela indique que vous avez lu toutes les données de la partition parent. # Modifier la période de conservation des données Amazon Kinesis Data Streams prend en charge les modifications de la période de conservation des enregistrements de données de votre flux de données. Le flux de données Kinesis est une séquence ordonnée d'enregistrements de données destinés à être écrits et lus en temps réel. Les enregistrements de données sont donc stockés provisoirement dans des partitions de votre flux. La période entre le moment où un enregistrement est ajouté et celui où il n'est plus accessible est appelée la *période de conservation*. Un flux de données Kinesis stocke des enregistrements pendant 24 heures par défaut, jusqu'à 8 760 heures (365 jours). Vous pouvez mettre à jour la période de rétention via la console Kinesis Data Streams ou en utilisant [IncreaseStreamRetentionPeriod](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_IncreaseStreamRetentionPeriod.html)les opérations et [DecreaseStreamRetentionPeriod](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_DecreaseStreamRetentionPeriod.html). La console Kinesis Data Streams vous permet de modifier en bloc la durée de conservation de plusieurs flux de données à la fois. Vous pouvez augmenter la période de rétention jusqu'à un maximum de 8 760 heures (365 jours) à l'aide de l'[IncreaseStreamRetentionPeriod](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_IncreaseStreamRetentionPeriod.html)opération ou de la console Kinesis Data Streams. Vous pouvez réduire la période de rétention à un minimum de 24 heures à l'aide de l'[DecreaseStreamRetentionPeriod](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_DecreaseStreamRetentionPeriod.html)opération ou de la console Kinesis Data Streams. La syntaxe de demande pour les deux opérations inclut le nom du flux et la période de conservation en heures. Enfin, vous pouvez vérifier la période de conservation actuelle d'un flux en appelant l'opération [DescribeStream](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_DescribeStream.html). Voici un exemple de modification de la période de conservation à l'aide de l' AWS CLI : ``` aws kinesis increase-stream-retention-period --stream-name retentionPeriodDemo --retention-period-hours 72 ``` Lorsque vous augmentez la période de conservation de Kinesis Data Streams, les enregistrements qui étaient auparavant inaccessibles en raison de l'ancienne période de conservation redeviennent accessibles en quelques minutes. Par exemple, si la période de conservation est portée de 24 heures à 48 heures, les enregistrements ajoutés au flux 23 heures 55 minutes auparavant continuent d'être disponibles au bout de 24 heures. Lorsque vous diminuez la période de conservation de Kinesis Data Streams, les enregistrements plus anciens que la nouvelle période de conservation deviennent presque immédiatement inaccessibles. Par conséquent, l'appel de l'opération [DecreaseStreamRetentionPeriod](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_DecreaseStreamRetentionPeriod.html) doit être effectué avec une grande précaution. Définissez votre période de conservation de données de manière à garantir que vos consommateurs pourront lire les données avant leur expiration, si des problèmes se produisent. Vous devez prendre soin de tenir compte de toutes les situations possibles, par exemple d'un problème avec votre logique de traitement des enregistrements ou d'une dépendance en aval hors service pendant une longue période. Considérez la période de conservation comme un filet de sécurité pour accorder davantage de temps à vos consommateurs de données pour extraire des données. Les opérations d'API de période de conservation vous permettent de configurer la période de conservation de manière proactive ou de répondre de manière réactive aux événements opérationnels. Des frais supplémentaires s'appliquent pour les flux dont la période de conservation définie est supérieure à 24 heures. Pour en savoir plus, consultez la [Tarification Amazon Kinesis Data Streams](https://aws.amazon.com/kinesis/data-streams/pricing/). # Étiquetez vos ressources Amazon Kinesis Data Streams *Vous pouvez attribuer vos propres métadonnées aux flux et aux consommateurs de fans améliorés que vous créez dans Amazon Kinesis Data Streams sous forme de balises.* Une balise est une paire clé-valeur que vous définissez pour un flux. L'utilisation de balises est un moyen simple mais puissant de gérer les AWS ressources et d'organiser les données, y compris les données de facturation. **Topics** + [Passez en revue les bases des tags](#tagging-basics) + [Suivez les coûts à l'aide du balisage](#tagging-billing) + [Comprendre les restrictions relatives aux balises](#tagging-restrictions) + [Étiquetez les flux à l'aide de la console Kinesis Data Streams](#tagging-console) + [Étiquetez les flux à l'aide du AWS CLI](#tagging-cli) + [Étiquetez les flux à l'aide des Kinesis Data Streams APIs](#tagging-api) + [Taguez les consommateurs à l'aide du AWS CLI](#tagging-consumers-cli) + [Identifiez les consommateurs à l'aide des Kinesis Data Streams APIs](#tagging-consumers-api) ## Passez en revue les bases des tags Les ressources Kinesis Data Streams que vous pouvez baliser incluent les flux de données et les consommateurs fans améliorés. Vous utilisez la console AWS CLI Kinesis Data Streams ou l'API Kinesis Data Streams pour effectuer les tâches suivantes : + Création d'une ressource avec des balises + Ajouter des balises à une ressource + Répertoriez les balises de vos ressources + Supprimer les balises d'une ressource **Note** La console Kinesis Data Streams ne permet pas d'appliquer de tags à des clients fans avertis. Pour appliquer des tags aux consommateurs, utilisez l' AWS CLI API Kinesis Data Streams. Vous pouvez également utiliser des balises pour classer vos ressources par catégorie. Par exemple, vous pouvez classer les ressources par objectif, propriétaire ou environnement. Dans la mesure où vous avez défini la clé et la valeur de chaque balise, vous pouvez créer un ensemble personnalisé de catégories répondant à vos besoins spécifiques. Par exemple, vous pouvez définir un ensemble de balises qui vous aident à suivre les ressources par propriétaire et par application associée. Voici quelques exemples de balises : + Projet : nom du projet + Propriétaire : nom + Objectif : test de la charge + Application : nom de l'application + Environnement : production **Important** Pour ajouter des balises lors de la création d'un flux, vous devez inclure les `kinesis:AddTagsToStream` autorisations `kinesis:CreateStream` et pour ce flux. Vous **ne pouvez pas utiliser** l'`kinesis:TagResource`autorisation pour baliser des flux lors de leur création. Pour ajouter des balises lors de l'enregistrement du consommateur, vous devez inclure les `kinesis:RegisterStreamConsumer` autorisations `kinesis:TagResource` et. ## Suivez les coûts à l'aide du balisage Vous pouvez utiliser des balises pour classer et suivre vos AWS coûts. Lorsque vous appliquez des balises à vos ressources Kinesis Data Streams, AWS votre rapport de répartition des coûts inclut l'utilisation et les coûts agrégés par balises. Vous pouvez appliquer des balises représentant des catégories commerciales, telles que les centres de coûts, les noms d'applications ou les propriétaires, afin d'organiser vos coûts entre plusieurs services. Pour plus d'informations, consultez [Utilisation des identifications de répartition des coûts pour les rapports de facturation personnalisés](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html) dans le *Guide de l'utilisateur AWS Billing *. ## Comprendre les restrictions relatives aux balises Les restrictions suivantes s’appliquent aux balises : **Restrictions de base** + Le nombre maximum de balises pour chaque ressource est de 50. + Les clés et valeurs d’étiquette sont sensibles à la casse. + Vous ne pouvez pas changer ou modifier les balises d'une ressource supprimée. **Restrictions relatives aux clés de balise** + Chaque clé de balise doit être unique. Si vous ajoutez une balise avec une clé qui est déjà en cours d’utilisation, la nouvelle balise remplace la paire clé-valeur existante. + Vous ne pouvez pas commencer une clé de balise par, `aws:` car ce préfixe est réservé à l'usage de AWS. AWS crée des balises qui commencent par ce préfixe en votre nom, mais vous ne pouvez ni les modifier ni les supprimer. + Les clés de balise doivent comporter entre 1 et 128 caractères Unicode. + Les clés de balise doivent comporter les caractères suivants : lettres Unicode, chiffres, espaces et les caractères spéciaux suivants :`_ . / = + - @`. **Restrictions relatives à la valeur de balise** + Les valeurs de balise doivent comporter entre 0 et 255 caractères Unicode. + Les valeurs de balise peuvent être vides. Si tel n'est pas le cas, elles doivent être composées des caractères suivants : lettres Unicode, chiffres, espaces et les caractères spéciaux suivants :`_ . / = + - @`. ## Étiquetez les flux à l'aide de la console Kinesis Data Streams Vous pouvez ajouter, mettre à jour, répertorier et supprimer des balises sur vos flux à l'aide de la console Kinesis Data Streams. **Pour afficher les balises d'un flux** 1. [Connectez-vous à la console Kinesis AWS Management Console et ouvrez-la à https://console.aws.amazon.com l'adresse /kinesis.](https://console.aws.amazon.com/kinesis) 1. Dans le volet de navigation de gauche, choisissez **Data streams**. 1. Sur la page **Flux de données**, choisissez le flux que vous souhaitez baliser. 1. Sur la page des détails du flux, choisissez **Configuration**. 1. Dans la section **Tags**, visualisez les tags appliqués au flux. **Pour créer un flux de données avec une balise** 1. Ouvrez la console Kinesis Data Streams. 1. Dans le volet de navigation de gauche, choisissez **Data streams**. 1. Choisissez **Create data stream (Créer un flux de données)**. 1. Sur la page **Créer un flux de données**, entrez le nom de votre flux de données. 1. Pour la **capacité du flux de données**, choisissez le mode **à la demande** ou le mode Capacité **provisionnée**. Pour plus d'informations sur les modes de capacité, consultez[Choisissez le bon mode pour diffuser](how-do-i-size-a-stream.md). 1. Dans la section **Tags**, procédez comme suit : 1. Sélectionnez **Ajouter une nouvelle balise**. 1. Pour **Clé**, entrez la balise et spécifiez éventuellement une valeur dans le champ **Valeur**. Si une erreur s'affiche, cela signifie que la clé ou la valeur de balise que vous avez spécifiée ne respecte pas les restrictions de balise. Pour de plus amples informations, veuillez consulter [Comprendre les restrictions relatives aux balises](#tagging-restrictions). 1. Choisissez **Create data stream (Créer un flux de données)**. **Pour ajouter ou mettre à jour un tag dans un stream** 1. Ouvrez la console Kinesis Data Streams. 1. Dans le volet de navigation de gauche, choisissez **Data streams**. 1. Sur la page **Flux de données**, choisissez le flux auquel vous souhaitez ajouter ou mettre à jour des balises. 1. Sur la page des détails du flux, choisissez **Configuration**. 1. Dans la section **Balises** choisissez **Gérer les balises**. 1. Sous **Balises**, effectuez l'une des opérations suivantes : + Pour ajouter une nouvelle balise, choisissez **Ajouter une nouvelle balise**, puis entrez les données de **clé** et de **valeur** de la balise. Répétez cette étape autant de fois que nécessaire. Le nombre maximum de balises que vous pouvez ajouter pour chaque flux est de 50. + Pour mettre à jour une balise existante, entrez une nouvelle valeur de balise dans le champ **Valeur** de la **clé** de cette balise. Si une erreur s'affiche, cela signifie que la clé ou la valeur de balise que vous avez spécifiée ne respecte pas les restrictions de balise. Pour de plus amples informations, veuillez consulter [Comprendre les restrictions relatives aux balises](#tagging-restrictions). 1. Sélectionnez **Save Changes (Enregistrer les modifications)**. **Pour supprimer une balise d'un flux** 1. Ouvrez la console Kinesis Data Streams. 1. Dans le volet de navigation de gauche, choisissez **Data streams**. 1. Sur la page **Flux de données**, choisissez le flux dont vous souhaitez supprimer les balises. 1. Sur la page des détails du flux, choisissez **Configuration**. 1. Dans la section **Balises** choisissez **Gérer les balises**. 1. Recherchez la paire **clé** et **valeur** de balise que vous souhaitez supprimer. Puis choisissez **Supprimer**. 1. Sélectionnez **Enregistrer les modifications**. ## Étiquetez les flux à l'aide du AWS CLI Vous pouvez ajouter, répertorier et supprimer des balises sur vos flux à l'aide du AWS CLI. Pour obtenir des exemples, consultez la documentation suivante : [créer un flux](https://docs.aws.amazon.com/cli/latest/reference/kinesis/create-stream.html) Crée un flux avec des balises. [add-tags-to-stream](https://docs.aws.amazon.com/cli/latest/reference/kinesis/add-tags-to-stream.html) Ajoute ou met à jour les balises du flux spécifié. [list-tags-for-stream](https://docs.aws.amazon.com/cli/latest/reference/kinesis/list-tags-for-stream.html) Répertorie les balises du flux spécifié. [remove-tags-from-stream](https://docs.aws.amazon.com/cli/latest/reference/kinesis/remove-tags-from-stream.html) Supprime les balises du flux spécifié. ## Étiquetez les flux à l'aide des Kinesis Data Streams APIs Vous pouvez ajouter, répertorier et supprimer des balises sur vos flux à l'aide des Kinesis Data APIs Streams. Pour obtenir des exemples, consultez la documentation suivante : [CreateStream](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_CreateStream.html) Crée un flux avec des balises. [AddTagsToStream](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_AddTagsToStream.html) Ajoute ou met à jour les balises du flux spécifié. [ListTagsForStream](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_ListTagsForStream.html) Répertorie les balises du flux spécifié. [RemoveTagsFromStream](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_RemoveTagsFromStream.html) Supprime les balises du flux spécifié. ## Taguez les consommateurs à l'aide du AWS CLI Vous pouvez ajouter, répertorier et supprimer des tags sur vos clients à l'aide du AWS CLI. Pour obtenir des exemples, consultez la documentation suivante : [register-stream-consumer](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kinesis/register-stream-consumer.html) Enregistre un consommateur pour un flux de données Kinesis avec des balises. [tag-resource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kinesis/tag-resource.html) Ajoute ou met à jour les balises pour la ressource Kinesis spécifiée. [list-tags-for-resource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kinesis/list-tags-for-resource.html) Répertorie les balises de la ressource Kinesis spécifiée. [untag-resource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kinesis/untag-resource.html) Supprime les balises de la ressource Kinesis spécifiée. ## Identifiez les consommateurs à l'aide des Kinesis Data Streams APIs Vous pouvez ajouter, répertorier et supprimer des tags sur vos clients à l'aide des Kinesis Data APIs Streams. Pour obtenir des exemples, consultez la documentation suivante : [RegisterStreamConsumer](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_RegisterStreamConsumer.html) Enregistre un consommateur pour un flux de données Kinesis avec des balises. [TagResource](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_TagResource.html) Ajoute ou met à jour les balises pour la ressource Kinesis spécifiée. [ListTagsForResource](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_ListTagsForResource.html) Répertorie les balises de la ressource Kinesis spécifiée. [UntagResource](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_UntagResource.html) Supprime les balises de la ressource Kinesis spécifiée. # Gérez de gros disques Amazon Kinesis Data Streams prend en charge les enregistrements jusqu'à 10 mégaoctets (). MiBs Cette fonctionnalité est recommandée pour traiter des charges utiles de données intermittentes qui dépassent la limite de taille d'enregistrement par défaut de 1 MiB. La taille d'enregistrement maximale par défaut pour les flux existants et nouvellement créés est fixée à 1 MiB. Cette fonctionnalité profite aux applications de l'Internet des objets (IoT), aux pipelines de capture des données modifiées (CDC) et aux flux de travail d'apprentissage automatique qui nécessitent le traitement de charges utiles de données parfois plus importantes. Pour commencer à utiliser des enregistrements volumineux dans votre flux, mettez à jour la taille maximale d'enregistrement de votre flux. **Important** La limite de débit de partition individuelle de 1 MB/s pour les écritures et de 2 MB/s pour les lectures reste inchangée, compte tenu de la prise en charge de tailles d'enregistrement plus importantes. Kinesis Data Streams est conçu pour prendre en charge des enregistrements volumineux intermittents ainsi qu'un trafic de base d'enregistrements inférieur ou égal à 1 MiB. Il n'est pas conçu pour permettre l'ingestion prolongée de volumes élevés et records. ## Mettez à jour votre stream pour utiliser des enregistrements volumineux **Pour traiter des enregistrements plus volumineux avec Kinesis Data Streams** 1. Accédez à la console Kinesis Data Streams. 1. Sélectionnez votre stream, puis accédez à l'onglet **Configuration**. 1. Cliquez sur **Modifier**, qui se trouve à côté de **Taille maximale d'enregistrement**. 1. Définissez la taille maximale de votre enregistrement (jusqu'à 10 MiB). 1. Enregistrez vos modifications. Ce paramètre ajuste uniquement la taille d'enregistrement maximale pour ce flux de données Kinesis. Avant d'augmenter cette limite, vérifiez que toutes les applications en aval peuvent gérer des enregistrements plus volumineux. Vous pouvez également mettre à jour ce paramètre à l'aide de la AWS CLI : ``` aws kinesis update-max-record-size \ --stream-arn \ --max-record-size-in-ki-b 5000 ``` ## Optimisez les performances de votre streaming avec des enregistrements volumineux Il est recommandé de conserver des enregistrements volumineux à moins de 2 % de votre trafic global. Dans un flux, chaque partition a une capacité de débit de 1 MiB par seconde. Pour gérer des enregistrements volumineux, Kinesis Data diffuse des données en rafale jusqu'à 10 MiBs, avec une moyenne de 1 MiB par seconde. Cette capacité à prendre en charge des enregistrements volumineux est continuellement réinjectée dans le flux. Le taux de remplissage dépend de la taille des grands enregistrements et de la taille de l'enregistrement de référence. Pour de meilleurs résultats, utilisez une clé de partition uniformément distribuée. Pour plus d'informations sur l'évolution de Kinesis On-Demand, consultez la section [Fonctionnalités et cas d'utilisation du mode à la demande](how-do-i-size-a-stream.html#ondemandmode). ## Atténuez le ralentissement avec des enregistrements volumineux **Pour atténuer l'étranglement** 1. Implémentez une logique de nouvelle tentative avec un ralentissement exponentiel dans votre application de production. 1. Utilisez des clés de partition aléatoires pour répartir les enregistrements volumineux sur les partitions disponibles. 1. Stockez les charges utiles dans Amazon S3 et envoyez uniquement des références de métadonnées au flux pour les flux continus d'enregistrements volumineux. Pour plus d'informations, consultez la section [Traitement d'enregistrements volumineux avec Amazon Kinesis Data Streams](https://aws.amazon.com/blogs/big-data/processing-large-records-with-amazon-kinesis-data-streams/). ## Gérez des enregistrements volumineux à l'aide des Kinesis Data Streams APIs La prise en charge des enregistrements volumineux introduit une nouvelle API et met à jour deux plans de contrôle existants APIs pour gérer jusqu'à 10 enregistrements MiBs. API pour modifier la taille des enregistrements : + `UpdateMaxRecordSize`: Configure la limite maximale de taille d'enregistrement pour les flux existants jusqu'à 10 MiBs. Mises à jour des éléments existants APIs : + `CreateStream`: ajoute le `MaxRecordSizeInKiB` paramètre facultatif permettant de définir des limites de taille d'enregistrement lors de la création du flux. + `DescribeStreamSummary`: renvoie le `MaxRecordSizeInKiB` champ pour afficher la configuration actuelle du flux. Tous les flux APIs répertoriés sont rétrocompatibles avec les flux existants. Pour consulter la documentation complète des API, consultez le manuel [Amazon Kinesis Data Streams Service API Reference](https://docs.aws.amazon.com/kinesis/latest/APIReference/Welcome.html). ## AWS composants compatibles avec les grands disques Les AWS composants suivants sont compatibles avec les enregistrements de grande taille : | Composant | Description | | --- | --- | | AWS SDK | AWS Le SDK prend en charge la gestion d'enregistrements volumineux. Vous pouvez mettre à jour la taille d'enregistrement maximale de votre flux jusqu'à 10 MiB en utilisant les méthodes disponibles dans le. AWS SDKs Pour plus d'informations, consultez la section [Utilisation de ce service avec un AWS SDK.](https://docs.aws.amazon.com/streams/latest/dev/sdk-general-information-section.html) | | Bibliothèque Kinesis Consumer (KCL) | À partir de la version 2.x, KCL prend en charge la gestion des enregistrements volumineux. Pour utiliser le support d'enregistrements volumineux, mettez à jour votre stream et utilisez KCL. `maxRecordSize` Pour plus d'informations, consultez la section [Utiliser la bibliothèque cliente Kinesis](https://docs.aws.amazon.com/streams/latest/dev/kcl.html). | | Bibliothèque Kinesis Producer (KPL) | À partir de la version 1.0.5, KPL prend en charge la gestion des enregistrements volumineux. Pour utiliser le support d'enregistrements volumineux, mettez à jour votre stream et utilisez KPL. maxRecordSize Pour plus d'informations, consultez [Développer des producteurs à l'aide de la bibliothèque Amazon Kinesis Producer Library (KPL)](https://docs.aws.amazon.com/streams/latest/dev/developing-producers-with-kpl.html). | | Amazon EMR | Amazon EMR avec Apache Spark prend en charge le traitement d'enregistrements volumineux jusqu'à la limite de Kinesis Data Streams (10). MiBs Pour utiliser le support d'enregistrements volumineux, utilisez la `readStream` fonction. Pour plus d'informations, consultez la section [Intégration d'Amazon EMR et d'Amazon Kinesis](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-kinesis.html). | | Amazon Data Firehose | Lorsqu'il est utilisé avec Kinesis Data Streams, le comportement d'Amazon Data Firehose avec des enregistrements volumineux dépend de la destination de livraison : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/streams/latest/dev/large-records.html) Pour les applications nécessitant une livraison à Snowflake ou Redshift avec des enregistrements volumineux, transmettez d'abord les données à Amazon S3. Ensuite, utilisez les processus d'extraction, de transformation, de chargement (ETL) pour charger les données. Pour toutes les autres destinations, testez le comportement avec des enregistrements volumineux dans un proof-of-concept environnement avant de l'adapter à l'utilisation en production. La gestion de gros dossiers varie selon la destination. | | AWS Lambda | AWS Lambda prend en charge des charges utiles jusqu'à 6 MiBs. Cette limite inclut la charge utile Kinesis convertie en codage base-64 et les métadonnées associées au mappage des sources d'événements (ESM). Pour les enregistrements inférieurs à 6 MiBs, Lambda les traite à l'aide d'ESM sans qu'aucune configuration supplémentaire ne soit requise. Pour les enregistrements supérieurs à 6 MiBs, Lambda les traite en utilisant une destination en cas de défaillance. Vous devez configurer une destination en cas de panne à l'aide d'ESM pour gérer les enregistrements qui dépassent les limites de traitement de Lambda. Chaque événement envoyé à la destination en cas d'échec est un document JSON contenant des métadonnées relatives à l'échec de l'invocation. Il est recommandé de créer une destination en cas de défaillance dans l'ESM, quelle que soit la taille de l'enregistrement. Cela garantit qu'aucun enregistrement n'est supprimé. Pour plus d'informations, voir [Configuration des destinations en cas d'échec des appels.](https://docs.aws.amazon.com/lambda/latest/dg/kinesis-on-failure-destination.html#kinesis-on-failure-destination-console) | | Amazon Redshift | Amazon Redshift prend uniquement en charge les tailles d'enregistrement inférieures à 1 MiB lors du streaming de données depuis Kinesis Data Streams. Les enregistrements qui dépassent cette limite ne sont pas traités. Les enregistrements qui ne sont pas traités sont enregistrés sous le nom de`sys_stream_scan_errors`. Pour plus d'informations, consultez [SYS\$1STREAM\$1SCAN\$1ERRORS](https://docs.aws.amazon.com/redshift/latest/dg/r_SYS_STREAM_SCAN_ERRORS.html). | | Connecteur Flink pour Kinesis Data Streams | Il existe deux approches pour consommer les données issues de Kinesis Data Streams : le connecteur source Kinesis et le connecteur Kinesis Sink. Le connecteur source prend en charge le traitement des enregistrements inférieurs à 1 MiB et jusqu'à 10. MiBs N'utilisez pas le connecteur récepteur pour les enregistrements supérieurs à 1 MiB. Pour plus d'informations, consultez [Utiliser des connecteurs pour déplacer des données dans Amazon Managed Service pour Apache Flink avec l' DataStreamAPI](https://docs.aws.amazon.com/managed-flink/latest/java/how-connectors.html). | ## Régions où les enregistrements volumineux sont pris en charge Cette fonctionnalité Amazon Kinesis Data Streams n'est disponible que dans les régions AWS suivantes : | AWS Région | Nom de la région | | --- | --- | | eu-north-1 | Europe (Stockholm) | | me-south-1 | Middle East (Bahrain) | | ap-south-1 | Asie-Pacifique (Mumbai) | | eu-west-3 | Europe (Paris) | | ap-southeast-3 | Asie-Pacifique (Jakarta) | | us-east-2 | USA Est (Ohio) | | af-south-1 | Afrique (Le Cap) | | eu-west-1 | Europe (Irlande) | | me-central-1 | Moyen-Orient (EAU) | | eu-central-1 | Europe (Francfort) | | sa-east-1 | Amérique du Sud (São Paulo) | | ap-east-1 | Asie-Pacifique (Hong Kong) | | ap-south-2 | Asie-Pacifique (Hyderabad) | | us-east-1 | USA Est (Virginie du Nord) | | ap-northeast-2 | Asie-Pacifique (Séoul) | | ap-northeast-3 | Asie-Pacifique (Osaka) | | eu-west-2 | Europe (Londres) | | ap-southeast-4 | Asie-Pacifique (Melbourne) | | ap-northeast-1 | Asie-Pacifique (Tokyo) | | us-west-2 | USA Ouest (Oregon) | | us-west-1 | USA Ouest (Californie du Nord) | | ap-southeast-1 | Asie-Pacifique (Singapour) | | ap-southeast-2 | Asie-Pacifique (Sydney) | | il-central-1 | Israël (Tel Aviv) | | ca-central-1 | Canada (Centre) | | ca-west-1 | Canada-Ouest (Calgary) | | eu-south-2 | Europe (Espagne) | | cn-northwest-1 | Chine (Ningxia) | | eu-central-2 | Europe (Zurich) | | us-gov-east-1 | AWS GovCloud (USA Est) | | us-gov-west-1 | AWS GovCloud (US-Ouest) | # Réalisez des tests de résilience avec AWS Fault Injection Service AWS Fault Injection Service est un service entièrement géré qui vous permet de réaliser des expériences d'injection de défauts sur vos AWS charges de travail. AWS FIS l'intégration avec Amazon Kinesis Data Streams vous permet de tester la résilience de votre application par rapport aux erreurs courantes de l'API Amazon Kinesis Data Streams dans un environnement contrôlé. Cette fonctionnalité vous permet de valider la gestion des erreurs, de réessayer la logique et de surveiller les systèmes avant qu'ils ne rencontrent des défaillances. Pour plus d'informations, voir [Qu'est-ce que c'est AWS Fault Injection Service ?](https://docs.aws.amazon.com/fis/latest/userguide/what-is.html) . **Actions** + Erreur interne de l'API : cela injecte des erreurs internes dans les demandes effectuées par le rôle IAM cible. La réponse spécifique dépend de chaque service et de chaque API. L'action `aws:fis:inject-api-internal-error` crée `InternalFailure` des erreurs (HTTP 500). + Erreur d'accélération de l'API : cela injecte des erreurs internes dans les demandes effectuées par le rôle IAM cible. La réponse spécifique dépend de chaque service et de chaque API. L'action `aws:fis:inject-api-throttle-error` crée `ThrottlingException` des erreurs (HTTP 400). + Erreur d'indisponibilité de l'API : cela injecte des erreurs internes dans les demandes effectuées par le rôle IAM cible. La réponse spécifique dépend de chaque service et de chaque API. L'action `aws:fis:inject-api-unavailable-error` crée `ServiceUnavailable` des erreurs (HTTP 503). + Exception de débit provisionnée par l'API : cela injecte des erreurs internes dans les demandes effectuées par le rôle IAM cible. La réponse spécifique dépend de chaque service et de chaque API. L'action `aws:kinesis:inject-api-provisioned-throughput-exception` crée `ProvisionedThroughputExceededException` des erreurs (HTTP 400). + Exception d'itérateur d'API expirée : cela injecte des erreurs internes dans les demandes effectuées par le rôle IAM cible. La réponse spécifique dépend de chaque service et de chaque API. L'action `aws:kinesis:inject-api-expired-iterator-exception` crée `ExpiredIteratorException` des erreurs (HTTP 400). Pour plus d'informations, consultez les [actions Amazon Kinesis Data Streams](https://docs.aws.amazon.com/fis/latest/userguide/fis-actions-reference.html#aws-kinesis-actions). **Considérations** + Vous pouvez utiliser les actions ci-dessus avec les offres provisionnées et à la demande pour Amazon Kinesis Data Streams. + Votre diffusion reprend une fois l'expérience terminée, en fonction de la durée sélectionnée. Vous pouvez également arrêter un test en cours avant qu'il ne soit terminé. Vous pouvez également définir une condition d'arrêt pour arrêter l'expérience en fonction des alarmes qui définissent l'état de l'application dans un Amazon CloudWatch Application Insights. + Vous pouvez tester jusqu'à 280 flux. Pour plus d'informations sur le support régional, consultez la section [AWS Fault Injection Service Points de terminaison et quotas](https://docs.aws.amazon.com/general/latest/gr/fis.html). # Erreurs d'exception relatives au débit provisionné Des erreurs exceptionnelles de dépassement du débit provisionné (HTTP 400) se produisent lorsque le taux de demandes pour un flux Kinesis dépasse les limites de débit d'une ou de plusieurs partitions. Chaque partition possède des limites de capacité de lecture et d'écriture spécifiques, et le dépassement de ces limites déclenche cette exception. Les scénarios à l'origine de cette exception incluent : des pics soudains d'ingestion ou de consommation de données, une capacité de partition insuffisante pour le volume de données traité ou une distribution inégale des clés de partition. **Recommandations relatives à la gestion des exceptions** + Mettez en œuvre des mécanismes de temporisation et de réessai exponentiels. + Augmentez le nombre de partitions pour répondre à un débit plus élevé. + Assurez-vous que les clés de partition sont correctement distribuées. + Surveillez les statistiques des flux. En outre, l'utilisation du mode de capacité à la demande de Kinesis permet d'ajuster automatiquement les charges de travail et de minimiser l'occurrence de cette exception. Pour plus d’informations, consultez [Qu’est-ce qu’ AWS Fault Injection Service ?](https://docs.aws.amazon.com/fis/latest/userguide/what-is.html) **Note** Les problèmes de distribution inappropriés ne sont pas liés à la capacité du mode à la demande du dimensionnement automatique. **Pour effectuer une expérience de base** 1. Utilisez des mesures de référence : enregistrez les modèles de débit normaux avant les tests. 1. Créez une expérience : utilisez l'`aws:kinesis:inject-api-provisioned-throughput-exception`action. 1. Configurez l'intensité : commencez par une limitation de 25 % des demandes. 1. Surveillez les réponses : vérifiez la logique des nouvelles tentatives avec un recul exponentiel. 1. Validez le dimensionnement : vérifiez que l'auto-scaling déclenche l'activation. 1. Vérifiez les alarmes : assurez-vous que les `CloudWatch` alarmes fonctionnent comme prévu. Les applications doivent mettre en œuvre des stratégies de sauvegarde, de surveillance `WriteProvisionedThroughputExceeded` et de `ReadProvisionedThroughputExceeded` mesures appropriées, et déclencher le dimensionnement des partitions le cas échéant. **Détails de l'action** + **Type de ressource** : ARN du rôle IAM + **Opérations cibles** :`PutRecord`,`PutRecords`, `GetRecords` + ****Code d'erreur**** : `ProvisionedThroughputExceededException` (HTTP 400) + ****Description**** : simule des scénarios dans lesquels le taux de demandes dépasse les limites de capacité des partitions, teste la régulation des applications et redimensionne les réponses. **Parameters** + **ARN du rôle IAM** : rôle utilisé par votre application pour les opérations Kinesis Data Streams. + **Opérations** : opérations cibles :`PutRecord`,`PutRecords`,`GetRecords`. + **Liste des ressources** : les noms de flux ou les identifiants de partition spécifiques. + **Durée** : durée de l'expérience, qui est comprise entre une minute et 12 heures. Dans l' AWS FIS API, la valeur est une chaîne au format ISO 8601. Par exemple, PT1 M représente une minute. Dans la AWS FIS console, vous entrez le nombre de secondes, de minutes ou d'heures. + **Intensité** : pourcentage de demandes à limiter. **Autorisations requises** + `kinesis:InjectApiError` Exemple de modèle d'expérience L'exemple suivant montre une exception de débit provisionné pour toutes les demandes contenant jusqu'à 5 flux Kinesis Data avec la balise spécifiée. AWS FIS sélectionne les flux à affecter de manière aléatoire. Après 5 minutes, le défaut est supprimé. ``` { "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" } } ``` Exemple d'autorisations liées aux rôles d'expérimentation L'autorisation suivante vous permet d'exécuter les `aws:kinesis:stream-expired-iterator-exception` actions `aws:kinesis:stream-provisioned-throughput-exception` et sur un flux spécifique qui ont un impact sur 50 % des demandes. # Erreurs d'exception d'itérateur expirées Les erreurs d'exception d'itérateur expiré (HTTP 400) se produisent lorsque l'itérateur de partition expire et n'est plus utilisé pour récupérer des enregistrements de flux lors d'un appel. `GetRecords` Cela se produit lorsqu'il y a des retards entre les opérations de lecture, en raison de tâches de traitement de données de longue durée, de problèmes de réseau ou d'indisponibilité des applications. **Note** Un itérateur de partition est valide pendant 5 minutes après son émission. **Recommandations relatives à la gestion des exceptions** + Actualisation des itérateurs de partitions avant leur expiration. + Intégration de la gestion des erreurs pour obtenir de nouveaux itérateurs. + Utilisation de la bibliothèque cliente Kinesis Kinesis (KCL) qui gère automatiquement l'expiration des itérateurs de partitions. Pour plus d'informations, voir [Qu'est-ce que c'est AWS Fault Injection Service ?](https://docs.aws.amazon.com/fis/latest/userguide/what-is.html) **Pour effectuer une expérience de base** 1. Créez un modèle d'expérience : utilisez la AWS FIS console. 1. Sélectionnez l'action : utilisez l'`aws:kinesis:inject-api-expired-iterator-exception`action. 1. Configurez les cibles : spécifiez le rôle IAM et Kinesis Data Streamsoperations. 1. Définissez la durée : commencez par 5 à 10 minutes pour le test initial. 1. Ajouter des conditions d'[arrêt : conditions d'arrêt pour AWS FIS](https://docs.aws.amazon.com/fis/latest/userguide/stop-conditions.html). 1. Exécutez l'expérience : surveillez le comportement de l'application. **Détails de l'action** + **Type de ressource** : ARN du rôle IAM + **Opérations cibles** : `GetRecords` + ****Code d'erreur**** : `ExpiredIteratorException` (HTTP 400) + ****Description**** : l'itérateur fourni dépasse l'âge maximum autorisé, simulant des scénarios dans lesquels le traitement des enregistrements est trop lent ou où la logique de pointage échoue. **Parameters** + **ARN du rôle IAM** : rôle utilisé par votre application pour les opérations Kinesis Data Streams. + **Opérations** : opérations cibles : `GetRecords` + **Liste des ressources** : les noms de flux spécifiques ou ARNs. + **Durée : durée** de l'expérience. Ceci est configurable. + **Intensité** : pourcentage de demandes à limiter. **Autorisations requises** + `kinesis:InjectApiError`