Após uma análise cuidadosa, decidimos descontinuar o Amazon Kinesis Data Analytics para aplicativos SQL:

1. A partir de **1º de setembro de 2025,** não forneceremos nenhuma correção de bug para aplicativos do Amazon Kinesis Data Analytics para SQL porque teremos suporte limitado para ele, devido à próxima descontinuação.

2. A partir **de 15 de outubro de 2025,** você não poderá criar novos aplicativos Kinesis Data Analytics para SQL.

3. Excluiremos as aplicações a partir de **27 de janeiro de 2026**. Você não poderá mais iniciar nem operar as aplicações do Amazon Kinesis Data Analytics para SQL. A partir dessa data, não haverá mais suporte ao Amazon Kinesis Data Analytics para SQL. Para obter mais informações, consulte [Descontinuação de aplicações do Amazon Kinesis Data Analytics para SQL](discontinuation.md).

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Criar funções do Lambda para pré-processamento
<a name="lambda-preprocessing-functions"></a>

O aplicativo Amazon Kinesis Data Analytics pode usar funções do Lambda para pré-processamento de registros à medida que são ingeridos no aplicativo. O Kinesis Data Analytics fornece os modelos a seguir no console para usar como ponto de partida para pré-processamento de seus dados.

**Topics**
+ [Criar uma função do Lambda de pré-processamento em Node.js](#lambda-preprocessing-functions-nodejs)
+ [Criar uma função do Lambda de pré-processamento em Python](#lambda-preprocessing-functions-python)
+ [Criar uma função do Lambda de pré-processamento em Java](#lambda-preprocessing-functions-java)
+ [Criar uma função do Lambda de pré-processamento em .NET](#lambda-preprocessing-functions-net)

## Criar uma função do Lambda de pré-processamento em Node.js
<a name="lambda-preprocessing-functions-nodejs"></a>

Os modelos a seguir para criar uma função do Lambda de pré-processamento em Node.js estão disponíveis no console do Kinesis Data Analytics:


| Lambda Blueprint | Linguagem e versão | Description | 
| --- | --- | --- | 
| Processamento de entrada geral do Kinesis Data Analytics  | Node.js 6.10 |  Um pré-processador de registros do Kinesis Data Analytics que recebe registros JSON ou CSV como entrada e os retorna com um status de processamento. Use esse processador como ponto de partida para a lógica de transformação personalizada.  | 
| Processamento de entrada compactado | Node.js 6.10 | Um processador de registros do Kinesis Data Analytics que recebe registros JSON ou CSV compactados (GZIP ou Deflate) como entrada e retorna registros descompactados com um status de processamento. | 

## Criar uma função do Lambda de pré-processamento em Python
<a name="lambda-preprocessing-functions-python"></a>

Os modelos a seguir para criar uma função do Lambda de pré-processamento em Python estão disponíveis no console:


| Lambda Blueprint | Linguagem e versão | Description | 
| --- | --- | --- | 
| Processamento de entrada geral do Kinesis Analytics  | Python 2.7 |  Um pré-processador de registros do Kinesis Data Analytics que recebe registros JSON ou CSV como entrada e os retorna com um status de processamento. Use esse processador como ponto de partida para a lógica de transformação personalizada.  | 
| Processamento de entrada do KPL | Python 2.7 | Um processador de registros do Kinesis Data Analytics que recebe agregados de registros JSON ou CSV do Kinesis Producer Library (KPL) como entrada e retorna registros desagregados com um status de processamento.  | 

## Criar uma função do Lambda de pré-processamento em Java
<a name="lambda-preprocessing-functions-java"></a>

Para criar uma função do Lambda em Java para pré-processar registros, use as classes de [eventos Java](https://github.com/aws/aws-lambda-java-libs/tree/master/aws-lambda-java-events/src/main/java/com/amazonaws/services/lambda/runtime/events).

O código a seguir demonstra um exemplo de função do Lambda que pré-processa registros usando 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;
    }

}
```

## Criar uma função do Lambda de pré-processamento em .NET
<a name="lambda-preprocessing-functions-net"></a>

Para criar uma função do Lambda em .NET para pré-processar registros, use as classes de [eventos .NET](https://github.com/aws/aws-lambda-dotnet/tree/master/Libraries/src/Amazon.Lambda.KinesisAnalyticsEvents).

O código a seguir demonstra um exemplo de função do Lambda que pré-processa registros usando 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;
        }
    }
```

Para obter mais informações sobre como criar funções do Lambda para pré-processamento e destinos em .NET, consulte [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).