

Nach reiflicher Überlegung haben wir uns entschieden, Amazon Kinesis Data Analytics für SQL-Anwendungen einzustellen:

1. Ab dem **1. September 2025** werden wir keine Bugfixes für Amazon Kinesis Data Analytics for SQL-Anwendungen bereitstellen, da wir aufgrund der bevorstehenden Einstellung nur eingeschränkten Support dafür haben werden.

2. Ab dem **15. Oktober 2025** können Sie keine neuen Kinesis Data Analytics for SQL-Anwendungen mehr erstellen.

3. Wir werden Ihre Anwendungen ab dem **27. Januar 2026** löschen. Sie können Ihre Amazon Kinesis Data Analytics for SQL-Anwendungen nicht starten oder betreiben. Ab diesem Zeitpunkt ist kein Support mehr für Amazon Kinesis Data Analytics for SQL verfügbar. Weitere Informationen finden Sie unter [Einstellung von Amazon Kinesis Data Analytics für SQL-Anwendungen](discontinuation.md).

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Konfigurieren der Anwendungsausgabe
<a name="how-it-works-output"></a>



In Ihrem Anwendungscode schreiben Sie die Ausgabe von SQL-Anweisungen in einen oder mehrere In-Application-Streams. Sie können Ihrer Anwendung optional eine Ausgabekonfiguration hinzufügen, um alles, was in einen anwendungsinternen Stream geschrieben wurde, an einem externen Ziel wie einem Amazon Kinesis Kinesis-Datenstream, einem Firehose-Lieferstream oder einer Funktion zu persistieren. AWS Lambda 

Es gibt eine Begrenzung für die Anzahl der externen Ziele, an die Sie eine Anwendungsausgabe weiterleiten können. Weitere Informationen finden Sie unter [Einschränkungen](limits.md). 

**Anmerkung**  
Wir empfehlen die Verwendung eines externen Ziels, an das die Daten aus dem In-Application-Fehler-Stream weitergeleitet werden, damit Sie die Fehler untersuchen können. 



In jeder dieser Ausgabekonfigurationen stellen Sie Folgendes bereit:
+ **Name des In-Application-Streams** – Der Stream, den Sie an ein externes Ziel weiterleiten möchten. 

  Kinesis Data Analytics sucht nach dem In-Application-Stream, den Sie in der Ausgabekonfiguration angegeben haben. (Beim Streamnamen wird zwischen Groß- und Kleinschreibung unterschieden und er muss exakt übereinstimmen.) Stellen Sie sicher, dass Ihr Anwendungscode diesen anwendungsinternen Stream erstellt. 
+ **Externes Ziel** — Sie können Daten in einem Kinesis-Datenstream, einem Firehose-Lieferstream oder einer Lambda-Funktion persistieren. Sie geben den Amazon-Ressourcennamen (ARN) des Streams oder der Funktion an. Sie stellen außerdem eine IAM-Rolle bereit, die Kinesis Data Analytics übernehmen kann, um in Ihrem Namen in den Stream oder schreiben oder Funktionen auszuführen. Sie beschreiben das Datensatzformat (JSON, CSV), das Kinesis Data Analytics beim Schreiben in das externe Ziel verwenden soll.

Wenn Kinesis Data Analytics nicht in das Streaming- oder Lambda-Ziel schreiben kann, führt der Service für unbegrenzte Zeit Versuche aus. Dies führt zu einer hohen Auslastung und Ihre Anwendung fällt zurück. Wenn dieses Problem nicht behoben wird, verarbeitet Ihre Anwendung ab einem gewissen Zeitpunkt keine neuen Daten mehr. Sie können [Amazon-Kinesis-Analytics-Metriken](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/aka-metricscollected.html) überwachen und Alarmen für Ausfälle festlegen. Weitere Informationen zu Metriken und Alarmen finden Sie unter [Amazon CloudWatch Metrics verwenden](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/working_with_metrics.html) und [ CloudWatchAmazon-Alarme erstellen](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html).

Sie können die Anwendungsausgabe mittels der AWS-Managementkonsole konfigurieren. Die Konsole führt den API-Aufruf aus, um die Konfiguration zu speichern. 

## Erstellen einer Ausgabe mit dem AWS CLI
<a name="how-it-works-output-cli"></a>

In diesem Abschnitt wird beschrieben, wie der Abschnitt `Outputs` des Anforderungstextes für eine `CreateApplication`- oder `AddApplicationOutput`-Operation erstellt wird.

### Erstellen einer Kinesis Stream-Ausgabe
<a name="how-it-works-output-cli-streams"></a>

Das folgende JSON-Fragment zeigt den Abschnitt `Outputs` im `CreateApplication`-Anforderungstext zum Erstellen eines Ziels für den Amazon-Kinesis-Datenstrom.

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

### Erstellen einer Firehose Delivery Stream-Ausgabe
<a name="how-it-works-output-cli-firehose"></a>

Das folgende JSON-Fragment zeigt den `Outputs` Abschnitt im `CreateApplication` Anforderungstext für die Erstellung eines Amazon Data Firehose-Lieferstream-Ziels.

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

### Erstellen einer Lambda-Funktion
<a name="how-it-works-output-cli-lambda"></a>

Das folgende JSON-Fragment zeigt den `Outputs` Abschnitt im Hauptteil der `CreateApplication` Anfrage zum Erstellen eines AWS Lambda Funktionsziels.

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

# Verwenden einer Lambda-Funktion als Ausgabe
<a name="how-it-works-output-lambda"></a>

Wenn Sie es AWS Lambda als Ziel verwenden, können Sie Ihre SQL-Ergebnisse einfacher nachbearbeiten, bevor Sie sie an ein endgültiges Ziel senden. Zu gängigen Aufgaben der Nachverarbeitung gehören:
+ Aggregieren von mehreren Zeilen in einem einzigen Datensatz
+ Kombinieren aktueller Ergebnisse mit vorherigen Ergebnissen für die Einordnung spät eintreffender Daten
+ Bereitstellung auf verschiedene Ziele abhängig von der Art von Informationen
+ Aufzeichnung von Formatumsetzungen (z. B. die Umsetzung in Protobuf)
+ Bearbeitung oder Transformation von Zeichenfolgen
+ Datenanreicherung nach der analytischen Verarbeitung
+ Benutzerdefinierte Verarbeitung für koordinatenbasierte Anwendungsfälle
+ Datenverschlüsselung

Lambda-Funktionen können analytische Informationen für eine Vielzahl von AWS Diensten und anderen Zielen bereitstellen, darunter die folgenden:
+ [Amazon Simple Storage Service (Amazon-S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/)
+ Benutzerdefiniert 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/)

Weitere Informationen zum Erstellen von Lambda-Anwendungen finden Sie unter [Erste Schritte mit AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html).

**Topics**
+ [

## Berechtigungen für Lambda als Ausgabe
](#how-it-works-output-lambda-perms)
+ [

## Lambda als Ausgabemetriken
](#how-it-works-output-lambda-metrics)
+ [

## Ereignis-Eingabedatenmodell und Datensatz-Antwortmodell von Lambda als Ausgabe
](#how-it-works-output-lambda-model)
+ [

## Häufigkeit der Lambda-Ausgabeaufrufe
](#how-it-works-output-lambda-frequency)
+ [

## Hinzufügen einer Lambda-Funktion zur Verwendung als Ausgabe
](#how-it-works-output-lambda-procedure)
+ [

## Häufige Lambda-Ausgabefehler
](#how-it-works-output-lambda-troubleshooting)
+ [

# Erstellen von Lambda-Funktionen für Anwendungsziele
](how-it-works-output-lambda-functions.md)

## Berechtigungen für Lambda als Ausgabe
<a name="how-it-works-output-lambda-perms"></a>

Um Lambda als Ausgabe verwenden zu können, benötigt die IAM-Rolle für die Lambda-Ausgabe der Anwendung die folgende Berechtigungsrichtlinie:

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

## Lambda als Ausgabemetriken
<a name="how-it-works-output-lambda-metrics"></a>

Sie verwenden Amazon CloudWatch , um die Anzahl der gesendeten Byte, Erfolge und Misserfolge usw. zu überwachen. Informationen zu CloudWatch Metriken, die von Kinesis Data Analytics mithilfe von Lambda als Ausgabe ausgegeben werden, finden Sie unter [Amazon Kinesis](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/aka-metricscollected.html) Analytics Analytics-Metriken.

## Ereignis-Eingabedatenmodell und Datensatz-Antwortmodell von Lambda als Ausgabe
<a name="how-it-works-output-lambda-model"></a>

Um Kinesis Data Analytics-Ausgabedatensätze senden zu können, muss Ihre Lambda-Funktion mit den erforderlichen Ereignis-Eingabedaten- und Datensatz-Antwortmodellen konform sein. 

### Ereignis-Eingabedatenmodell
<a name="how-it-works-output-lambda-model-request"></a>

Kinesis Data Analytics sendet die Ausgabedatensätze mit dem folgenden Anforderungsmodell fortlaufend von der Anwendung als Ausgabefunktion an die Lambda-Funktion. Innerhalb Ihrer Funktion durchlaufen Sie die Liste und wenden Ihre Geschäftslogik an, um Ihre Ausgabeanforderungen (z. B. Datentransformation vor dem senden an ein endgültiges Ziel) zu erfüllen.


| Feld | Description | 
| --- | --- | 
| Feld | Description | 
| --- | --- | 
| Feld | Description | 
| --- | --- | 
| invocationId | Die Lambda -Aufrufs-ID (zufällige GUID). | 
| applicationArn | Der Amazon-Ressourcenname (ARN) der Kinesis Data Analytics-Anwendung. | 
| Datensätze [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/kinesisanalytics/latest/dev/how-it-works-output-lambda.html)  | 
| recordId | Datensatz-ID (zufällige GUID) | 
| lambdaDeliveryRecordMetadata |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/kinesisanalytics/latest/dev/how-it-works-output-lambda.html)  | 
| data | Base64-kodierte Augabedatensatz-Nutzlast | 
| retryHint | Anzahl der wiederholten Nachrichtenzustellungen | 

**Anmerkung**  
`retryHint` ist ein Wert, der sich bei jedem Zustellungsfehler erhöht. Dieser Wert wird nicht dauerhaft gespeichert und wird zurückgesetzt werden, wenn die Anwendung unterbrochen wird.

### Datensatz-Antwortmodell
<a name="how-it-works-output-lambda-model-response"></a>

Jeder Datensatz, der als Ausgabefunktion (mit Datensatz IDs) an Ihr Lambda gesendet wird`DeliveryFailed`, muss entweder mit `Ok` oder bestätigt werden und er muss die folgenden Parameter enthalten. Andernfalls wird er von Kinesis Data Analytics als unzustellbar behandelt.


| Feld | Description | 
| --- | --- | 
| Datensätze [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/kinesisanalytics/latest/dev/how-it-works-output-lambda.html)  | 
| recordId | Die Datensatz-ID wird während des Aufrufs von Kinesis Data Analytics an Lambda übertragen. Jede fehlende Übereinstimmung zwischen der ID des ursprünglichen Datensatzes und der ID des bestätigten Datensatzes wird als Zustellungsfehler behandelt. | 
| result | Der Status der Datensatzzustellung. Folgende Werte sind möglich: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/kinesisanalytics/latest/dev/how-it-works-output-lambda.html)  | 

## Häufigkeit der Lambda-Ausgabeaufrufe
<a name="how-it-works-output-lambda-frequency"></a>

Eine Kinesis Data Analytics-Anwendung puffert die Ausgabedatensätze und ruft häufig die AWS Lambda -Zielfunktion auf.
+ Wenn Datensätze als Taumelfenster an den anwendungsinternen Zielstream innerhalb der Datenanalyseanwendung ausgegeben werden, wird die AWS Lambda Zielfunktion pro Taumelfenster-Trigger aufgerufen. Wenn z. B. ein rollierendes Fenster von 60 Sekunden verwendet wird, um die Datensätze an den In-Application-Stream des Ziels auszugeben, wird die Lambda-Funktion einmal alle 60 Sekunden aufgerufen.
+ Wenn Datensätze innerhalb der Anwendung als fortlaufende Abfrage oder gleitendes Fenster zum In-Application-Stream des Ziels gesendet werden, wird die Lambda-Zielfunktion ca. einmal pro Sekunde aufgerufen.

**Anmerkung**  
[Pro Aufruf der Lambda-Funktion gelten Nutzlastgrenzwerte](https://docs.aws.amazon.com/lambda/latest/dg/limits.html). Beim Überschreiten dieser Limits erhalten Sie Ausgabedatensätze, die über mehrere Lambda-Funktionsaufrufe aufgeteilt und gesendet werden.

## Hinzufügen einer Lambda-Funktion zur Verwendung als Ausgabe
<a name="how-it-works-output-lambda-procedure"></a>

Das folgende Verfahren veranschaulicht, wie Sie die Lambda-Funktion als Ausgabe für eine Kinesis Data Analytics-Anwendung hinzufügen.

1. [Melden Sie sich bei der Managed Service for Apache Flink-Konsole unter /kinesisanalytics an AWS-Managementkonsole und öffnen Sie sie. https://console.aws.amazon.com](https://console.aws.amazon.com/kinesisanalytics)

1. Wählen Sie die Anwendung in der Liste aus und klicken Sie dann auf **Application details**.

1. Klicken Sie im Bereich **Destination** auf **Connect new destination**.

1. Wählen Sie für das Element **Destination (Ziel)** die Option **AWS Lambda function (-Funktion)**.

1. Wählen Sie im Bereich **Datensätze an AWS Lambda liefern** entweder eine vorhandene Lambda-Funktion aus oder klicken Sie auf **Neu erstellen**.

1. Wenn Sie eine neue Lambda-Funktion erstellen, verfahren Sie wie folgt:

   1. Wählen Sie eine der bereitgestellten Vorlagen. Weitere Informationen finden Sie unter [Erstellen von Lambda-Funktionen für Anwendungsziele](how-it-works-output-lambda-functions.md).

   1. Die Seite **Create Function** (Funktion erstellen) wird in einer neuen Webbrowser-Registerkarte geöffnet. Geben Sie im Feld **Name** der Funktion einen sinnvollen Namen (z. B. **myLambdaFunction**).

   1. Aktualisieren Sie die Vorlage mit Nachverarbeitungsfunktionalität für Ihre Anwendung. Weitere Informationen zum Erstellen einer Lambda-Funktion finden Sie unter [Erste Schritte](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html) im *AWS Lambda -Entwicklerhandbuch*.

   1. Wählen Sie in der Kinesis Data Analytics-Konsole aus der Liste **Lambda-Funktionen** die gerade erstellte Lambda-Funktion aus. Wählen Sie **\$1LATEST** für die Lambda-Funktionsversion.

1. Wählen Sie im Bereich **In-application stream** die Option **Choose an existing in-application stream** aus. Wählen Sie für **In-application stream name** den Ausgabe-Stream Ihrer Anwendung aus. Die Ergebnisse aus dem ausgewählten Ausgabe-Stream werden zur Lambda-Ausgabefunktion gesendet.

1. Belassen Sie im Formular die übrigen Standardwerte und wählen Sie **Save and continue**.

Ihre Anwendung sendet nun Datensätze aus dem In-Application-Stream zu Ihrer Lambda-Funktion. Sie können die Ergebnisse der Standardvorlage in der CloudWatch Amazon-Konsole sehen. Überwachen Sie die Metrik `AWS/KinesisAnalytics/LambdaDelivery.OkRecords`, um die Anzahl der Datensätze zu sehen, die an die Lambda-Funktion übermittelt werden.

## Häufige Lambda-Ausgabefehler
<a name="how-it-works-output-lambda-troubleshooting"></a>

Nachfolgend werden die häufigsten Gründe aufgeführt, aus denen die Übermittlung an die Lambda-Funktion fehlschlagen kann.
+ Nicht alle Datensätze (mit Datensatz IDs) in einem Batch, die an die Lambda-Funktion gesendet werden, werden an den Kinesis Data Analytics Analytics-Dienst zurückgegeben. 
+ In der Antwort fehlt entweder die Datensatz-ID oder das Statusfeld. 
+ Die Zeitüberschreitungen der Lambda-Funktion sind für den Abschluss der Geschäftslogik innerhalb der Lambda-Funktion nicht ausreichend.
+ Die Geschäftslogik innerhalb der Lambda-Funktion erfasst nicht alle Fehler. Dies führt aufgrund unbehandelter Ausnahmen zu einer Zeitüberschreitung und einer zu hohen Auslastung. Diese werden oft als Poison-Pill-Nachrichten bezeichnet.

Bei Datenübermittlungsfehlern führt Kinesis Data Analytics Lambda-Aufrufe für dieselbe Gruppe von Datensätzen erneut durch, bis der Aufruf erfolgreich ist. Um Einblick in Fehler zu erhalten, können Sie die folgenden CloudWatch Metriken überwachen: 
+ Kinesis Data Analytics Analytics-Anwendung Lambda as CloudWatch Output-Metriken: Gibt unter anderem die Anzahl der Erfolge und Misserfolge an. Weitere Informationen finden Sie unter [Amazon-Kinesis-Analytics-Metriken](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/aka-metricscollected.html).
+ AWS Lambda CloudWatch Funktionsmetriken und Protokolle.

# Erstellen von Lambda-Funktionen für Anwendungsziele
<a name="how-it-works-output-lambda-functions"></a>

Ihre Kinesis Data Analytics Analytics-Anwendung kann AWS Lambda Funktionen als Ausgabe verwenden. Kinesis Data Analytics stellt Vorlagen zum Erstellen von Lambda-Funktionen zur Verfügung, die als Ziel Ihrer Anwendung verwendet werden. Diese Vorlagen dienen als Ausgangspunkt für die Nachverarbeitung der Ausgabe Ihrer Anwendung. 

**Topics**
+ [

## Erstellen eines Lambda-Funktionsziels in Node.js
](#how-it-works-lambda-dest-nodejs)
+ [

## Erstellen eines Lambda-Funktionsziels in Python
](#how-it-works-lambda-dest-python)
+ [

## Erstellen eines Lambda-Funktionsziels in Java
](#how-it-works-lambda-dest-java)
+ [

## Erstellen eines Lambda-Funktionsziels in .NET
](#how-it-works-lambda-net)

## Erstellen eines Lambda-Funktionsziels in Node.js
<a name="how-it-works-lambda-dest-nodejs"></a>

Die folgende Vorlage zum Erstellen eines Lambda-Funktionsziels in Node.js finden Sie in der Konsole:


| Lambda als Ausgabe-Blueprint | Sprache und Version | Description | 
| --- | --- | --- | 
| kinesis-analytics-output | Node.js 12.x | Übermitteln von Ausgabedatensätzen von einer Kinesis Data Analytics-Anwendung an ein benutzerdefiniertes Ziel. | 

## Erstellen eines Lambda-Funktionsziels in Python
<a name="how-it-works-lambda-dest-python"></a>

Die folgenden Vorlagen zum Erstellen eines Lambda-Funktionsziels in Python finden Sie in der Konsole:


| Lambda als Ausgabe-Blueprint | Sprache und Version | Description | 
| --- | --- | --- | 
| kinesis-analytics-output-sns | Python 2.7 | Stellen Sie Ausgabedatensätze aus einer Kinesis Data Analytics-Anwendung an Amazon-SNS bereit. | 
| kinesis-analytics-output-ddb | Python 2.7 | Stellen Sie Ausgabedatensätze aus einer Kinesis Data Analytics-Anwendung an Amazon-DynamoDB bereit. | 

## Erstellen eines Lambda-Funktionsziels in Java
<a name="how-it-works-lambda-dest-java"></a>

Zum Erstellen eines Lambda-Funktionsziels in Java verwenden Sie die [Java Events](https://github.com/aws/aws-lambda-java-libs/tree/master/aws-lambda-java-events/src/main/java/com/amazonaws/services/lambda/runtime/events)-Klassen.

Der folgende Code zeigt das Beispiel eines Lambda-Funktionsziels mit 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;
    }

}
```

## Erstellen eines Lambda-Funktionsziels in .NET
<a name="how-it-works-lambda-net"></a>

Zum Erstellen eines Lambda-Funktionsziels in .NET verwenden Sie die [.NET-Events](https://github.com/aws/aws-lambda-dotnet/tree/master/Libraries/src/Amazon.Lambda.KinesisAnalyticsEvents)-Klassen.

Der folgende Code zeigt das Beispiel eines Lambda-Funktionsziels mit 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;
        }
    }
```

Weitere Informationen zum Erstellen von Lambda-Funktionen für die Vorverarbeitung und Ziele in .NET finden Sie unter [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).

# Bereitstellungsmodell für die Weiterleitung der Anwendungsausgabe an ein externes Ziel
<a name="failover-checkpoint"></a>

Amazon-Kinesis-Data-Analytics verwendet für die Anwendungsausgabe an die konfigurierten Ziele ein Bereitstellungsmodell nach dem Verfahren „mindestens einmal“. Wenn die Anwendung ausgeführt wird, erstellt Kinesis Data Analytics interne Checkpoints. Diese Checkpoints sind Zeitpunkte, an denen die Ausgabedaten ohne Datenverluste an die Ziele geliefert wurden. Der Service verwendet die Checkpoints nach Bedarf, um sicherzustellen, dass die Ausgabe Ihrer Anwendungen mindestens einmal an die konfigurierten Ziele geliefert wird.

In einer normalen Situation verarbeitet Ihre Anwendung eingehende Daten kontinuierlich. Kinesis Data Analytics schreibt die Ausgabe an die konfigurierten Ziele, z. B. einen Kinesis-Datenstream oder einen Firehose-Lieferstream. Ihre Anwendung kann jedoch gelegentlich unterbrochen werden, z. B.:
+ Sie möchten möglicherweise die Anwendung anhalten und später erneut starten.
+ Sie löschen die IAM-Rolle, die Kinesis Data Analytics benötigt, um Ihre Anwendungsausgabe zum konfigurierten Ziel zu schreiben. Ohne die IAM-Rolle besitzt Kinesis Data Analytics keine Berechtigungen, um in Ihrem Namen in das externe Ziel zu schreiben.
+ Ein Netzwerkausfall oder der Ausfall eines anderen internen Service führt dazu, dass Ihre Anwendung vorübergehend angehalten wird. 

Wenn Ihre Anwendung neu gestartet wird, stellt Kinesis Data Analytics sicher, dass Ausgabedaten weiterhin ab einem Punkt verarbeitet und geschrieben werden, der vor oder an dem Punkt liegt, an dem der Fehler aufgetreten ist. Dadurch wird sichergestellt, dass alle Anwendungsausgaben an die konfigurierten Ziele geliefert werden. 

Gehen wir davon aus, dass Sie mehrere Ziele für den selben In-Application-Stream konfiguriert haben. Nachdem die Anwendung nach dem Fehler wiederhergestellt wurde, setzt Kinesis Data Analytics die Ausgabe an die konfigurierten Ziele ab dem letzten Datensatz fort, der an das langsamste Ziel geliefert wurde. Dies kann dazu führen, dass derselbe Ausgabedatensatz mehr als einmal für andere Ziele bereitgestellt wird. In diesem Fall müssen Sie potenzielle Doppelerfassungen im Ziel extern behandeln. 