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.

# Création de fonctions Lambda pour le prétraitement
<a name="lambda-preprocessing-functions"></a>

Votre application Amazon Kinesis Data Analytics peut utiliser des fonctions Lambda pour le prétraitement des enregistrements à mesure que ceux-ci sont reçus dans l’application. Kinesis Data Analytics fournit dans la console les modèles suivants à utiliser comme point de départ pour le prétraitement de vos données.

**Topics**
+ [Création d’une fonction Lambda de prétraitement dans Node.js](#lambda-preprocessing-functions-nodejs)
+ [Création d’une fonction Lambda de prétraitement dans Python](#lambda-preprocessing-functions-python)
+ [Création d’une fonction Lambda de prétraitement dans Java](#lambda-preprocessing-functions-java)
+ [Création d’une fonction Lambda de prétraitement dans .NET](#lambda-preprocessing-functions-net)

## Création d’une fonction Lambda de prétraitement dans Node.js
<a name="lambda-preprocessing-functions-nodejs"></a>

Les modèles suivants pour créer une fonction Lambda de prétraitement dans Node.js sont disponibles dans la console Kinesis Data Analytics :


| Plan Lambda | Langage et version | Description | 
| --- | --- | --- | 
| Traitement d’entrée General Kinesis Data Analytics  | Node.js 6.10 |  Un préprocesseur d’enregistrement Kinesis Data Analytics qui reçoit des enregistrements JSON ou CSV en entrée, puis les renvoie avec un statut de traitement. Utilisez ce processeur comme point de départ pour une logique de transformation personnalisée.  | 
| Traitement d'entrée compressée | Node.js 6.10 | Un processeur d’enregistrements Kinesis Data Analytics qui reçoit des enregistrements JSON ou CSV compressés (GZIP ou compressés via Deflate) en entrée et renvoie des enregistrements décompressés avec un statut de traitement. | 

## Création d’une fonction Lambda de prétraitement dans Python
<a name="lambda-preprocessing-functions-python"></a>

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


| Plan Lambda | Langage et version | Description | 
| --- | --- | --- | 
| Traitement d'entrée General Kinesis Analytics  | Python 2.7 |  Un préprocesseur d’enregistrement Kinesis Data Analytics qui reçoit des enregistrements JSON ou CSV en entrée, puis les renvoie avec un statut de traitement. Utilisez ce processeur comme point de départ pour une logique de transformation personnalisée.  | 
| Traitement d'entrée KPL | Python 2.7 | Un processeur d’enregistrements Kinesis Data Analytics qui reçoit des regroupements KPL (Kinesis Producer Library) d’enregistrements JSON ou CSV en entrée et renvoie des enregistrements désagrégés avec un statut de traitement.  | 

## Création d’une fonction Lambda de prétraitement dans Java
<a name="lambda-preprocessing-functions-java"></a>

Pour créer une fonction Lambda dans Java pour prétraiter des enregistrements, 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 qui prétraite des enregistrements à l’aide de Java :

```
public class LambdaFunctionHandler implements
        RequestHandler<KinesisAnalyticsStreamsInputPreprocessingEvent, KinesisAnalyticsInputPreprocessingResponse> {

    @Override
    public KinesisAnalyticsInputPreprocessingResponse handleRequest(
            KinesisAnalyticsStreamsInputPreprocessingEvent event, Context context) {
        context.getLogger().log("InvocatonId is : " + event.invocationId);
        context.getLogger().log("StreamArn is : " + event.streamArn);
        context.getLogger().log("ApplicationArn is : " + event.applicationArn);

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

        event.records.stream().forEach(record -> {
            context.getLogger().log("recordId is : " + record.recordId);
            context.getLogger().log("record aat is :" + record.kinesisStreamRecordMetadata.approximateArrivalTimestamp);
             // Add your record.data pre-processing logic here.                               
            // response.records.add(new Record(record.recordId, KinesisAnalyticsInputPreprocessingResult.Ok, <preprocessedrecordData>));
        });
        return response;
    }

}
```

## Création d’une fonction Lambda de prétraitement dans .NET
<a name="lambda-preprocessing-functions-net"></a>

Pour créer une fonction Lambda dans .NET pour prétraiter des enregistrements, 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 qui prétraite des enregistrements à l’aide de C\$1 :

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

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

            foreach (var record in evnt.Records)
            {
                context.Logger.LogLine($"\tRecordId: {record.RecordId}");
                context.Logger.LogLine($"\tShardId: {record.RecordMetadata.ShardId}");
                context.Logger.LogLine($"\tPartitionKey: {record.RecordMetadata.PartitionKey}");
                context.Logger.LogLine($"\tRecord ApproximateArrivalTime: {record.RecordMetadata.ApproximateArrivalTimestamp}");
                context.Logger.LogLine($"\tData: {record.DecodeData()}");

                // Add your record preprocessig logic here.

                var preprocessedRecord = new KinesisAnalyticsInputPreprocessingResponse.Record
                {
                    RecordId = record.RecordId,
                    Result = KinesisAnalyticsInputPreprocessingResponse.OK
                };
                preprocessedRecord.EncodeData(record.DecodeData().ToUpperInvariant());
                response.Records.Add(preprocessedRecord);
            }
            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).