

Après mûre réflexion, nous avons décidé de mettre fin à Amazon Kinesis Data Analytics pour les applications SQL :

1. À compter du **1er septembre 2025,** nous ne fournirons aucune correction de bogue pour les applications Amazon Kinesis Data Analytics for SQL, car leur support sera limité, compte tenu de l'arrêt prochain.

2. À compter du **15 octobre 2025,** vous ne pourrez plus créer de nouvelles applications Kinesis Data Analytics for SQL.

3. Nous supprimerons vos candidatures à compter **du 27 janvier 2026**. Vous ne serez pas en mesure de démarrer ou d'utiliser vos applications Amazon Kinesis Data Analytics for SQL. Support ne sera plus disponible pour Amazon Kinesis Data Analytics for SQL à partir de cette date. Pour de plus amples informations, veuillez consulter [Arrêt d'Amazon Kinesis Data Analytics pour les applications SQL](discontinuation.md).

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.

# Configuration de la sortie d'application
<a name="how-it-works-output"></a>



Dans le code de votre application, vous écrivez le résultat des instructions SQL dans un ou plusieurs flux intégrés à l'application. Vous pouvez éventuellement ajouter une configuration de sortie à votre application pour conserver tout ce qui est écrit dans un flux intégré à l'application vers une destination externe, telle qu'un flux de données Amazon Kinesis, un flux de diffusion Firehose ou une fonction. AWS Lambda 

Le nombre de destinations externes que vous pouvez utiliser pour conserver la sortie d'une application est limité. Pour de plus amples informations, veuillez consulter [Limites](limits.md). 

**Note**  
Nous vous recommandons d'utiliser une destination externe pour conserver les données du flux d'erreurs intégré à l'application pour pouvoir examiner les erreurs. 



Dans chacune de ces configurations de sortie, vous fournissez les éléments suivants :
+ **Nom du flux intégré à l'application** : flux que vous souhaitez conserver dans une destination externe. 

  Kinesis Data Analytics recherche le flux intégré à l’application que vous avez spécifié dans la configuration de sortie. (Le nom du flux distingue les majuscules et minuscules et doit correspondre exactement.) Assurez-vous que le code de votre application crée ce flux intégré à l'application. 
+ **Destination externe** : vous pouvez conserver les données dans un flux de données Kinesis, un flux de diffusion Firehose ou une fonction Lambda. Vous fournissez le Amazon Resource Name (ARN) du flux ou de la fonction. Vous pouvez également fournir un rôle IAM que Kinesis Data Analytics peut endosser pour écrire dans le flux ou la fonction en votre nom. Vous décrivez également le format d’enregistrement (JSON, CSV) que Kinesis Data Analytics doit utiliser lors de l’écriture dans la destination externe.

Si Kinesis Data Analytics ne peut pas écrire dans la destination de streaming ou Lambda, il continue d’essayer indéfiniment. Cela crée une pression de retour qui peut amener votre application à prendre du retard. Si ce problème n'est pas résolu, votre application finira par arrêter de traiter de nouvelles données. Vous pouvez surveiller les [Métriques de données Kinesis Analytics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/aka-metricscollected.html) et définir des alarmes d'échec. Pour plus d'informations sur les métriques et les alarmes, consultez les sections [Utilisation d'Amazon CloudWatch Metrics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/working_with_metrics.html) et [Création d' CloudWatchalarmes Amazon](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html).

Vous pouvez configurer la sortie d'application à l'aide de l' AWS Management Console. La console effectue l'appel d'API pour enregistrer la configuration. 

## Création d'une sortie à l'aide du AWS CLI
<a name="how-it-works-output-cli"></a>

Cette section explique comment créer la section `Outputs` du corps de la requête pour une opération `CreateApplication` ou `AddApplicationOutput`.

### Création d’une sortie de flux Kinesis
<a name="how-it-works-output-cli-streams"></a>

Le fragment JSON suivant montre la section `Outputs` dans le corps de la requête `CreateApplication` qui permet de créer une destination de flux de données Amazon Kinesis.

```
"Outputs": [
   {
       "DestinationSchema": {
           "RecordFormatType": "string"
       },
       "KinesisStreamsOutput": {
           "ResourceARN": "string",
           "RoleARN": "string"
       },
       "Name": "string"
   }
 
]
```

### Création d'une sortie Firehose Delivery Stream
<a name="how-it-works-output-cli-firehose"></a>

Le fragment JSON suivant montre la `Outputs` section du corps de la `CreateApplication` demande permettant de créer une destination de flux de diffusion Amazon Data Firehose.

```
"Outputs": [
   {
       "DestinationSchema": {
           "RecordFormatType": "string"
       },
       "KinesisFirehoseOutput": {
           "ResourceARN": "string",
           "RoleARN": "string"
       },
       "Name": "string"
   }
]
```

### Création d’une sortie de fonction Lambda
<a name="how-it-works-output-cli-lambda"></a>

Le fragment JSON suivant montre la `Outputs` section du corps de la `CreateApplication` demande permettant de créer une destination de AWS Lambda fonction.

```
"Outputs": [
   {
       "DestinationSchema": {
           "RecordFormatType": "string"
       },
       "LambdaOutput": {
           "ResourceARN": "string",
           "RoleARN": "string"
       },
       "Name": "string"
   }
]
```

# Utilisation d'une fonction Lambda en tant que sortie
<a name="how-it-works-output-lambda"></a>

L'utilisation AWS Lambda comme destination vous permet d'effectuer plus facilement le post-traitement de vos résultats SQL avant de les envoyer vers une destination finale. Les tâches de post-traitement courantes sont les suivantes :
+ Agrégation de plusieurs lignes dans un seul enregistrement
+ Combinaison des résultats actuels avec des résultats antérieurs afin de mieux gérer les données tardives
+ Diffusion vers différentes destinations en fonction du type d'information
+ Traduction des formats d'enregistrement (par exemple, traduction en Protobuf)
+ Manipulation ou transformation des chaînes
+ Enrichissement des données après traitement analytique
+ Traitement personnalisé pour les cas d'utilisation de géolocalisation
+ Chiffrement des données

Les fonctions Lambda peuvent fournir des informations analytiques à divers AWS services et à d'autres destinations, notamment les suivantes :
+ [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/)
+ Personnalisé APIs
+ [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/)
+ [Amazon Aurora](http://aurora.apache.org/)
+ [Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/dg/)
+ [Amazon Simple Notification Service (Amazon SNS)](https://docs.aws.amazon.com/sns/latest/dg/)
+ [Amazon Simple Queue Service (Amazon SQS)](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/)
+ [Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/)

Pour plus d’informations sur la création d’applications Lambda, consultez [Mise en route avec AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html).

**Topics**
+ [Autorisations de la fonction Lambda utilisée en tant que sortie](#how-it-works-output-lambda-perms)
+ [Métriques de la fonction Lambda utilisée en tant que sortie](#how-it-works-output-lambda-metrics)
+ [Modèle de données d'entrée d'événement et modèle de réponse d'enregistrement pour une fonction Lambda utilisée comme sortie](#how-it-works-output-lambda-model)
+ [Fréquence d'appel de sortie Lambda](#how-it-works-output-lambda-frequency)
+ [Ajout d’une fonction Lambda pour une utilisation en tant que sortie](#how-it-works-output-lambda-procedure)
+ [Échecs courants associés à l’utilisation de Lambda en tant que sortie](#how-it-works-output-lambda-troubleshooting)
+ [Création de fonctions Lambda pour des destinations d’application](how-it-works-output-lambda-functions.md)

## Autorisations de la fonction Lambda utilisée en tant que sortie
<a name="how-it-works-output-lambda-perms"></a>

Pour utiliser Lambda comme sortie, le rôle IAM de sortie Lambda de l’application a besoin de la stratégie d’autorisations suivante :

```
{
   "Sid": "UseLambdaFunction",
   "Effect": "Allow",
   "Action": [
       "lambda:InvokeFunction",
       "lambda:GetFunctionConfiguration"
   ],
   "Resource": "FunctionARN"
}
```

## Métriques de la fonction Lambda utilisée en tant que sortie
<a name="how-it-works-output-lambda-metrics"></a>

Vous utilisez Amazon CloudWatch pour surveiller le nombre d'octets envoyés, les réussites et les échecs, etc. Pour plus d'informations sur CloudWatch les métriques émises par Kinesis Data Analytics à l'aide de Lambda comme sortie, consultez Amazon [Kinesis Analytics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/aka-metricscollected.html) Metrics.

## Modèle de données d'entrée d'événement et modèle de réponse d'enregistrement pour une fonction Lambda utilisée comme sortie
<a name="how-it-works-output-lambda-model"></a>

Pour envoyer des enregistrements de sortie Kinesis Data Analytics, votre fonction Lambda doit être conforme aux modèles de données d’entrée d’événement et de réponse d’enregistrement imposés. 

### Modèle de données d'entrée d'événement
<a name="how-it-works-output-lambda-model-request"></a>

Kinesis Data Analytics envoie continuellement les enregistrements de sortie de l’application à la fonction Lambda en tant que sortie en suivant le modèle de requête ci-dessous. Dans votre fonction, vous effectuez une itération dans la liste et appliquez votre logique métier pour réaliser vos exigences de sortie (par exemple, transformation des données avant envoi vers une destination finale).


| Champ | Description | 
| --- | --- | 
| Champ | Description | 
| --- | --- | 
| Champ | Description | 
| --- | --- | 
| invocationId | ID d’invocation Lambda (GUID aléatoire). | 
| applicationArn | Amazon Resource Name (ARN) de l’application Kinesis Data Analytics. | 
| enregistrements [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/kinesisanalytics/latest/dev/how-it-works-output-lambda.html)  | 
| recordId | ID d'enregistrement (GUID aléatoire) | 
| lambdaDeliveryRecordMetadata |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/kinesisanalytics/latest/dev/how-it-works-output-lambda.html)  | 
| data | Charge utile d'enregistrement de sortie codée en base64 | 
| retryHint | Nombre de nouvelles tentatives de diffusion | 

**Note**  
Le `retryHint` est une valeur qui augmente à chaque échec de diffusion. Cette valeur n'est pas conservée durablement et est réinitialisée en cas d'interruption de l'application.

### Modèle de réponse d'enregistrement
<a name="how-it-works-output-lambda-model-response"></a>

Chaque enregistrement envoyé à votre Lambda en tant que fonction de sortie (avec enregistrement IDs) doit être confirmé par l'un `Ok` ou l'autre des deux`DeliveryFailed`, et il doit contenir les paramètres suivants. À défaut, Kinesis Data Analytics les traite comme un échec de diffusion.


| Champ | Description | 
| --- | --- | 
| enregistrements [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/kinesisanalytics/latest/dev/how-it-works-output-lambda.html)  | 
| recordId | L’ID d’enregistrement est transmis depuis Kinesis Data Analytics vers Lambda pendant l’invocation. La moindre incohérence entre l'ID de l'enregistrement initial et l'ID de l'enregistrement conformé est traitée comme un échec de diffusion. | 
| result | État de la diffusion de l'enregistrement. Les valeurs admises sont les suivantes : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/kinesisanalytics/latest/dev/how-it-works-output-lambda.html)  | 

## Fréquence d'appel de sortie Lambda
<a name="how-it-works-output-lambda-frequency"></a>

Une application Kinesis Data Analytics place les enregistrements de sortie dans la mémoire tampon et invoque fréquemment la fonction de destination AWS Lambda .
+ Si des enregistrements sont émis vers le flux intégré à l'application de destination au sein de l'application d'analyse de données sous forme de fenêtre de basculement, la fonction de AWS Lambda destination est invoquée par déclencheur de fenêtre de basculement. Par exemple, si une fenêtre bascule de 60 secondes est utilisée pour transmettre les enregistrements vers le flux de destination intégré à l’application, la fonction Lambda est invoquée une fois toutes les 60 secondes.
+ Si des enregistrements sont émis vers le flux de destination intégré à l’application au sein de l’application sous la forme d’une requête continue ou d’une fenêtre défilante, la fonction Lambda de destination est invoquée environ une fois par seconde.

**Note**  
Les [limites de taille de la charge utile pour les demandes d’invocation par fonction Lambda](https://docs.aws.amazon.com/lambda/latest/dg/limits.html) s’appliquent. Si ces limites sont dépassées, les enregistrements de sortie sont fractionnés et envoyés sur plusieurs appels de fonction Lambda.

## Ajout d’une fonction Lambda pour une utilisation en tant que sortie
<a name="how-it-works-output-lambda-procedure"></a>

La procédure suivante explique comment ajouter une fonction Lambda en tant que sortie pour une application Kinesis Data Analytics.

1. Connectez-vous à la console Managed Service for Apache Flink AWS Management Console et ouvrez-la à l'adresse [ https://console.aws.amazon.com/kinesisanalytics.](https://console.aws.amazon.com/kinesisanalytics)

1. Choisissez l'application dans la liste, puis sélectionnez **Application details**.

1. Dans la section **Destination**, choisissez **Connect new destination**.

1. Pour l'élément **Destination**, choisissez la **fonction AWS Lambda **.

1. Dans la section **Diffuser des enregistrements vers AWS Lambda**, choisissez une fonction et une version Lambda existantes ou cliquez sur **Créer**.

1. Si vous créez une nouvelle fonction Lambda, procédez comme suit :

   1. Choisissez l'un des modèles fournis. Pour plus d’informations, consultez [Création de fonctions Lambda pour des destinations d’application](how-it-works-output-lambda-functions.md).

   1. La page **Create Function** (Créer une fonction) s'ouvre dans un nouvel onglet du navigateur web. Dans la zone **Nom**, attribuez à la fonction un nom significatif (par exemple, **myLambdaFunction**).

   1. Mettez à jour le modèle avec la fonctionnalité de post-traitement pour votre application. Pour plus d’informations sur la création d’une fonction Lambda, consultez [Mise en route](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html) dans le *Manuel du développeur AWS Lambda *.

   1. Dans la console Kinesis Data Analytics, dans la liste de **fonctions Lambda**, choisissez la fonction Lambda que vous venez de créer. Sélectionnez **\$1LATEST** pour la version de la fonction Lambda.

1. Dans la section **In-application stream**, sélectionnez **Choose an existing in-application stream**. Dans le champ **In-application stream name**, choisissez le flux de sortie de votre application. Les résultats du flux de sortie sélectionné sont envoyés à la fonction de sortie Lambda.

1. Conservez les valeurs par défaut pour les autres champs du formulaire, puis cliquez sur **Save and continue**.

Votre application envoie désormais à votre fonction Lambda les enregistrements du flux intégré à l’application. Vous pouvez consulter les résultats du modèle par défaut dans la CloudWatch console Amazon. Surveillez la métrique `AWS/KinesisAnalytics/LambdaDelivery.OkRecords` pour voir le nombre d’enregistrements envoyés à la fonction Lambda.

## Échecs courants associés à l’utilisation de Lambda en tant que sortie
<a name="how-it-works-output-lambda-troubleshooting"></a>

Voici quelques raisons courantes qui peuvent expliquer un échec de diffusion vers une fonction Lambda.
+ Tous les enregistrements (avec enregistrement IDs) d'un lot envoyés à la fonction Lambda ne sont pas renvoyés au service Kinesis Data Analytics. 
+ L'ID d'enregistrement ou le champ d'état est manquant dans la réponse. 
+ Les délais d’expiration de la fonction Lambda ne sont pas suffisants pour réaliser la logique métier au sein de la fonction Lambda.
+ La logique métier au sein de la fonction Lambda ne repère pas toutes les erreurs, ce qui se traduit par une expiration du délai d'attente et par une pression de retour en raison d'exceptions non traitées. C'est ce que l'on appelle communément les messages « poison pill ».

En cas d’échec de diffusion des données, Kinesis Data Analytics continue de relancer les invocations Lambda sur le même ensemble d’enregistrements jusqu’à ce que cela aboutisse. Pour mieux comprendre les défaillances, vous pouvez surveiller les CloudWatch indicateurs suivants : 
+ L'application Lambda de l'application Kinesis Data Analytics en tant que métriques CloudWatch de sortie : indique le nombre de réussites et d'échecs, entre autres statistiques. Pour plus d'informations, consultez [Métriques Amazon Kinesis Analytics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/aka-metricscollected.html).
+ AWS Lambda CloudWatch métriques et journaux des fonctions.

# Création de fonctions Lambda pour des destinations d’application
<a name="how-it-works-output-lambda-functions"></a>

Votre application Kinesis Data Analytics peut AWS Lambda utiliser des fonctions comme sortie. Kinesis Data Analytics fournit des modèles de création de fonctions Lambda qui peuvent être utilisées comme destination pour vos applications. Utilisez ces modèles comme point de départ pour la sortie de post-traitement de votre application. 

**Topics**
+ [Création d’une destination de fonction Lambda dans Node.js](#how-it-works-lambda-dest-nodejs)
+ [Création d’une destination de fonction Lambda dans Python](#how-it-works-lambda-dest-python)
+ [Création d’une destination de fonction Lambda dans Java](#how-it-works-lambda-dest-java)
+ [Création d’une destination de fonction Lambda dans .NET](#how-it-works-lambda-net)

## Création d’une destination de fonction Lambda dans Node.js
<a name="how-it-works-lambda-dest-nodejs"></a>

Le modèle suivant pour créer une fonction Lambda de destination dans Node.js est disponible dans la console :


| Plan de la fonction Lambda utilisée en tant que sortie | Langage et version | Description | 
| --- | --- | --- | 
| kinesis-analytics-output | Node.js 12.x | Envoyez des enregistrements de sortie d’une application Kinesis Data Analytics vers une destination personnalisée. | 

## Création d’une destination de fonction Lambda dans Python
<a name="how-it-works-lambda-dest-python"></a>

Les modèles suivants pour créer une fonction Lambda de destination dans Python sont disponibles dans la console :


| Plan de la fonction Lambda utilisée en tant que sortie | Langage et version | Description | 
| --- | --- | --- | 
| kinesis-analytics-output-sns | Python 2.7 | Envoyez des enregistrements de sortie d’une application Kinesis Data Analytics vers Amazon SNS. | 
| kinesis-analytics-output-ddb | Python 2.7 | Envoyez des enregistrements de sortie d’une application Kinesis Data Analytics vers Amazon DynamoDB. | 

## Création d’une destination de fonction Lambda dans Java
<a name="how-it-works-lambda-dest-java"></a>

Pour créer une fonction Lambda de destination dans Java, utilisez les classes d’[événements Java](https://github.com/aws/aws-lambda-java-libs/tree/master/aws-lambda-java-events/src/main/java/com/amazonaws/services/lambda/runtime/events).

Le code suivant illustre un exemple de fonction Lambda de destination utilisant Java :

```
public class LambdaFunctionHandler
        implements RequestHandler<KinesisAnalyticsOutputDeliveryEvent, KinesisAnalyticsOutputDeliveryResponse> {

    @Override
    public KinesisAnalyticsOutputDeliveryResponse handleRequest(KinesisAnalyticsOutputDeliveryEvent event,
            Context context) {
        context.getLogger().log("InvocatonId is : " + event.invocationId);
        context.getLogger().log("ApplicationArn is : " + event.applicationArn);

        List<KinesisAnalyticsOutputDeliveryResponse.Record> records = new ArrayList<KinesisAnalyticsOutputDeliveryResponse.Record>();
        KinesisAnalyticsOutputDeliveryResponse response = new KinesisAnalyticsOutputDeliveryResponse(records);

        event.records.stream().forEach(record -> {
            context.getLogger().log("recordId is : " + record.recordId);
            context.getLogger().log("record retryHint is :" + record.lambdaDeliveryRecordMetadata.retryHint);
            // Add logic here to transform and send the record to final destination of your choice.
            response.records.add(new Record(record.recordId, KinesisAnalyticsOutputDeliveryResponse.Result.Ok));
        });
        return response;
    }

}
```

## Création d’une destination de fonction Lambda dans .NET
<a name="how-it-works-lambda-net"></a>

Pour créer une fonction Lambda de destination dans .NET, utilisez les classes d’[événements .NET](https://github.com/aws/aws-lambda-dotnet/tree/master/Libraries/src/Amazon.Lambda.KinesisAnalyticsEvents).

Le code suivant illustre un exemple de fonction Lambda de destination utilisant C\$1 :

```
public class Function
    {
        public KinesisAnalyticsOutputDeliveryResponse FunctionHandler(KinesisAnalyticsOutputDeliveryEvent evnt, ILambdaContext context)
        {
            context.Logger.LogLine($"InvocationId: {evnt.InvocationId}");
            context.Logger.LogLine($"ApplicationArn: {evnt.ApplicationArn}");

            var response = new KinesisAnalyticsOutputDeliveryResponse
            {
                Records = new List<KinesisAnalyticsOutputDeliveryResponse.Record>()
            };

            foreach (var record in evnt.Records)
            {
                context.Logger.LogLine($"\tRecordId: {record.RecordId}");
                context.Logger.LogLine($"\tRetryHint: {record.RecordMetadata.RetryHint}");
                context.Logger.LogLine($"\tData: {record.DecodeData()}");

                // Add logic here to send to the record to final destination of your choice.

                var deliveredRecord = new KinesisAnalyticsOutputDeliveryResponse.Record
                {
                    RecordId = record.RecordId,
                    Result = KinesisAnalyticsOutputDeliveryResponse.OK
                };
                response.Records.Add(deliveredRecord);
            }
            return response;
        }
    }
```

Pour plus d’informations sur la création de fonctions Lambda pour le prétraitement et les destinations dans .NET, consultez [https://github.com/aws/aws-lambda-dotnet/tree/master/Libraries/src/Amazon.Lambda.KinesisAnalyticsEvents](https://github.com/aws/aws-lambda-dotnet/tree/master/Libraries/src/Amazon.Lambda.KinesisAnalyticsEvents).

# Modèle de diffusion pour la conservation de la sortie d'application dans une destination externe
<a name="failover-checkpoint"></a>

Amazon Kinesis Data Analytics utilise un modèle de diffusion « au moins une fois » pour la sortie d’application vers les destinations configurées. Lorsqu’une application est en cour d’exécution, Kinesis Data Analytics prend des points de contrôle internes. Ces points de contrôle sont des points dans le temps où les enregistrements de sortie ont été envoyés vers les destinations sans perte de données. Le service utilise les points de contrôle si nécessaire pour s'assurer que la sortie de votre application est envoyée au moins une fois aux destinations configurées.

Dans une situation normale, votre application traite les données entrantes en continu. Kinesis Data Analytics écrit la sortie sur les destinations configurées, telles qu'un flux de données Kinesis ou un flux de diffusion Firehose. Toutefois, votre application peut parfois être interrompue, par exemple :
+ Vous choisissez d'arrêter votre application et de la redémarrer ultérieurement.
+ Vous supprimez le rôle IAM dont Kinesis Data Analytics a besoin pour écrire la sortie de votre application vers la destination configurée. Sans le rôle IAM, Kinesis Data Analytics n’est pas autorisé à écrire vers la destination externe en votre nom.
+ Une indisponibilité du réseau ou d'autres défaillances de service internes entraînent l'arrêt temporaire de votre application. 

Lorsque votre application redémarre, Kinesis Data Analytics veille à ce qu’elle continue de traiter et d’écrire la sortie à partir d’un point avant ou correspondant au moment où la défaillance s’est produite. Cela permet de garantir que rien ne manque dans la sortie de votre application envoyée vers les destinations configurées. 

Supposons que vous avez configuré plusieurs destinations depuis le même flux intégré à l'application. Une fois que l’application s’est rétablie de la défaillance, Kinesis Data Analytics reprend l’envoi de la sortie vers les destinations configurées pour conservation à partir du dernier enregistrement qui a été envoyé vers la destination plus lente. De ce fait, le même enregistrement de sortie peut être envoyé plusieurs fois vers d’autres destinations. Dans ce cas, vous devez traiter les duplications potentielles dans la destination en externe. 