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.
# Daten in Amazon Kinesis Data Streams schreiben
Ein *Produzent* ist eine Anwendung, die Daten in Amazon Kinesis Data Streams schreibt. Sie können mit der AWS SDK für Java und der Kinesis Producer Library (KPL) Producer Library (KPL) Producer für Kinesis Data Streams erstellen.
Wenn Sie Kinesis Data Streams zum ersten Mal verwenden, sollten Sie sich zunächst mit den Konzepten und der Terminologie in [Was ist Amazon Kinesis Data Streams?](introduction.md) und [Verwenden Sie die AWS CLI , um Amazon Kinesis Data Streams Streams-Operationen durchzuführen](getting-started.md) vertraut machen.
**Wichtig**
Kinesis Data Streams unterstützt Änderungen des Zeitraums der Datensatzaufbewahrung für einen Datenstrom. Weitere Informationen finden Sie unter [Ändern Sie den Aufbewahrungszeitraum für Daten](kinesis-extended-retention.md).
Zur Übergabe von Daten an einen Stream müssen Sie den Namen des Streams, einen Partitionsschlüssel und den Daten-Blob, der zum Stream hinzugefügt wird, angeben. Der Partitionsschlüssel wird verwendet, um zu ermitteln, zu welchem Shard im Stream der Datensatz hinzugefügt wird.
Alle Daten im Shard werden an denselben Worker gesendet, der den Shard verarbeitet. Welchen Partitionsschlüssel Sie verwenden, hängt von Ihrer Anwendungslogik ab. Die Anzahl der Partitionsschlüssel sollte in der Regel viel größer sein als die Anzahl der Shards. Der Grund hierfür ist, dass über den Partitionsschlüssel festgelegt wird, wie ein Datensatz einem bestimmten Shard zugeordnet wird. Wenn Sie genügend Partitionsschlüssel haben, können die Daten gleichmäßig auf die Shards in einem Stream verteilt werden.
**Topics**
+ [Entwickeln Sie Produzenten mithilfe der Amazon Kinesis Producer Library (KPL)](developing-producers-with-kpl.md)
+ [Entwickeln Sie Produzenten mithilfe der Amazon Kinesis Data Streams Streams-API mit dem AWS SDK für Java](developing-producers-with-sdk.md)
+ [Schreiben Sie mit Kinesis Agent in Amazon Kinesis Data Streams](writing-with-agents.md)
+ [Schreiben Sie mithilfe anderer AWS Dienste in Kinesis Data Streams](using-other-services.md)
+ [Schreiben Sie mithilfe von Integrationen von Drittanbietern in Kinesis Data Streams](using-other-services-third-party.md)
+ [Problembehandlung Amazon Kinesis Data Streams Streams-Produzenten](troubleshooting-producers.md)
+ [Optimieren Sie Kinesis Data Streams Streams-Produzenten](advanced-producers.md)
# Entwickeln Sie Produzenten mithilfe der Amazon Kinesis Producer Library (KPL)
Ein Produzent von Amazon Kinesis Data Streams ist eine Anwendung, die Datensätze an einen Kinesis-Datenstrom übergibt (dies wird auch als *Datenerfassung* bezeichnet). Die Amazon Kinesis Producer Library (KPL) vereinfacht die Entwicklung von Herstelleranwendungen und ermöglicht es Entwicklern, einen hohen Schreibdurchsatz in einen Kinesis-Datenstrom zu erzielen.
Sie können die KPL mit Amazon CloudWatch überwachen. Weitere Informationen finden Sie unter [Überwachen Sie die Kinesis Producer Library mit Amazon CloudWatch](monitoring-with-kpl.md).
**Topics**
+ [Sehen Sie sich die Rolle der KPL an](#developing-producers-with-kpl-role)
+ [Machen Sie sich die Vorteile der Verwendung der KPL bewusst](#developing-producers-with-kpl-advantage)
+ [Verstehen Sie, wann Sie die KPL nicht verwenden sollten](#developing-producers-with-kpl-when)
+ [Installieren Sie die KPL](kinesis-kpl-dl-install.md)
+ [Migrieren Sie von KPL 0.x zu KPL 1.x](kpl-migration-1x.md)
+ [Umstellung auf Amazon Trust Services (ATS) -Zertifikate für die KPL](kinesis-kpl-upgrades.md)
+ [Von KPL unterstützte Plattformen](kinesis-kpl-supported-plats.md)
+ [Die wichtigsten Konzepte von KPL](kinesis-kpl-concepts.md)
+ [Integrieren Sie die KPL in den Herstellercode](kinesis-kpl-integration.md)
+ [Schreiben Sie mit der KPL in Ihren Kinesis-Datenstream](kinesis-kpl-writing.md)
+ [Konfiguration der Amazon Kinesis Producer Library](kinesis-kpl-config.md)
+ [Implementieren Sie die Deaggregation für Verbraucher](kinesis-kpl-consumer-deaggregation.md)
+ [Verwenden Sie die KPL mit Amazon Data Firehose](kpl-with-firehose.md)
+ [Verwenden Sie die KPL mit der Schema Registry AWS Glue](kpl-with-schemaregistry.md)
+ [Konfigurieren Sie die KPL-Proxykonfiguration](kpl-proxy-configuration.md)
+ [Richtlinie zum Lebenszyklus der KPL-Version](kpl-version-lifecycle-policy.md)
**Anmerkung**
Es wird empfohlen, ein Upgrade auf die neueste KPL-Version durchzuführen. KPL wird regelmäßig mit neueren Versionen aktualisiert, die die neuesten Abhängigkeits- und Sicherheitspatches, Bugfixes und abwärtskompatible neue Features enthalten. Weitere Informationen finden Sie unter [https://github.com/awslabs/amazon-kinesis-producer/releases/](https://github.com/awslabs/amazon-kinesis-producer/releases/).
## Sehen Sie sich die Rolle der KPL an
Die KPL ist eine hochgradig konfigurierbare Bibliothek easy-to-use, mit der Sie in einen Kinesis-Datenstrom schreiben können. Sie dient als Vermittler zwischen dem Code Ihrer Produzentenanwendung und den API-Aktionen von Kinesis Data Streams. Die KPL führt die folgenden primären Aufgaben durch:
+ Schreiben in einen oder mehrere Kinesis-Datenströme mit einem automatischen und konfigurierbaren Wiederholungsmechanismus
+ Sammeln von Datensätzen und Verwenden von `PutRecords`, um pro Anforderung mehrere Datensätze für mehrere Shards zu schreiben
+ Aggregieren von Benutzerdatensätzen zur Erhöhung der Nutzlast und Verbesserung des Durchsatzes
+ Nahtlose Integration in die [Kinesis Client Library](https://docs.aws.amazon.com/kinesis/latest/dev/developing-consumers-with-kcl.html) (KCL), für eine Disaggregation gestapelter Datensätze auf Konsumentenseite
+ Übermittelt in Ihrem Namen CloudWatch Amazon-Metriken, um Einblick in die Leistung der Produzenten zu erhalten
Beachten Sie, dass sich die KPL von der Kinesis Data Streams Streams-API unterscheidet, die in der verfügbar ist. [AWS SDKs](https://aws.amazon.com/tools/) Die API für Kinesis Data Streams unterstützt Sie bei der Verwaltung vieler Aspekte von Kinesis Data Streams (einschließlich Stream-Erstellung, Resharding sowie Hinzufügen und Abrufen von Datensätzen), während die KPL eine Abstraktionsebene speziell für die Datenübernahme bereitstellt. Informationen zur Kinesis-Data-Streams-API finden Sie in der [Amazon-Kinesis-API-Referenz](https://docs.aws.amazon.com/kinesis/latest/APIReference/).
## Machen Sie sich die Vorteile der Verwendung der KPL bewusst
In der folgenden Liste sind einige der größten Vorteile der Verwendung der KPL für die Entwicklung von Produzenten von Kinesis Data Streams aufgeführt.
Die KPL kann für synchrone oder asynchrone Anwendungsfälle eingesetzt werden. Wir empfehlen, die höhere Leistung der asynchronen Schnittstelle zu verwenden, sofern keine besonderen Gründe für die Nutzung des synchronen Verhaltens vorliegen. Weitere Informationen zu diesen beiden Anwendungsfällen sowie einen Beispiel-Code finden Sie unter [Schreiben Sie mit der KPL in Ihren Kinesis-Datenstream](kinesis-kpl-writing.md).
**Leistungsvorteile**
Mit der KPL können Sie leistungsstarke Produzenten erstellen. Angenommen, Ihre Amazon-EC2-Instances dienen als Proxy zum Erfassen von 100-Byte-Ereignissen von mehreren Hundert oder Tausend energiesparenden Geräten und zum Schreiben von Datensätzen in einen Kinesis-Datenstrom. Diese EC2 Instances müssen jeweils Tausende von Ereignissen pro Sekunde in Ihren Datenstream schreiben. Um den nötigen Durchsatz zu erreichen, müssen Produzenten eine komplexe Logik, beispielsweise Stapelverarbeitung oder Multithreading, implementieren und auf Konsumentenseite eine Wiederholung der Logik sowie die Disaggregation der Datensätze sicherstellen. Die KPL führt all diese Aufgaben für Sie durch.
**Anwenderfreundlichkeit auf Konsumentenseite**
Entwickler auf Konsumentenseite, die die KCL in Java nutzen, können die KPL ohne zusätzlichen Aufwand integrieren. Wenn die KCL einen aggregierten Datensatz von Kinesis Data Streams abruft, der aus mehreren KPL-Benutzerdatensätzen besteht, ruft sie automatisch die KPL auf, um die einzelnen Benutzerdatensätze vor der Rückgabe an den Benutzer zu extrahieren.
Für Entwickler auf Verbraucherseite, die anstelle der KCL direkt die API-Operation `GetRecords` nutzen, steht eine KPL-Java-Bibliothek zum Extrahieren der einzelnen Benutzerdatensätze vor der Rückgabe an den Benutzer zur Verfügung.
**Überwachen von Produzenten**
Sie können Ihre Kinesis Data Streams Streams-Produzenten mithilfe von Amazon und der KPL sammeln, überwachen CloudWatch und analysieren. Die KPL sendet in Ihrem Namen Durchsatz-, Fehler- und andere Messwerte an und kann für die Überwachung CloudWatch auf Stream-, Shard- oder Producer-Ebene konfiguriert werden.
**Asynchrone Architektur**
Da die KPL Datensätze zwischenspeichern kann, bevor sie an Kinesis Data Streams gesendet werden, zwingt sie die aufrufende Anwendung nicht, zu blockieren und auf eine Bestätigung zu warten, dass der Datensatz auf dem Server angekommen ist, bevor die Laufzeit fortgesetzt wird. Der Aufruf, einen Datensatz an die KPL zu übergeben, wird stets sofort zurückgegeben. Es wird nicht darauf gewartet, dass der Datensatz gesendet bzw. eine Antwort vom Server empfangen wird. Stattdessen wird ein `Future`-Objekt erstellt, das zu einem späteren Zeitpunkt das Ergebnis der Sendung des Datensatzes an Kinesis Data Streams empfängt. Dies ist dasselbe Verhalten wie bei asynchronen Clients im SDK. AWS
## Verstehen Sie, wann Sie die KPL nicht verwenden sollten
Die KPL kann eine weitere Verarbeitungsverzögerung von `RecordMaxBufferedTime` innerhalb der Bibliothek verursachen (vom Benutzer konfigurierbar). Größere Werte von `RecordMaxBufferedTime` führen zu einer schnelleren Verpackung und einer besseren Leistung. Anwendungen, die diese zusätzliche Verzögerung nicht tolerieren können, müssen das AWS SDK möglicherweise direkt verwenden. Weitere Informationen zur Verwendung des AWS SDK mit Kinesis Data Streams finden Sie unter[Entwickeln Sie Produzenten mithilfe der Amazon Kinesis Data Streams Streams-API mit dem AWS SDK für Java](developing-producers-with-sdk.md). Weitere Informationen zu `RecordMaxBufferedTime` und anderen vom Benutzer konfigurierbaren Eigenschaften der KPL finden Sie unter [Konfiguration der Amazon Kinesis Producer Library](kinesis-kpl-config.md).
# Installieren Sie die KPL
Amazon stellt vorgefertigte Binärdateien der C\$1\$1 Amazon Kinesis Producer Library (KPL) für macOS, Windows und aktuelle Linux-Distributionen bereit (Einzelheiten zu den unterstützten Plattformen finden Sie im nächsten Abschnitt). Diese Binärdateien sind Teil der JAR-Dateien von Java und werden automatisch aufgerufen und verwendet, wenn Sie das Paket mit Maven installieren. Mit den folgenden Maven-Links können Sie nach den neusten Versionen der KPL und KCL suchen:
+ [KPL](https://search.maven.org/#search|ga|1|amazon-kinesis-producer)
+ [KCL](https://search.maven.org/#search|ga|1|amazon-kinesis-client)
Die Linux-Binärdateien wurden mit der GNU Compiler Collection (GCC) kompiliert und statisch mit libstdc\$1\$1 unter Linux verknüpft. Sie werden voraussichtlich von allen 64-Bit-Linux-Distributionen unterstützt, in denen glibc in der Version 2.5 oder höher enthalten ist.
Benutzer früherer Linux-Distributionen können die KPL mithilfe der Build-Anweisungen erstellen, die zusammen mit dem Quellcode bereitgestellt werden. GitHub Informationen zum Herunterladen der KPL finden Sie in der GitHub [Amazon Kinesis Producer Library](https://github.com/awslabs/amazon-kinesis-producer).
**Wichtig**
Amazon Kinesis Producer Library (KPL) 0.x wird end-of-support am 30. Januar 2026 verfügbar sein. Wir **empfehlen dringend**, dass Sie Ihre KPL-Anwendungen, die Version 0.x verwenden, vor dem 30. Januar 2026 auf die neueste KPL-Version migrieren. [Die neueste KPL-Version finden Sie auf der KPL-Seite auf Github.](https://github.com/awslabs/amazon-kinesis-producer) Informationen zur Migration von KPL 0.x zu KPL 1.x finden Sie unter. [Migrieren Sie von KPL 0.x zu KPL 1.x](kpl-migration-1x.md)
# Migrieren Sie von KPL 0.x zu KPL 1.x
Dieses Thema enthält step-by-step Anweisungen zur Migration Ihres Verbrauchers von KPL 0.x zu KPL 1.x. KPL 1.x bietet Unterstützung für AWS SDK für Java 2.x unter Beibehaltung der Schnittstellenkompatibilität mit früheren Versionen. Sie müssen Ihre zentrale Datenverarbeitungslogik nicht aktualisieren, um auf KPL 1.x zu migrieren.
1. **Stellen Sie sicher, dass Sie die folgenden Voraussetzungen erfüllen:**
+ Java Development Kit (JDK) 8 oder höher
+ AWS SDK für Java 2.x
+ Maven oder Gradle für das Abhängigkeitsmanagement
1. **Fügen Sie Abhängigkeiten hinzu**
Wenn Sie Maven verwenden, fügen Sie Ihrer Datei pom.xml die folgende Abhängigkeit hinzu. Stellen Sie sicher, dass Sie die groupId von `com.amazonaws` bis `software.amazon.kinesis` und die Version `1.x.x` auf die neueste KPL-Version aktualisiert haben.
```
software.amazon.kinesis
amazon-kinesis-producer
1.x.x
```
Wenn Sie Gradle verwenden, fügen Sie Ihrer Datei Folgendes hinzu. `build.gradle` Stellen Sie sicher, dass Sie es `1.x.x` durch die neueste KPL-Version ersetzen.
```
implementation 'software.amazon.kinesis:amazon-kinesis-producer:1.x.x'
```
Sie können im [Maven](https://central.sonatype.com/search?q=amazon-kinesis-producer) Central Repository nach der neuesten Version der KPL suchen.
1. **Aktualisieren Sie die Importanweisungen für KPL**
KPL 1.x verwendet AWS SDK für Java 2.x und verwendet einen aktualisierten Paketnamen, der mit beginnt`software.amazon.kinesis`, verglichen mit dem Paketnamen in der vorherigen KPL, der mit beginnt. `com.amazonaws.services.kinesis`
Ersetzen Sie den Import für durch. `com.amazonaws.services.kinesis` `software.amazon.kinesis` In der folgenden Tabelle sind die Importe aufgeführt, die Sie ersetzen müssen.
**Importiere Ersatzprodukte**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/streams/latest/dev/kpl-migration-1x.html)
1. **Importanweisungen für Anbieterklassen für Anmeldeinformationen aktualisieren AWS **
Bei der Migration zu KPL 1.x müssen Sie Pakete und Klassen in Ihren Importen in Ihrem KPL-Anwendungscode, die auf der Version AWS SDK für Java 1.x basieren, auf die entsprechenden Pakete und Klassen aktualisieren, die auf der Version 2.x basieren. AWS SDK für Java Übliche Importe in der KPL-Anwendung sind Anbieterklassen für Anmeldeinformationen. Eine vollständige Liste der [Änderungen des Anmeldeinformationsanbieters](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration-client-credentials.html) finden Sie in der Dokumentation zum AWS SDK für Java 2.x-Migrationshandbuch unter Änderungen des Anmeldeinformationsanbieters. Im Folgenden finden Sie die häufigsten Importänderungen, die Sie möglicherweise in Ihren KPL-Anwendungen vornehmen müssen.
**Importieren Sie in KPL 0.x**
```
import com.amazonaws.auth.DefaultAWSCredentialsProviderChain;
```
**In KPL 1.x importieren**
```
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
```
Wenn Sie andere Anbieter für Anmeldeinformationen importieren, die auf Version AWS SDK für Java 1.x basieren, müssen Sie sie auf die entsprechenden Anbieter von AWS SDK für Java 2.x aktualisieren. Wenn Sie keine classes/packages aus Version AWS SDK für Java 1.x importiert haben, können Sie diesen Schritt ignorieren.
1. **Aktualisieren Sie die Konfiguration des Anmeldeinformationsanbieters in der KPL-Konfiguration**
Die Konfiguration des Anmeldeinformationsanbieters in KPL 1.x erfordert die Anmeldeinformationsanbieter AWS SDK für Java 2.x. Wenn Sie die Anbieter für Anmeldeinformationen für die Version AWS SDK für Java 1.x in der übergeben, `KinesisProducerConfiguration` indem Sie den standardmäßigen Anbieter für Anmeldeinformationen überschreiben, müssen Sie ihn mit den Anmeldeinformationsanbietern der Version 2.x aktualisieren. AWS SDK für Java Eine vollständige Liste der [Änderungen des Anmeldeinformationsanbieters](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration-client-credentials.html) finden Sie in der Dokumentation zum Migrationshandbuch für AWS SDK für Java 2.x unter Änderungen des Anmeldeinformationsanbieters. Wenn Sie den standardmäßigen Anbieter für Anmeldeinformationen in der KPL-Konfiguration nicht überschrieben haben, können Sie diesen Schritt ignorieren.
Wenn Sie beispielsweise den standardmäßigen Anbieter für Anmeldeinformationen für die KPL mit dem folgenden Code überschreiben:
```
KinesisProducerConfiguration config = new KinesisProducerConfiguration();
// SDK v1 default credentials provider
config.setCredentialsProvider(new DefaultAWSCredentialsProviderChain());
```
Sie müssen sie mit dem folgenden Code aktualisieren, um den AWS SDK für Java 2.x-Anmeldeinformationsanbieter verwenden zu können:
```
KinesisProducerConfiguration config = new KinesisProducerConfiguration();
// New SDK v2 default credentials provider
config.setCredentialsProvider(DefaultCredentialsProvider.create());
```
# Umstellung auf Amazon Trust Services (ATS) -Zertifikate für die KPL
Am 9. Februar 2018 um 9:00 AM PST hat Amazon Kinesis Data Streams ATS-Zertifikate installiert. Um weiterhin Datensätze mithilfe der Amazon Kinesis Producer Library (KPL) in Kinesis Data Streams schreiben zu können, müssen Sie Ihre Installation der KPL auf [Version](http://search.maven.org/#artifactdetails|com.amazonaws|amazon-kinesis-producer|0.12.6|jar) 0.12.6 oder höher aktualisieren. Diese Änderung betrifft alle Regionen. AWS
Informationen zur Umstellung auf ATS finden Sie unter [So bereiten Sie sich auf die AWS Umstellung auf eine eigene Zertifizierungsstelle](https://aws.amazon.com/blogs/security/how-to-prepare-for-aws-move-to-its-own-certificate-authority/) vor.
Falls Sie Probleme haben und technischen Support benötigen, [erstellen Sie einen Fall](https://console.aws.amazon.com/support/v1#/case/create) im AWS Support Center.
# Von KPL unterstützte Plattformen
Die Amazon Kinesis Producer Library (KPL) ist in C\$1\$1 geschrieben und wird als untergeordneter Prozess des Hauptbenutzerprozesses ausgeführt. Vorkompilierte native 64-Bit-Binärdateien sind in der Java-Version enthalten und werden vom Java-Wrapper verwaltet.
Das Java-Paket kann auf folgenden Betriebssystemen ausgeführt werden, ohne dass zusätzliche Bibliotheken installiert werden müssen:
+ Linux-Distributionen mit Kernel 2.6.18 (September 2006) und höher
+ Apple iOS X 10.9 und höher
+ Windows Server 2008 und höher
**Wichtig**
Windows Server 2008 und höher wird für alle KPL-Versionen bis Version 0.14.0 unterstützt.
Die Windows-Plattform wird ab KPL Version 0.14.0 oder höher NICHT unterstützt.
Beachten Sie, dass es sich bei der KPL um eine 64-Bit-Version handelt.
## Quellcode
Für den Fall, dass die Binärdateien, die bei der KPL-Installation bereitgestellt werden, für Ihre Umgebung nicht ausreichen, wird der Kern der KPL als C\$1\$1-Modul bereitgestellt. Der Quellcode für das C\$1\$1-Modul und die Java-Schnittstelle sind unter der Amazon Public License veröffentlicht und GitHub in der [Amazon Kinesis Producer Library](https://github.com/awslabs/amazon-kinesis-producer) verfügbar. Obwohl die KPL auf allen Plattformen verwendet werden kann, für die ein neuer, standardmäßiger C\$1\$1-Compiler und eine Java-Laufzeitumgebung verfügbar sind, unterstützt Amazon offiziell keine Plattformen, die nicht auf der Liste der unterstützten Plattformen enthalten sind.
# Die wichtigsten Konzepte von KPL
Die folgenden Abschnitte enthalten Konzepte und Terminologie, die Sie benötigen, um die Amazon Kinesis Producer Library (KPL) zu verstehen und davon zu profitieren.
**Topics**
+ [Datensätze](#kinesis-kpl-concepts-records)
+ [Stapelverarbeitung](#kinesis-kpl-concepts-batching)
+ [Aggregation](#kinesis-kpl-concepts-aggretation)
+ [Sammlung](#kinesis-kpl-concepts-collection)
## Datensätze
In dieser Anleitung wird zwischen *KPL-Benutzerdatensätzen* und *Datensätzen von Kinesis Data Streams* unterschieden. Wenn von einem *Datensatz* ohne weitere Angabe die Rede ist, ist ein *KPL-Benutzerdatensatz* gemeint. Wenn wir uns auf einen Datensatz von Kinesis Data Streams beziehen, sagen wir ausdrücklich *Datensatz von Kinesis Data Streams*.
Ein KPL-Benutzerdatensatz ist ein Daten-Blob mit einer bestimmten Bedeutung für den Benutzer. Zu den Beispielen zählen ein JSON-Blob, der ein Ereignis auf der Benutzeroberfläche einer Website darstellt oder der Protokolleintrag eines Webservers.
Ein Datensatz von Kinesis Data Streams ist eine Instance der `Record`-Datenstruktur, die von der API des Kinesis-Data-Streams-Dienstes definiert wird. Er enthält eine Sequenznummer, einen Partitionsschlüssel und einen Daten-Blob.
## Stapelverarbeitung
Unter *Stapelverarbeitung* versteht man das Durchführen einer einzelnen Aktion für mehrere Elemente gleichzeitig (im Gegensatz zur Ausführung ein und derselben Aktion für jedes Element separat).
In diesem Kontext steht „Element“ für einen Datensatz, der durch die Aktion an Kinesis Data Streams gesendet wird. Ohne Stapelverarbeitung würden Sie jeden Datensatz in einen separaten Datensatz von Kinesis Data Streams platzieren und eine HTTP-Anforderung erstellen, um ihn an Kinesis Data Streams zu senden. Mit Stapelverarbeitung können mehrere Datensätze in eine HTTP-Anforderung eingeschlossen werden.
Die KPL unterstützt zwei Arten der Stapelverarbeitung:
+ *Aggregation* – Speichern mehrerer Datensätze in einem einzelnen Datensatz von Kinesis Data Streams.
+ *Sammlung* – Verwenden der API-Operation `PutRecords` zum Senden mehrerer Datensätze aus Kinesis Data Streams an einen oder mehrere Shards in Ihrem Kinesis-Datenstrom.
Die zwei Arten der KPL-Stapelverarbeitung sind so konzipiert, dass sie gleichzeitig und unabhängig voneinander aktiviert oder deaktiviert werden können. Standardmäßig sind beide aktiviert.
## Aggregation
*Aggregation* bezieht sich auf die Speicherung mehrerer Datensätze in einem Datensatz von Kinesis Data Streams. Die Aggregation ermöglicht Kunden, die Anzahl der Datensätze zu erhöhen, die pro API-Aufruf gesendet werden. Dadurch steigt der Durchsatz des Produzenten deutlich.
Shards von Kinesis Data Streams unterstützen bis zu 1 000 Datensätze von Kinesis Data Streams pro Sekunde bzw. einen Durchsatz von 1 MB. Das Limit für Datensätze pro Sekunde von Kinesis Data Streams bindet Kunden mit Datensätzen kleiner als 1 KB. Durch die Datensatzaggregation können Kunden mehrere Datensätze in einem einzelnen Datensatz von Kinesis Data Streams zusammenfassen. So können Kunden Ihren Durchsatz pro Shard verbessern.
Stellen Sie sich den Fall eines Shards in der Region us-east-1 vor, der derzeit mit einer konstanten Rate von 1.000 Datensätzen pro Sekunde mit Datensätzen von jeweils 512 Byte ausgeführt wird. Mit der KPL-Aggregation können Sie 1 000 Datensätze in nur 10 Datensätze von Kinesis Data Streams verpacken und reduzieren so die Anfragen pro Sekunde (RPS) auf 10 (jeweils 50 KB).
## Sammlung
Mit *Sammlung* ist die Stapelverarbeitung mehrerer Datensätze von Kinesis Data Streams und das Senden von diesen in einer einzelnen HTTP-Anforderung mit einem Aufruf der API-Operation `PutRecords` gemeint. Dies steht im Gegensatz zum Senden einzelner Datensätze von Kinesis Data Streams in separaten HTTP-Anforderungen.
Durch eine Sammlung wird der Durchsatz erhöht, da der Aufwand für das Erstellen vieler separater HTTP-Anforderungen entfällt. `PutRecords` wurde speziell für diesen Zweck entwickelt.
Eine Sammlung unterscheidet sich von der Aggregation dahingehend, dass mit Gruppen von Datensätzen von Kinesis Data Streams gearbeitet wird. Die gesammelten Datensätze von Kinesis Data Streams können trotzdem mehrere Datensätze eines Benutzers enthalten. Die Beziehung lässt sich wie folgt visualisieren:
```
record 0 --|
record 1 | [ Aggregation ]
... |--> Amazon Kinesis record 0 --|
... | |
record A --| |
|
... ... |
|
record K --| |
record L | | [ Collection ]
... |--> Amazon Kinesis record C --|--> PutRecords Request
... | |
record S --| |
|
... ... |
|
record AA--| |
record BB | |
... |--> Amazon Kinesis record M --|
... |
record ZZ--|
```
# Integrieren Sie die KPL in den Herstellercode
Die Amazon Kinesis Producer Library (KPL) wird in einem separaten Prozess ausgeführt und kommuniziert über IPC mit Ihrem übergeordneten Benutzerprozess. Diese Architektur wird gelegentlich auch als [Microservice](http://en.wikipedia.org/wiki/Microservices) bezeichnet und aus zwei Gründen verwendet:
**1) Ihr Benutzerprozess stürzt auch dann nicht ab, wenn die KPL abstürzt**
Im Prozess sind möglicherweise Aufgaben enthalten, die nichts mit Kinesis Data Streams zu tun haben. Diese können auch bei einem Absturz der KPL weiterhin durchgeführt werden. Die KPL kann von Ihrem übergeordneten Benutzerprozess auch neu gestartet werden, sodass eine volle Betriebsfähigkeit wiederhergestellt wird (die Funktion ist in den offiziellen Wrappern enthalten).
Ein Beispiel hierfür ist ein Webserver, der Metriken an Kinesis Data Streams sendet. Der Server kann auch noch Seiten bereitstellen, wenn die Komponente Kinesis Data Streams nicht mehr betriebsfähig ist. Ein Absturz des gesamten Servers aufgrund eines Fehlers in der KPL würde einen unnötigen Ausfall verursachen.
**2) Es können beliebige Clients unterstützt werden**
Es gibt immer Kunden, die Sprachen verwenden, die nicht offiziell unterstützt werden. Diese Kunden sollten die KPL auch problemlos nutzen können.
## Matrix zur empfohlenen Verwendung
In der folgenden Verwendungsmatrix sind die empfohlenen Einstellungen für verschiedene Benutzer aufgeführt und Sie werden darüber informiert, ob und wie Sie die KPL verwenden sollten. Beachten Sie, dass bei aktivierter Aggregation auch eine Disaggregation verwendet werden muss, um die Datensätze auf der Konsumentenseite zu extrahieren.
| Sprache auf Produzentenseite | Sprache auf Konsumentenseite | KCL-Version | Prüfpunkt-Logik | Können Sie die KPL verwenden? | Einschränkungen |
| --- | --- | --- | --- | --- | --- |
| Alles außer Java | \$1 | \$1 | \$1 | Nein | – |
| Java | Java | Direkte Java-SDK-Verwendung | – | Ja | Bei aktivierter Aggregation muss nach GetRecords-Aufrufen die bereitgestellte Disaggregationsbibliothek verwendet werden. |
| Java | Alles außer Java | Direkte SDK-Verwendung | – | Ja | Aggregation muss deaktiviert werden. |
| Java | Java | 1.3.x | – | Ja | Aggregation muss deaktiviert werden. |
| Java | Java | 1.4.x | Prüfpunkt-Aufruf ohne Argumente | Ja | Keine |
| Java | Java | 1.4.x | Prüfpunkt-Aufruf mit expliziter Sequenznummer | Ja | Entweder muss die Aggregation deaktiviert oder der Code so geändert werden, dass erweiterte Sequenznummern für das Setzen von Prüfpunkten verwendet werden. |
| Java | Alles außer Java | 1.3.x \$1 mehrsprachiger Daemon \$1 sprachspezifischer Wrapper | – | Ja | Aggregation muss deaktiviert werden. |
# Schreiben Sie mit der KPL in Ihren Kinesis-Datenstream
In den folgenden Abschnitten wird Beispielcode in einem Schritt vom einfachsten Producer-Code bis hin zum vollständig asynchronen Code dargestellt.
## Barebones-Produzentencode
Der folgende Code reicht für die Entwicklung eines einfachen Produzenten aus. Die Benutzerdatensätze der Amazon Kinesis Producer Library (KPL) werden im Hintergrund verarbeitet.
```
// KinesisProducer gets credentials automatically like
// DefaultAWSCredentialsProviderChain.
// It also gets region automatically from the EC2 metadata service.
KinesisProducer kinesis = new KinesisProducer();
// Put some records
for (int i = 0; i < 100; ++i) {
ByteBuffer data = ByteBuffer.wrap("myData".getBytes("UTF-8"));
// doesn't block
kinesis.addUserRecord("myStream", "myPartitionKey", data);
}
// Do other stuff ...
```
## Reagieren Sie synchron auf Ergebnisse
Im vorherigen Beispiel wird vom Code nicht geprüft, ob die KPL-Benutzerdatensätze erfolgreich verarbeitet wurden. Die KPL führt alle Wiederholungen durch, die notwendig sind, um Ausfälle zu kompensieren. Wenn Sie jedoch die Ergebnisse prüfen möchten, können Sie sich diese, wie im folgenden Beispiel gezeigt, mit den `Future`-Objekten ansehen, die von `addUserRecord` zurückgegeben werden (vorheriges Beispiel aus Kontextgründen erneut aufgeführt).
```
KinesisProducer kinesis = new KinesisProducer();
// Put some records and save the Futures
List> putFutures = new LinkedList>();
for (int i = 0; i < 100; i++) {
ByteBuffer data = ByteBuffer.wrap("myData".getBytes("UTF-8"));
// doesn't block
putFutures.add(
kinesis.addUserRecord("myStream", "myPartitionKey", data));
}
// Wait for puts to finish and check the results
for (Future f : putFutures) {
UserRecordResult result = f.get(); // this does block
if (result.isSuccessful()) {
System.out.println("Put record into shard " +
result.getShardId());
} else {
for (Attempt attempt : result.getAttempts()) {
// Analyze and respond to the failure
}
}
}
```
## Reagieren Sie asynchron auf Ergebnisse
Im vorherigen Beispiel wird ein `get()` `Future` Objekt aufgerufen, das die Laufzeit blockiert. Wenn Sie die Laufzeit nicht blockieren möchten, können Sie einen asynchronen Callback verwenden, wie im folgenden Beispiel gezeigt:
```
KinesisProducer kinesis = new KinesisProducer();
FutureCallback myCallback = new FutureCallback() {
@Override public void onFailure(Throwable t) {
/* Analyze and respond to the failure */
};
@Override public void onSuccess(UserRecordResult result) {
/* Respond to the success */
};
};
for (int i = 0; i < 100; ++i) {
ByteBuffer data = ByteBuffer.wrap("myData".getBytes("UTF-8"));
ListenableFuture f = kinesis.addUserRecord("myStream", "myPartitionKey", data);
// If the Future is complete by the time we call addCallback, the callback will be invoked immediately.
Futures.addCallback(f, myCallback);
}
```
# Konfiguration der Amazon Kinesis Producer Library
Die Standardeinstellungen reichen für die meisten Anwendungsfälle aus. Bei Bedarf können Sie aber auch das Verhalten von `KinesisProducer` an Ihre Bedürfnisse anpassen. Dazu kann beispielsweise eine Instance der `KinesisProducerConfiguration`-Klasse an den `KinesisProducer`-Konstruktor übergeben werden:
```
KinesisProducerConfiguration config = new KinesisProducerConfiguration()
.setRecordMaxBufferedTime(3000)
.setMaxConnections(1)
.setRequestTimeout(60000)
.setRegion("us-west-1");
final KinesisProducer kinesisProducer = new KinesisProducer(config);
```
Sie können zudem eine Konfiguration aus einer Eigenschaftendatei laden:
```
KinesisProducerConfiguration config = KinesisProducerConfiguration.fromPropertiesFile("default_config.properties");
```
Sie können jeden Pfad und jeden Dateinamen ersetzen, auf den der Benutzerprozess Zugriff hat. Sie können weitere SET-Methoden auf der so erstellten `KinesisProducerConfiguration`-Instance aufrufen, um die Konfiguration anzupassen.
In der Eigenschaftendatei sollten Parameter anhand ihrer Namen in PascalCase angegeben werden. Die Namen stimmen mit denen überein, die in den SET-Methoden der `KinesisProducerConfiguration`-Klasse verwendet werden. Beispiel:
```
RecordMaxBufferedTime = 100
MaxConnections = 4
RequestTimeout = 6000
Region = us-west-1
```
Weitere Informationen zur Verwendung von Konfigurationsparametern und zu Wertgrenzen finden Sie in der [Beispieldatei mit den Konfigurationseigenschaften unter GitHub](https://github.com/awslabs/amazon-kinesis-producer/blob/master/java/amazon-kinesis-producer-sample/default_config.properties).
Beachten Sie, dass nach dem Initialisieren von `KinesisProducer` eine Änderung der verwendeten `KinesisProducerConfiguration`-Instance keine weiteren Auswirkungen mehr hat. `KinesisProducer` unterstützt derzeit keine dynamische Neukonfiguration.
# Implementieren Sie die Deaggregation für Verbraucher
Ab Version 1.4.0 unterstützt die KCL eine automatische Disaggregation von KPL-Benutzerdatensätzen. Code für Konsumentenanwendungen, der mit früheren KCL-Versionen geschrieben wurde, wird nach der Aktualisierung der KCL ohne Änderungen kompiliert. Wenn jedoch eine KPL-Aggregation auf Konsumentenseite verwendet wird, ist beim Checkpointing Folgendes zu beachten: Alle untergeordneten Datensätze innerhalb eines aggregierten Datensatzes haben dieselbe Sequenznummer. Somit müssen zusätzliche Daten mit dem Prüfpunkt gespeichert werden, wenn Sie zwischen untergeordneten Datensätze unterscheiden müssen. Diese zusätzlichen Daten werden als *Teilsequenznummer* bezeichnet.
**Topics**
+ [Migrieren Sie von früheren Versionen der KCL](#kinesis-kpl-consumer-deaggregation-migration)
+ [Verwenden Sie KCL-Erweiterungen für die KPL-Deaggregation](#kinesis-kpl-consumer-deaggregation-extensions)
+ [Direkt verwenden GetRecords](#kinesis-kpl-consumer-deaggregation-getrecords)
## Migrieren Sie von früheren Versionen der KCL
Sie müssen Ihre vorhandenen Aufrufe nicht ändern, um Checkpointing mit Aggregation durchzuführen. Sie können nach wie vor alle Datensätze erfolgreich abrufen, die in Kinesis Data Streams gespeichert sind. Die KCL bietet jetzt zwei neue Checkpoint-Operationen zur Unterstützung bestimmter Anwendungsfälle, die im Folgenden beschrieben werden.
Wenn Ihr vorhandener Code vor der KPL-Unterstützung für die KCL geschrieben wurde und Ihre Checkpoint-Operation ohne Argumente aufgerufen wird, entspricht dies dem Checkpointing der Sequenznummer des letzten KPL-Benutzerdatensatzes im Batch. Wird Ihre Prüfpunkt-Operation mit einer Sequenznummernzeichenfolge aufgerufen, entspricht dies dem Checkpointing der angegebenen Sequenznummer des Stapels zusammen mit der impliziten Teilsequenznummer 0 (null).
Das Aufrufen der neuen KCL-Prüfpunkt-Operation `checkpoint()` ohne Argumente entspricht semantisch dem Checkpointing der Sequenznummer des letzten `Record`-Aufrufs im Stapels zusammen mit der impliziten Teilsequenznummer 0 (null).
Das Aufrufen der neuen KCL-Prüfpunkt-Operation `checkpoint(Record record)` entspricht semantisch dem Checkpointing der angegebenen Sequenznummer von `Record` zusammen mit der impliziten Teilsequenznummer 0 (null). Handelt es sich beim `Record`-Aufruf um einen `UserRecord`, wird ein Checkpointing der Sequenznummer und Teilsequenznummer von `UserRecord` durchgeführt.
Das Aufrufen der neuen KCL-Prüfpunkt-Operation `checkpoint(String sequenceNumber, long subSequenceNumber)` führt explizit zu einem Checkpointing der angegebenen Sequenznummer zusammen mit der angegebenen Teilsequenznummer.
In all diesen Fällen kann, nachdem der Prüfpunkt in der Amazon-DynamoDB-Prüfpunkttabelle gespeichert wurde, die KCL das Abrufen der Datensätze fehlerfrei wieder aufnehmen, auch wenn die Anwendung abstürzt und neu gestartet wird. Sind mehr Datensätze in der Sequenz enthalten, beginnt das Abrufen mit dem Datensatz, dem die nächste Teilsequenznummer zugeordnet wurde, innerhalb des Datensatzes mit der Sequenznummer, für die zuletzt ein Prüfpunkt gesetzt wurde. Enthält der letzte Prüfpunkt die allerletzte Teilsequenznummer des vorherigen Sequenznummerndatensatzes, beginnt das Abrufen mit dem Datensatz, dem die nächst folgende Sequenznummer zugeordnet ist.
Im nächsten Abschnitt werden Einzelheiten zur Sequenz- und Folgesequenzprüfung für Benutzer beschrieben, die vermeiden müssen, dass Datensätze übersprungen und dupliziert werden. Wenn das Überspringen (oder Duplizieren) bei einem Stopp und Neustart der Datensatzverarbeitung Ihres Konsumenten keine Rolle spielt, können Sie Ihren vorhandenen Code ohne Änderungen ausführen.
## Verwenden Sie KCL-Erweiterungen für die KPL-Deaggregation
Die KPL-Deaggregation kann Teilsequenz-Checkpoints beinhalten. Zur Unterstützung des Checkpointings einer Teilsequenz wurde eine `UserRecord`-Klasse zur KCL hinzugefügt:
```
public class UserRecord extends Record {
public long getSubSequenceNumber() {
/* ... */
}
@Override
public int hashCode() {
/* contract-satisfying implementation */
}
@Override
public boolean equals(Object obj) {
/* contract-satisfying implementation */
}
}
```
Diese Klasse wird nun anstelle von `Record` verwendet. Sie führt nicht zu Fehlern im vorhandenen Code, da es sich um eine Subklasse von `Record` handelt. Die `UserRecord`-Klasse repräsentiert sowohl tatsächlich untergeordnete Datensätze als auch standardmäßige, nicht aggregierte Datensätze. Nicht-aggregierte Datensätze sind aggregierte Datensätze mit genau einem untergeordneten Datensatz.
Darüber hinaus wurden zwei neue Operationen zu `IRecordProcessorCheckpointer` hinzugefügt:
```
public void checkpoint(Record record);
public void checkpoint(String sequenceNumber, long subSequenceNumber);
```
Führen Sie die folgende Konvertierung durch, um mit dem Checkpointing einer Teilsequenznummer zu beginnen: Ändern Sie folgenden Formularcode:
```
checkpointer.checkpoint(record.getSequenceNumber());
```
Neue Formularcode:
```
checkpointer.checkpoint(record);
```
Wir empfehlen für das Checkpointing der Teilsequenz das `checkpoint(Record record)`-Formular. Wenn Sie jedoch bereits `sequenceNumbers` in Zeichenfolgen für das Checkpointing gespeichert haben, sollten Sie nun auch `subSequenceNumber` speichern, wie im folgenden Beispiel gezeigt:
```
String sequenceNumber = record.getSequenceNumber();
long subSequenceNumber = ((UserRecord) record).getSubSequenceNumber(); // ... do other processing
checkpointer.checkpoint(sequenceNumber, subSequenceNumber);
```
Die Umwandlung von nach ist `UserRecord` immer erfolgreich`Record`, da die Implementierung immer verwendet. `UserRecord` Wenn Sie keine arithmetischen Operationen für die Sequenznummern durchführen müssen, ist dieser Ansatz nicht zu empfehlen.
Während der Verarbeitung der KPL-Benutzerdatensätze schreibt die KCL die Teilsequenznummer für jede Zeile als zusätzliches Feld in die Amazon DynamoDB. Frühere Versionen der KCL nutzten `AFTER_SEQUENCE_NUMBER` zum Abrufen von Datensätzen bei der Wiederaufnahme von Prüfpunkten. Die aktuelle KCL mit KPL-Support verwendet stattdessen `AT_SEQUENCE_NUMBER`. Wenn der Datensatz bei der Sequenznummer abgerufen wird, bei der ein Prüfpunkt gesetzt wurde, wird die Teilsequenznummer, für die ein Checkpointing durchgeführt wurde, geprüft und untergeordnete Datensätze gegebenenfalls ausgelassen (möglicherweise alle, wenn beim letzten Datensatz ein Prüfpunkt gesetzt wurde). Nochmals: Nicht aggregierte Datensätze können als aggregierte Datensätze mit einem einzelnen untergeordneten Datensatz betrachtet werden, sodass derselbe Algorithmus sowohl für aggregierte als auch für nicht aggregierte Datensätze funktioniert.
## Direkt verwenden GetRecords
Sie können sich auch gegen die Verwendung der KCL entscheiden und stattdessen direkt die API-Operation `GetRecords` aufrufen, um Datensätze aus Kinesis Data Streams abzurufen. Zum Entpacken dieser abgerufenen Datensätze in Ihre ursprünglichen KPL-Benutzerdatensätze rufen Sie eine der folgenden statischen Operationen in `UserRecord.java` auf:
```
public static List deaggregate(List records)
public static List deaggregate(List records, BigInteger startingHashKey, BigInteger endingHashKey)
```
Die erste Operation verwendet den Standardwert `0` (null) für `startingHashKey` und den Standardwert `2^128 -1` für `endingHashKey`.
Jede dieser Operationen führt eine Disaggregation der vorhandenen Liste der Datensätze aus Kinesis Data Streams in eine Liste mit KPL-Benutzerdatensätzen durch. Alle KPL-Benutzerdatensätze, deren expliziter Hash- oder Partitionsschlüssel außerhalb des Bereichs von `startingHashKey` (einschließlich) liegt, sowie `endingHashKey` (einschließlich) werden aus der zurückgegebenen Datensatzliste entfernt.
# Verwenden Sie die KPL mit Amazon Data Firehose
Wenn Sie die Kinesis Producer Library (KPL) verwenden, um Daten an einen Kinesis Data Stream zu schreiben, können Sie die Aggregation dazu verwenden, die an diesen Kinesis Data Stream geschriebenen Datensätze zu kombinieren. Wenn Sie diesen Datenstrom dann als Quelle für Ihren Firehose-Lieferstream verwenden, deaggregiert Firehose die Datensätze, bevor sie an das Ziel geliefert werden. Wenn Sie Ihren Delivery Stream so konfigurieren, dass er die Daten transformiert, deaggregiert Firehose die Datensätze, bevor es sie zustellt. AWS Lambda Weitere Informationen finden Sie unter [Schreiben zu Amazon Firehose mithilfe von Kinesis Data Streams](https://docs.aws.amazon.com/firehose/latest/dev/writing-with-kinesis-streams.html).
# Verwenden Sie die KPL mit der Schema Registry AWS Glue
Sie können Ihre Kinesis-Datenströme in die AWS Glue Schema Registry integrieren. Mit der AWS Glue Schema Registry können Sie Schemas zentral erkennen, steuern und weiterentwickeln und gleichzeitig sicherstellen, dass die erstellten Daten kontinuierlich anhand eines registrierten Schemas validiert werden. Ein Schema definiert die Struktur und das Format eines Datensatzes. Ein Schema ist eine versionierte Spezifikation für zuverlässige Datenveröffentlichung, -nutzung oder -speicherung. Mit der AWS Glue Schema Registry können Sie die end-to-end Datenqualität und Datenverwaltung in Ihren Streaming-Anwendungen verbessern. Weitere Informationen finden Sie unter [AWS Glue Schema Registry](https://docs.aws.amazon.com/glue/latest/dg/schema-registry.html). Alternativ können Sie diese Integration über die Bibliotheken KPL und Kinesis Client Library (KCL) in Java einrichten.
**Wichtig**
Derzeit wird die Integration von Kinesis Data Streams und AWS Glue Schema-Registry nur für Kinesis-Datenstreams unterstützt, die in Java implementierte KPL-Producer verwenden. Mehrsprachige Unterstützung wird nicht bereitgestellt.
Detaillierte Anweisungen zur Einrichtung der Integration von Kinesis Data Streams mit Schema Registry mithilfe der KPL finden Sie im Abschnitt „Interaktion mit Daten mithilfe der KPL/KCL Bibliotheken“ unter [Anwendungsfall: Integration von Amazon Kinesis Data Streams mit der AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/schema-registry-integrations.html#schema-registry-integrations-kds) Schema Registry.
# Konfigurieren Sie die KPL-Proxykonfiguration
Für Anwendungen, die keine direkte Verbindung zum Internet herstellen können, unterstützen alle AWS SDK-Clients die Verwendung von HTTP- oder HTTPS-Proxys. In einer typischen Unternehmensumgebung muss der gesamte ausgehende Netzwerkverkehr über Proxyserver geleitet werden. Wenn Ihre Anwendung Kinesis Producer Library (KPL) zum Sammeln und Senden von Daten AWS in eine Umgebung verwendet, die Proxyserver verwendet, benötigt Ihre Anwendung eine KPL-Proxykonfiguration. KPL ist eine High-Level-Bibliothek, die auf dem AWS Kinesis SDK aufbaut. Sie ist in einen systemeigenen Prozess und einen Wrapper aufgeteilt. Der native Prozess führt alle Aufgaben der Verarbeitung und des Sendens von Datensätzen aus, während der Wrapper den nativen Prozess verwaltet und mit ihm kommuniziert. Weitere Informationen finden Sie unter [Implementieren effizienter und zuverlässiger Produzenten mit der Amazon Kinesis Producer Library](https://aws.amazon.com/blogs/big-data/implementing-efficient-and-reliable-producers-with-the-amazon-kinesis-producer-library/).
Der Wrapper ist in Java geschrieben und der native Prozess ist in C\$1\$1 unter Verwendung des Kinesis SDK geschrieben. KPL-Version 0.14.7 und höher unterstützt jetzt die Proxykonfiguration im Java-Wrapper, der alle Proxykonfigurationen an den nativen Prozess übergeben kann. Weitere Informationen finden Sie unter [https://github.com/awslabs/amazon-kinesis-producer/releases/tag/v](https://github.com/awslabs/amazon-kinesis-producer/releases/tag/v0.14.7)0.14.7.
Alternativ können Sie den folgenden Code verwenden, um Proxykonfigurationen zu Ihren KPL-Anwendungen hinzuzufügen.
```
KinesisProducerConfiguration configuration = new KinesisProducerConfiguration();
// Next 4 lines used to configure proxy
configuration.setProxyHost("10.0.0.0"); // required
configuration.setProxyPort(3128); // default port is set to 443
configuration.setProxyUserName("username"); // no default
configuration.setProxyPassword("password"); // no default
KinesisProducer kinesisProducer = new KinesisProducer(configuration);
```
# Richtlinie zum Lebenszyklus der KPL-Version
In diesem Thema wird die Versions-Lebenszyklus-Richtlinie für die Amazon Kinesis Producer Library (KPL) beschrieben. AWS stellt regelmäßig neue Versionen für KPL-Versionen bereit, um neue Funktionen und Verbesserungen, Bugfixes, Sicherheitspatches und Abhängigkeitsupdates zu unterstützen. Wir empfehlen Ihnen, up-to-date bei KPL-Versionen zu bleiben, um über die neuesten Funktionen, Sicherheitsupdates und die zugrunde liegenden Abhängigkeiten auf dem Laufenden zu bleiben. Wir empfehlen **nicht,** weiterhin eine KPL-Version zu verwenden, die nicht unterstützt wird.
Der Lebenszyklus wichtiger KPL-Versionen besteht aus den folgenden drei Phasen:
+ **Allgemeine Verfügbarkeit (GA)** — Während dieser Phase wird die Hauptversion vollständig unterstützt. AWS bietet regelmäßige Versionen von Neben- und Patch-Versionen, die Unterstützung für neue Funktionen oder API-Updates für Kinesis Data Streams sowie Fehler- und Sicherheitskorrekturen beinhalten.
+ **Wartungsmodus** — AWS Beschränkt die Veröffentlichung von Patch-Versionen auf kritische Bugfixes und Sicherheitsprobleme. Die Hauptversion erhält keine Updates für neue Funktionen oder APIs für Kinesis Data Streams.
+ **E nd-of-support** — Die Hauptversion wird keine Updates oder Releases mehr erhalten. Zuvor veröffentlichte Versionen werden weiterhin über öffentliche Paketmanager verfügbar sein und der Code bleibt aktiviert GitHub. Die Verwendung einer Version, die erreicht wurde, end-of-support erfolgt nach eigenem Ermessen des Benutzers. Wir empfehlen Ihnen, auf die neueste Hauptversion zu aktualisieren.
| Hauptversion | Aktuelle Phase | Datum der Veröffentlichung | Datum des Wartungsmodus | End-of-support Datum |
| --- | --- | --- | --- | --- |
| KPL 0.x | Wartungsmodus | 2015-06-02 | 17.04.2025 | 2026-01-30 |
| KPL 1.x | Allgemeine Verfügbarkeit | 2024-12-15 | -- | -- |
# Entwickeln Sie Produzenten mithilfe der Amazon Kinesis Data Streams Streams-API mit dem AWS SDK für Java
Sie können Producer mithilfe der Amazon Kinesis Data Streams Streams-API mit dem AWS SDK for Java entwickeln. Wenn Sie Kinesis Data Streams zum ersten Mal verwenden, sollten Sie sich zunächst mit den Konzepten und der Terminologie in [Was ist Amazon Kinesis Data Streams?](introduction.md) und [Verwenden Sie die AWS CLI , um Amazon Kinesis Data Streams Streams-Operationen durchzuführen](getting-started.md) vertraut machen.
In den Beispielen wird die [API für Kinesis Data Streams](https://docs.aws.amazon.com/kinesis/latest/APIReference/) behandelt und das [AWS -SDK for Java](https://aws.amazon.com/sdk-for-java/) eingesetzt, um Daten zu einem Stream hinzuzufügen. Für die meisten Anwendungsfälle sollten Sie jedoch die KPL-Bibliothek von Kinesis Data Streams verwenden. Weitere Informationen finden Sie unter [Entwickeln Sie Produzenten mithilfe der Amazon Kinesis Producer Library (KPL)](developing-producers-with-kpl.md).
Anhand des Java-Beispiel-Codes in diesem Abschnitt, der nach Operationstyp logisch unterteilt ist, wird gezeigt, wie Sie grundlegende API-Vorgänge mit Kinesis Data Streams durchführen. Diese Beispiele stellen keinen produktionsbereiten Code dar, d. h. es werden nicht alle möglichen Ausnahmen geprüft und es werden nicht alle möglichen Sicherheits- oder Leistungsüberlegungen berücksichtigt. Sie können zudem die [API für Kinesis Data Streams](https://docs.aws.amazon.com/kinesis/latest/APIReference/) mit anderen Programmiersprachen aufrufen. Weitere Informationen zu allen verfügbaren AWS SDKs Produkten finden Sie unter [Start Developing with Amazon Web Services](https://aws.amazon.com/developers/getting-started/).
Für jede Aufgabe gibt es Voraussetzungen. So können Sie beispielsweise erst dann Daten zu einem Stream hinzufügen, wenn Sie einen erstellt haben. Deshalb müssen Sie einen Client anlegen. Weitere Informationen finden Sie unter [Kinesis-Datenstreams erstellen und verwalten](working-with-streams.md).
**Topics**
+ [Daten zu einem Stream hinzufügen](#kinesis-using-sdk-java-add-data-to-stream)
+ [Interagieren Sie mit Daten mithilfe der AWS Glue Schema Registry](kinesis-integration-glue-schema-registry.md)
## Daten zu einem Stream hinzufügen
Sobald ein Stream eingerichtet wurde, können Sie Daten in Form von Datensätzen hinzufügen. Ein Datensatz ist eine Datenstruktur, die die zu verarbeitenden Daten in Form eines Daten-Blobs enthält. Nach dem Speichern der Daten im Datensatz prüft, interpretiert und ändert Kinesis Data Streams die Daten nicht. Jeder Datensatz verfügt zudem über eine zugeordnete Sequenznummer und einen Partitionsschlüssel.
Die API für Kinesis Data Streams unterstützt das Hinzufügen von Daten zu einem Stream mittels zweier Operationen: [https://docs.aws.amazon.com/kinesis/latest/APIReference/API_PutRecords.html](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_PutRecords.html) und [https://docs.aws.amazon.com/kinesis/latest/APIReference/API_PutRecord.html](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_PutRecord.html). Die Operation `PutRecords` sendet per HTTP-Anforderung mehrere Datensätze an Ihren Stream und die Operation `PutRecord` sendet immer nur einen Datensatz, dabei ist für jeden Datensatz eine separate HTTP-Anforderung erforderlich. Für die meisten Anwendungen sollten Sie `PutRecords` bevorzugen, da diese Operation pro Datenproduzent einen höheren Durchsatz erzielt. Weitere Informationen zu diesen Operationen finden Sie unten in separaten Unterabschnitten.
**Topics**
+ [Fügen Sie mehrere Datensätze hinzu mit PutRecords](#kinesis-using-sdk-java-putrecords)
+ [Fügen Sie einen einzelnen Datensatz hinzu mit PutRecord](#kinesis-using-sdk-java-putrecord)
Beachten Sie Folgendes: Wenn Ihre Quellanwendung Daten mit der API für Kinesis Data Streams zum Stream hinzufügt, gibt es vermutlich eine oder mehrere Konsumentenanwendungen, die gleichzeitig Daten aus dem Stream verarbeiten. Weitere Informationen dazu, wie Konsumenten Daten über die API für Kinesis Data Streams abrufen, erhalten Sie unter [Daten aus einem Stream abrufen](developing-consumers-with-sdk.md#kinesis-using-sdk-java-get-data).
**Wichtig**
[Ändern Sie den Aufbewahrungszeitraum für Daten](kinesis-extended-retention.md)
### Fügen Sie mehrere Datensätze hinzu mit PutRecords
Die [https://docs.aws.amazon.com/kinesis/latest/APIReference/API_PutRecords.html](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_PutRecords.html)-Operation sendet in einer einzelnen Anforderung mehrere Datensätze an Kinesis Data Streams. Mit `PutRecords` erzielen Produzenten einen höheren Durchsatz, wenn sie Daten an ihren Kinesis-Datenstrom senden. Jede `PutRecords`-Anfrage kann bis zu 500 Datensätze unterstützen. Die maximale Größe jedes Datensatzes in der Anforderung beträgt 1 MB bis zu einem Limit von 5 MB für die gesamte Anforderung einschließlich Partitionsschlüsseln. Wie bei der unten beschriebenen einzelnen `PutRecord`-Operation nutzt `PutRecords` Sequenznummern und Partitionsschlüssel. Der `PutRecord`-Parameter `SequenceNumberForOrdering` ist jedoch nicht in einem `PutRecords`-Aufruf enthalten. Die `PutRecords`-Operation versucht, alle Datensätze in der natürlichen Reihenfolge der Anforderung zu verarbeiten.
Jeder Datensatz hat eine eindeutige Sequenznummer. Die Sequenznummer wird von Kinesis Data Streams zugewiesen, nachdem Sie `client.putRecords` aufgerufen haben, um die Datensätze zum Stream hinzuzufügen. Sequenznummern für denselben Partitionsschlüssel steigen in der Regel im Laufe der Zeit; je länger die Zeitdauer zwischen `PutRecords`-Anforderungen ist, desto größer wird die Sequenznummer.
**Anmerkung**
Sequenznummern können nicht als Index für Datensätze innerhalb desselben Streams verwendet werden. Nutzen Sie für die logische Unterteilung von Datensätzen Partitionsschlüssel oder erstellen Sie für jeden Datensatz einen separaten Stream.
Eine `PutRecords`-Anforderung kann Datensätze mit unterschiedlichen Partitionsschlüsseln enthalten. Der Anforderung gilt für einen Stream. Jede Anforderung kann eine beliebige Kombination aus Partitionsschlüsseln und Datenschlüsseln enthalten, sofern die Grenzwerte der Anforderung nicht überschritten werden. Anforderungen mit vielen verschiedenen Partitionsschlüsseln an Streams mit vielen verschiedenen Shards sind im Allgemeinen schneller als Anforderungen mit wenigen Partitionsschlüsseln an Streams mit nur wenigen Shards. Die Anzahl der Partitionsschlüssel sollte viel größer sein als die Anzahl der Shards, um Latenzzeiten zu verkürzen und einen maximalen Durchsatz zu erzielen.
#### PutRecords Beispiel
Der folgende Code erstellt 100 Datensätze mit sequenziellen Partitionsschlüsseln und übergibt diese an einen Stream namens `DataStream`.
```
AmazonKinesisClientBuilder clientBuilder = AmazonKinesisClientBuilder.standard();
clientBuilder.setRegion(regionName);
clientBuilder.setCredentials(credentialsProvider);
clientBuilder.setClientConfiguration(config);
AmazonKinesis kinesisClient = clientBuilder.build();
PutRecordsRequest putRecordsRequest = new PutRecordsRequest();
putRecordsRequest.setStreamName(streamName);
List putRecordsRequestEntryList = new ArrayList<>();
for (int i = 0; i < 100; i++) {
PutRecordsRequestEntry putRecordsRequestEntry = new PutRecordsRequestEntry();
putRecordsRequestEntry.setData(ByteBuffer.wrap(String.valueOf(i).getBytes()));
putRecordsRequestEntry.setPartitionKey(String.format("partitionKey-%d", i));
putRecordsRequestEntryList.add(putRecordsRequestEntry);
}
putRecordsRequest.setRecords(putRecordsRequestEntryList);
PutRecordsResult putRecordsResult = kinesisClient.putRecords(putRecordsRequest);
System.out.println("Put Result" + putRecordsResult);
```
Die `PutRecords`-Antwort umfasst ein Array von `Records`-Antworten. Jeder Eintrag im Antwort-Array korreliert direkt mit einem Eintrag im Anforderungs-Array und zwar in natürlicher Reihenfolge von oben nach unten wie in der Anforderung und der Antwort. Das `Records`-Antwort-Array enthält stets die gleiche Anzahl an Datensätzen wie das Anforderungs-Array.
#### Behandeln Sie Fehler bei der Verwendung PutRecords
Standardmäßig führt ein Fehler bei einzelnen Datensätzen innerhalb einer Anforderung nicht zur Beendigung der Verarbeitung nachfolgender Datensätze in einer `PutRecords`-Anforderung. Das bedeutet, dass ein `Records`-Antwort-Array sowohl erfolgreich verarbeitete als auch nicht erfolgreich verarbeitete Datensätze enthält. Sie müssen nicht erfolgreich verarbeitete Datensätze erkennen und in einen nachfolgenden Aufruf aufnehmen.
Erfolgreich verarbeitete Datensätze enthalten `SequenceNumber`- und `ShardID`-Werte, nicht erfolgreiche verarbeitete Datensätze enthalten `ErrorCode`-und `ErrorMessage`-Werte. Der `ErrorCode`-Parameter gibt den Fehlertyp an. Folgende Werte sind möglich: `ProvisionedThroughputExceededException` oder `InternalFailure`. `ErrorMessage` enthält weitere Informationen zur `ProvisionedThroughputExceededException`-Ausnahme, einschließlich Konto-ID, Stream-Name und Shard-ID des gedrosselten Datensatzes. Im folgenden Beispiel umfasst eine `PutRecords`-Anforderung drei Datensätze. Der zweite Datensatz schlägt fehl und wird in der Antwort angegeben.
**Example PutRecords Syntax anfordern**
```
{
"Records": [
{
"Data": "XzxkYXRhPl8w",
"PartitionKey": "partitionKey1"
},
{
"Data": "AbceddeRFfg12asd",
"PartitionKey": "partitionKey1"
},
{
"Data": "KFpcd98*7nd1",
"PartitionKey": "partitionKey3"
}
],
"StreamName": "myStream"
}
```
**Example PutRecords Syntax der Antwort**
```
{
"FailedRecordCount”: 1,
"Records": [
{
"SequenceNumber": "21269319989900637946712965403778482371",
"ShardId": "shardId-000000000001"
},
{
“ErrorCode":”ProvisionedThroughputExceededException”,
“ErrorMessage": "Rate exceeded for shard shardId-000000000001 in stream exampleStreamName under account 111111111111."
},
{
"SequenceNumber": "21269319989999637946712965403778482985",
"ShardId": "shardId-000000000002"
}
]
}
```
Datensätze, die nicht erfolgreich verarbeitet wurden, können in nachfolgende `PutRecords`-Anforderungen aufgenommen werden. Überprüfen Sie zuerst den Parameter `FailedRecordCount` im `putRecordsResult`, um zu bestätigen, ob Datensätze in der Anforderung fehlgeschlagen sind. Wenn dies der Fall ist, darf jeder `putRecordsEntry`, dessen `ErrorCode` nicht `null` ist, nicht in der nächsten Anforderung hinzugefügt werden. Ein Beispiel für diese Art von Handler finden Sie in folgendem Code:
**Example PutRecords Fehlerhandler**
```
PutRecordsRequest putRecordsRequest = new PutRecordsRequest();
putRecordsRequest.setStreamName(myStreamName);
List putRecordsRequestEntryList = new ArrayList<>();
for (int j = 0; j < 100; j++) {
PutRecordsRequestEntry putRecordsRequestEntry = new PutRecordsRequestEntry();
putRecordsRequestEntry.setData(ByteBuffer.wrap(String.valueOf(j).getBytes()));
putRecordsRequestEntry.setPartitionKey(String.format("partitionKey-%d", j));
putRecordsRequestEntryList.add(putRecordsRequestEntry);
}
putRecordsRequest.setRecords(putRecordsRequestEntryList);
PutRecordsResult putRecordsResult = amazonKinesisClient.putRecords(putRecordsRequest);
while (putRecordsResult.getFailedRecordCount() > 0) {
final List failedRecordsList = new ArrayList<>();
final List putRecordsResultEntryList = putRecordsResult.getRecords();
for (int i = 0; i < putRecordsResultEntryList.size(); i++) {
final PutRecordsRequestEntry putRecordRequestEntry = putRecordsRequestEntryList.get(i);
final PutRecordsResultEntry putRecordsResultEntry = putRecordsResultEntryList.get(i);
if (putRecordsResultEntry.getErrorCode() != null) {
failedRecordsList.add(putRecordRequestEntry);
}
}
putRecordsRequestEntryList = failedRecordsList;
putRecordsRequest.setRecords(putRecordsRequestEntryList);
putRecordsResult = amazonKinesisClient.putRecords(putRecordsRequest);
}
```
### Fügen Sie einen einzelnen Datensatz hinzu mit PutRecord
Jeder Aufruf von [https://docs.aws.amazon.com/kinesis/latest/APIReference/API_PutRecord.html](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_PutRecord.html) wird auf einem einzelnen Datensatz ausgeführt. Bevorzugen Sie die `PutRecords`-Operation, die in [Fügen Sie mehrere Datensätze hinzu mit PutRecords](#kinesis-using-sdk-java-putrecords) beschrieben ist, es sei denn, Ihre Anwendung muss stets einzelne Datensätze per Anforderung senden oder es liegen andere Gründe vor, die gegen den Einsatz von `PutRecords` sprechen.
Jeder Datensatz hat eine eindeutige Sequenznummer. Die Sequenznummer wird von Kinesis Data Streams zugewiesen, nachdem Sie `client.putRecord` aufgerufen haben, um den Datensatz zum Stream hinzuzufügen. Sequenznummern für denselben Partitionsschlüssel steigen in der Regel im Laufe der Zeit; je länger die Zeitdauer zwischen `PutRecord`-Anforderungen ist, desto größer wird die Sequenznummer.
Wenn nacheinander viele PUT-Operationen durchgeführt werden, steigen die zurückgegebenen Sequenznummern nicht zwangsläufig an, da Kinesis Data Streams diese als gleichzeitig interpretiert. Um steigende Sequenznummern für denselben Partitionsschlüssel sicherzustellen, sollten Sie den `SequenceNumberForOrdering`-Parameter so verwenden, wie es im [PutRecord Beispiel](#kinesis-using-sdk-java-putrecord-example)-Codebeispiel gezeigt wird.
Unabhängig davon, ob Sie `SequenceNumberForOrdering` verwenden, werden Datensätze, die Kinesis Data Streams über einen `GetRecords`-Aufruf empfängt, streng nach Sequenznummern sortiert.
**Anmerkung**
Sequenznummern können nicht als Index für Datensätze innerhalb desselben Streams verwendet werden. Nutzen Sie für die logische Unterteilung von Datensätzen Partitionsschlüssel oder erstellen Sie für jeden Datensatz einen separaten Stream.
Ein Partitionsschlüssel wird verwendet, um Daten in einem Stream zu gruppieren. Ein Datensatz wird einem Shard innerhalb des Streams basierend auf dessen Partitionsschlüssel zugewiesen. Insbesondere Kinesis Data Streams verwendet den Partitionsschlüssel als Eingabe für eine Hash-Funktion, die den Partitionsschlüssel (und die zugehörigen Daten) einem bestimmten Shard zuordnet.
Aufgrund dieses Hashing-Mechanismus werden alle Datensätze mit demselben Partitionsschlüssel zum selben Shard im Stream zugeordnet. Wenn jedoch die Anzahl der Partitionsschlüssel die Anzahl der Shards übersteigt, enthalten einige Shards zwangsläufig Datensätze mit unterschiedlichen Partitionsschlüsseln. Vom Design-Standpunkt aus sollte die Anzahl der Shards (die über die `setShardCount`-Methode von `CreateStreamRequest` angegeben wird) wesentlich geringer sein als die Anzahl der eindeutigen Partitionsschlüssel und das Datenvolumen für einen einzelnen Partitionsschlüssel sollte wesentlich geringer sein, als die Shard-Kapazität, um sicherzustellen, dass alle Shards gut ausgelastet sind.
#### PutRecord Beispiel
Der folgende Code erstellt 10 Datensätze, die auf zwei Partitionsschlüssel verteilt werden, und fügt diese einem Stream namens `myStreamName` hinzu.
```
for (int j = 0; j < 10; j++)
{
PutRecordRequest putRecordRequest = new PutRecordRequest();
putRecordRequest.setStreamName( myStreamName );
putRecordRequest.setData(ByteBuffer.wrap( String.format( "testData-%d", j ).getBytes() ));
putRecordRequest.setPartitionKey( String.format( "partitionKey-%d", j/5 ));
putRecordRequest.setSequenceNumberForOrdering( sequenceNumberOfPreviousRecord );
PutRecordResult putRecordResult = client.putRecord( putRecordRequest );
sequenceNumberOfPreviousRecord = putRecordResult.getSequenceNumber();
}
```
Beim zuvor beschriebenen Codebeispiel wird `setSequenceNumberForOrdering` eingesetzt, um eine aufsteigende Reihenfolge innerhalb der einzelnen Partitionsschlüssel zu gewährleisten. Für eine effektive Verwendung des Parameters setzen Sie die `SequenceNumberForOrdering` des aktuellen Datensatzes (Datensatz *n*) auf die Sequenznummer des vorhergehenden Datensatzes (Datensatz *n-1*). Rufen Sie `getSequenceNumber` auf dem Ergebnis von `putRecord` auf, um die Sequenznummer des Datensatzes zu erhalten, der zum Stream hinzugefügt wurde.
Der `SequenceNumberForOrdering`-Parameter stellt strikt aufsteigende Sequenznummern für denselben Partitionsschlüssel sicher. `SequenceNumberForOrdering` stellt keine Datensatzsortierung bei mehreren Partitionsschlüsseln bereit.
# Interagieren Sie mit Daten mithilfe der AWS Glue Schema Registry
Sie können Ihre Kinesis-Datenströme in die AWS Glue Schema Registry integrieren. Mit der AWS Glue Schema Registry können Sie Schemas zentral erkennen, steuern und weiterentwickeln und gleichzeitig sicherstellen, dass die erstellten Daten kontinuierlich anhand eines registrierten Schemas validiert werden. Ein Schema definiert die Struktur und das Format eines Datensatzes. Ein Schema ist eine versionierte Spezifikation für zuverlässige Datenveröffentlichung, -nutzung oder -speicherung. Mit der AWS Glue Schema Registry können Sie die end-to-end Datenqualität und die Datenverwaltung in Ihren Streaming-Anwendungen verbessern. Weitere Informationen finden Sie unter [AWS Glue Schema Registry](https://docs.aws.amazon.com/glue/latest/dg/schema-registry.html). Eine Möglichkeit, diese Integration einzurichten, sind die `PutRecords` im AWS Java-SDK APIs verfügbaren `PutRecord` Kinesis Data Streams.
Detaillierte Anweisungen zur Einrichtung der Integration von Kinesis Data Streams mit der Schemaregistry mithilfe von PutRecords und PutRecord Kinesis Data Streams APIs finden Sie im Abschnitt „Interaktion mit Daten mithilfe der Kinesis Data Streams APIs“ unter [Anwendungsfall: Integration von Amazon Kinesis Data Streams mit der AWS](https://docs.aws.amazon.com/glue/latest/dg/schema-registry-integrations.html#schema-registry-integrations-kds) Glue Schema Registry.
# Schreiben Sie mit Kinesis Agent in Amazon Kinesis Data Streams
Kinesis Agent ist eine eigenständige Java-Anwendung, mit der Sie Daten einfach erfassen und an Kinesis Data Streams senden können. Der Agent überwacht kontinuierlich eine Reihe von Dateien und sendet neue Daten an Ihren Stream. Der Agent übernimmt die Dateirotation, das Checkpointing und die Wiederholung bei Fehlern. Er sorgt für eine zuverlässige, zeitgerechte und einfache Bereitstellung Ihrer Daten. Außerdem werden CloudWatch Amazon-Metriken ausgegeben, damit Sie den Streaming-Prozess besser überwachen und Fehler beheben können.
Standardmäßig werden Datensätze aus den einzelnen Dateien anhand des Zeilenumbruchzeichens (`'\n'`) analysiert. Der Agent kann jedoch auch für die Analyse mehrzeiliger Datensätze konfiguriert werden (siehe [Geben Sie die Einstellungen für die Agentenkonfiguration an](#agent-config-settings)).
Sie können den Agenten in Linux-Serverumgebungen installieren, beispielsweise auf Webservern, Protokollservern und Datenbankservern. Nach der Installation des Agenten konfigurieren Sie diesen, indem Sie die zu überwachenden Dateien sowie den Stream für die Daten angeben. Nachdem der Agent konfiguriert wurde, sammelt er permanent Daten aus den Dateien und sendet sie zuverlässig an den Stream.
**Topics**
+ [Erfüllen Sie die Voraussetzungen für Kinesis Agent](#prereqs)
+ [Herunterladen und Installieren des Agenten](#download-install)
+ [Konfigurieren und starten Sie den Agenten](#config-start)
+ [Geben Sie die Einstellungen für die Agentenkonfiguration an](#agent-config-settings)
+ [Überwachen Sie mehrere Dateiverzeichnisse und schreiben Sie in mehrere Streams](#sim-writes)
+ [Verwenden Sie den Agenten zur Vorverarbeitung von Daten](#pre-processing)
+ [Verwenden Sie CLI-Befehle für Agenten](#cli-commands)
+ [Häufig gestellte Fragen](#agent-faq)
## Erfüllen Sie die Voraussetzungen für Kinesis Agent
+ Sie benötigen entweder ein Amazon Linux AMI-Betriebssystem, Version 2015.09 oder höher, oder Version 7 oder höher von Red Hat Enterprise Linux.
+ Starten Sie Ihre EC2 Instance, wenn Sie Amazon EC2 verwenden, um den Agenten auszuführen.
+ Verwalten Sie Ihre AWS Anmeldeinformationen mit einer der folgenden Methoden:
+ Geben Sie eine IAM-Rolle an, wenn Sie Ihre EC2 Instance starten.
+ Geben Sie die AWS Anmeldeinformationen an, wenn Sie den Agenten konfigurieren (siehe [awsAccessKeyID](#awsAccessKeyId) und [awsSecretAccessSchlüssel](#awsSecretAccessKey)).
+ Bearbeiten Sie`/etc/sysconfig/aws-kinesis-agent`, um Ihre Region und Ihre AWS Zugriffsschlüssel anzugeben.
+ [Wenn sich Ihre EC2-Instance in einem anderen AWS Konto befindet, erstellen Sie eine IAM-Rolle, um Zugriff auf den Kinesis Data Streams Streams-Dienst zu gewähren, und geben Sie diese Rolle bei der Konfiguration des Agenten an (siehe [assumeRoleARN und Id).](#assumeRoleARN) assumeRoleExternal](#assumeRoleExternalId) Verwenden Sie eine der vorherigen Methoden, um die AWS Anmeldeinformationen eines Benutzers im anderen Konto anzugeben, der berechtigt ist, diese Rolle anzunehmen.
+ Die von Ihnen angegebene IAM-Rolle oder die AWS Anmeldeinformationen müssen berechtigt sein, den Kinesis Data Streams [PutRecords](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_PutRecords.html)Streams-Vorgang auszuführen, damit der Agent Daten an Ihren Stream senden kann. Wenn Sie die CloudWatch Überwachung für den Agenten aktivieren, ist auch eine Genehmigung zur Durchführung des CloudWatch [PutMetricData](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_PutMetricData.html)Vorgangs erforderlich. Weitere Informationen finden Sie unter [Steuern des Zugriffs auf Amazon Kinesis Data Streams Streams-Ressourcen mithilfe von IAM](controlling-access.md)[Überwachen Sie den Zustand des Kinesis Data Streams Streams-Agenten mit Amazon CloudWatch](agent-health.md), und [CloudWatch Zugriffskontrolle](https://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/UsingIAM.html).
## Herunterladen und Installieren des Agenten
Stellen Sie zunächst eine Verbindung mit Ihrer Instance her. Weitere Informationen finden Sie unter [Connect to Your Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-connect-to-instance-linux.html) im *Amazon EC2 EC2-Benutzerhandbuch*. Wenn Sie Probleme mit der Verbindung haben, finden Sie weitere Informationen unter [Problembehandlung beim Herstellen einer Verbindung zu Ihrer Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/TroubleshootingInstancesConnecting.html) im *Amazon EC2 EC2-Benutzerhandbuch*.
**So richten Sie den Agenten mithilfe der Amazon Linux AMI ein**
Verwenden Sie den folgenden Befehl zum Herunterladen und Installieren des Agenten:
```
sudo yum install –y aws-kinesis-agent
```
**So richten Sie den Agenten mit Red Hat Enterprise Linux ein**
Verwenden Sie den folgenden Befehl zum Herunterladen und Installieren des Agenten:
```
sudo yum install –y https://s3.amazonaws.com/streaming-data-agent/aws-kinesis-agent-latest.amzn2.noarch.rpm
```
**Um den Agenten einzurichten mit GitHub**
1. Laden Sie den Agenten von [amazon-kinesis-agentawlabs/](https://github.com/awslabs/amazon-kinesis-agent) herunter.
1. Installieren Sie den Agenten, indem Sie zum Download-Verzeichnis navigieren und den folgenden Befehl ausführen:
```
sudo ./setup --install
```
**So richten Sie den Agenten in einem Docker-Container ein**
Kinesis Agent kann auch in einem Container über die [amazonlinux](https://docs.aws.amazon.com/AmazonECR/latest/userguide/amazon_linux_container_image.html)-Containerbasis ausgeführt werden. Verwenden Sie die folgende Docker-Datei und führen Sie dann `docker build` aus.
```
FROM amazonlinux
RUN yum install -y aws-kinesis-agent which findutils
COPY agent.json /etc/aws-kinesis/agent.json
CMD ["start-aws-kinesis-agent"]
```
## Konfigurieren und starten Sie den Agenten
**So konfigurieren und starten Sie den Agenten**
1. Öffnen und bearbeiten Sie die Konfigurationsdatei (als Superuser, wenn Sie standardmäßige Dateizugriffsberechtigungen nutzen): `/etc/aws-kinesis/agent.json`
Geben Sie in der Konfigurationsdatei die Dateien (`"filePattern"`) an, aus denen der Agent Daten sammelt, sowie den Namen des Streams (`"kinesisStream"`, an den der Agent die Daten sendet. Beachten Sie, dass der Dateiname ein Muster ist und der Agent Dateirotationen erkennt. Sie können nur einmal pro Sekunde Dateien rotieren oder neue Dateien erstellen. Der Agent verwendet den Zeitstempel der Dateierstellung, um die Dateien zu ermitteln, die gesammelt und zum Stream hinzugefügt werden. Wenn häufiger als einmal pro Sekunde Dateien rotiert oder neue Dateien erstellt werden, kann der Agent nicht mehr ordnungsgemäß zwischen den Dateien unterscheiden.
```
{
"flows": [
{
"filePattern": "/tmp/app.log*",
"kinesisStream": "yourkinesisstream"
}
]
}
```
1. Starten Sie den Agenten manuell:
```
sudo service aws-kinesis-agent start
```
1. (Optional) Konfigurieren Sie den Agenten so, dass er beim Startup des Systems gestartet wird:
```
sudo chkconfig aws-kinesis-agent on
```
Der Agent wird jetzt als Systemdienst im Hintergrund ausgeführt. Er überwacht kontinuierlich die angegebenen Dateien und sendet Daten an den angegebenen Stream. Die Agentenaktivität wird in `/var/log/aws-kinesis-agent/aws-kinesis-agent.log` protokolliert.
## Geben Sie die Einstellungen für die Agentenkonfiguration an
Der Agent unterstützt die beiden obligatorischen Konfigurationseinstellungen `filePattern` und `kinesisStream` sowie optionale Konfigurationseinstellungen für zusätzliche Funktionen. Sie können sowohl die obligatorische als auch die optionale Konfiguration in `/etc/aws-kinesis/agent.json` angeben.
Wenn Sie die Konfigurationsdatei ändern, müssen Sie den Agenten mit den folgenden Befehlen anhalten und starten:
```
sudo service aws-kinesis-agent stop
sudo service aws-kinesis-agent start
```
Alternativ können Sie auch den folgenden Befehl nutzen:
```
sudo service aws-kinesis-agent restart
```
Im Folgenden finden Sie die allgemeinen Konfigurationseinstellungen.
| Konfigurationseinstellung | Description |
| --- | --- |
| assumeRoleARN | Der ARN der Rolle, die vom Benutzer übernommen werden muss. Weitere Informationen finden Sie unter [AWS Kontenübergreifendes Delegieren des Zugriffs mithilfe von IAM-Rollen](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_cross-account-with-roles.html) im *IAM-Benutzerhandbuch*. |
| assumeRoleExternalId | Eine optionale Kennung, die festlegt, wer die Rolle übernehmen kann. Weitere Informationen finden Sie unter [Verwendung einer externen ID](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html) im *IAM-Benutzerhandbuch*. |
| awsAccessKeyId | AWS Zugriffsschlüssel-ID, die die Standardanmeldedaten überschreibt. Diese Einstellung hat Vorrang vor allen anderen Anbietern von Anmeldeinformationen. |
| awsSecretAccessKey | AWS geheimer Schlüssel, der die Standardanmeldedaten überschreibt. Diese Einstellung hat Vorrang vor allen anderen Anbietern von Anmeldeinformationen. |
| cloudwatch.emitMetrics | Ermöglicht dem Agenten, Metriken auszusenden, CloudWatch sofern diese Einstellung gesetzt ist (true). Standard: true |
| cloudwatch.endpoint | Der regionale Endpunkt für CloudWatch. Standard: `monitoring.us-east-1.amazonaws.com` |
| kinesis.endpoint | Der regionale Endpunkt für Kinesis Data Streams. Standard: `kinesis.us-east-1.amazonaws.com` |
Im Folgenden finden Sie die Konfigurationseinstellungen für den Ablauf.
| Konfigurationseinstellung | Description |
| --- | --- |
| dataProcessingOptions | Die Liste der Verarbeitungsoptionen, die auf jeden analysierten Datensatz angewendet werden, ehe ein Datensatz an den Stream gesendet wird. Die Verarbeitungsoptionen werden in der angegebenen Reihenfolge ausgeführt. Weitere Informationen finden Sie unter [Verwenden Sie den Agenten zur Vorverarbeitung von Daten](#pre-processing). |
| kinesisStream | [Erforderlich] Der Name des Streams. |
| filePattern | [Erforderlich] Das Verzeichnis- und Dateimuster, das abgeglichen werden muss, damit es vom Agenten abgerufen werden kann. Für alle Dateien, die mit diesem Muster übereinstimmen, müssen Leseberechtigungen für `aws-kinesis-agent-user` vergeben werden. Für das die Dateien enthaltende Verzeichnis müssen Lese- und Ausführberechtigungen für `aws-kinesis-agent-user` vergeben werden. |
| initialPosition | Die Position, an der mit der Analyse der Datei begonnen wurde. Gültige Werte sind `START_OF_FILE` und `END_OF_FILE`. Standard: `END_OF_FILE` |
| maxBufferAgeMillis | Die maximale Zeit (in Millisekunden), während der durch den Agenten Daten gepuffert werden, bevor sie an den Stream gesendet werden. Wertebereich: 1.000 bis 900.000 (1 Sekunde bis 15 Minuten) Standard: 60.000 (1 Minute) |
| maxBufferSizeBytes | Die maximale Größe (in Bytes), bis zu der durch den Agenten Daten gepuffert werden, bevor sie an den Stream gesendet werden. Wertebereich: 1 bis 4.194.304 (4 MB) Standard: 4.194.304 (4 MB) |
| maxBufferSizeRecords | Die maximale Anzahl der Datensätze, für die der Agent Daten puffert, ehe diese an den Stream gesendet werden. Wertebereich: 1 bis 500 Standard: 500 |
| minTimeBetweenFilePollsMillis | Das Zeitintervall (in Millisekunden), in dem der Agent die überwachten Dateien auf neue Daten abfragt und analysiert. Wertbereich: 1 oder höher Standard: 100 |
| multiLineStartPattern | Das Muster für die Identifizierung des Datensatzbeginns. Ein Datensatz besteht aus einer Zeile, die mit dem angegebenen Muster übereinstimmt, und allen folgenden Zeilen, die nicht dem Muster entsprechen. Gültige Werte sind reguläre Ausdrücke. Standardmäßig wird jede neue Zeile in den Protokolldateien als einziger Datensatz analysiert. |
| partitionKeyOption | Die Methode zum Erstellen des Partitionsschlüssels. Gültige Werte sind `RANDOM` (zufällig generierte Ganzzahl) und `DETERMINISTIC` (ein aus den Daten berechneter Hash-Wert). Standard: `RANDOM` |
| skipHeaderLines | Die Anzahl der Zeilen, die der Agent überspringt, ehe mit der Analyse der überwachten Dateien begonnen wird. Wertbereich: 0 oder höher Standard: 0 (null) |
| truncatedRecordTerminator | Die Zeichenfolge, mit der der Agent einen analysierten Datensatz kürzt, wenn die Datensatzgröße das zulässige Datensatz-Limit von Kinesis Data Streams überschreitet. (1,000 KB) Standard: `'\n'` (Zeilenumbruch) |
## Überwachen Sie mehrere Dateiverzeichnisse und schreiben Sie in mehrere Streams
Wenn Sie mehrere Ablaufkonfigurationseinstellungen angeben, können Sie den Agenten so konfigurieren, dass er mehrere Dateiverzeichnisse überwacht und Daten an verschiedene Streams sendet. Im folgenden Konfigurationsbeispiel überwacht der Agent zwei Dateiverzeichnisse und sendet Daten an einen Kinesis-Stream bzw. einen Firehose-Lieferstream. Beachten Sie, dass Sie unterschiedliche Endpunkte für Kinesis Data Streams und Firehose angeben können, sodass sich Ihr Kinesis-Stream und Ihr Firehose-Lieferstream nicht in derselben Region befinden müssen.
```
{
"cloudwatch.emitMetrics": true,
"kinesis.endpoint": "https://your/kinesis/endpoint",
"firehose.endpoint": "https://your/firehose/endpoint",
"flows": [
{
"filePattern": "/tmp/app1.log*",
"kinesisStream": "yourkinesisstream"
},
{
"filePattern": "/tmp/app2.log*",
"deliveryStream": "yourfirehosedeliverystream"
}
]
}
```
Ausführlichere Informationen zur Verwendung des Agenten mit Firehose finden Sie unter [Writing to Amazon Data Firehose with Kinesis](https://docs.aws.amazon.com/firehose/latest/dev/writing-with-agents.html) Agent.
## Verwenden Sie den Agenten zur Vorverarbeitung von Daten
Der Agent kann die Datensätze vorverarbeiten, die aus den überwachten Dateien analysiert wurden, ehe diese an Ihren Stream gesendet werden. Sie können dieses Feature aktivieren, indem Sie Ihrem Dateifluss die Konfigurationseinstellung `dataProcessingOptions` hinzufügen. Sie können eine oder mehrere Verarbeitungsoptionen hinzufügen. Diese werden in der angegebenen Reihenfolge ausgeführt.
Der Agent unterstützt die folgenden aufgelisteten Verarbeitungsoptionen. Der Agent ist ein Open-Source-Tool, sodass Sie dessen Verarbeitungsoptionen optimieren und erweitern können. Sie können den Agenten von [Kinesis Agent](https://github.com/awslabs/amazon-kinesis-agent) herunterladen.Verarbeitungsoptionen
`SINGLELINE`
Konvertiert einen mehrzeiligen Datensatz in einen einzeiligen Datensatz, indem Zeilenumbruchzeichen sowie vorangestellte und folgende Leerzeichen entfernt werden.
```
{
"optionName": "SINGLELINE"
}
```
`CSVTOJSON`
Konvertiert einen Datensatz aus dem durch Trennzeichen getrennten Format in einen Datensatz im JSON-Format.
```
{
"optionName": "CSVTOJSON",
"customFieldNames": [ "field1", "field2", ... ],
"delimiter": "yourdelimiter"
}
```
`customFieldNames`
[Erforderlich] Die Feldnamen, die als Schlüssel in den einzelnen JSON-Schlüssel-Wert-Paaren verwendet werden. Wenn Sie beispielsweise `["f1", "f2"]` angeben, wird der Datensatz „v1, v2“ in `{"f1":"v1","f2":"v2"}` konvertiert.
`delimiter`
Die Zeichenfolge, die als Trennzeichen im Datensatz verwendet wird. Standardmäßig wird ein Komma (,) verwendet.
`LOGTOJSON`
Konvertiert einen Datensatz aus einem Protokollformat in einen Datensatz im JSON-Format. Folgende Protokollformate werden unterstützt: **Apache Common Log**, **Apache Combined Log**, **Apache Error Log** und **RFC3164 Syslog**.
```
{
"optionName": "LOGTOJSON",
"logFormat": "logformat",
"matchPattern": "yourregexpattern",
"customFieldNames": [ "field1", "field2", … ]
}
```
`logFormat`
[Erforderlich] Das Format des Protokolleintrags. Folgende Werte sind möglich:
+ `COMMONAPACHELOG` – Das Apache-Common-Log-Format. Jeder Protokolleintrag weist standardmäßig das folgende Muster auf: „`%{host} %{ident} %{authuser} [%{datetime}] \"%{request}\" %{response} %{bytes}`“.
+ `COMBINEDAPACHELOG` – Das Apache-Combined-Log-Format. Jeder Protokolleintrag weist standardmäßig das folgende Muster auf: „`%{host} %{ident} %{authuser} [%{datetime}] \"%{request}\" %{response} %{bytes} %{referrer} %{agent}`“.
+ `APACHEERRORLOG` – Das Apache-Error-Log-Format. Jeder Protokolleintrag weist standardmäßig das folgende Muster auf: „`[%{timestamp}] [%{module}:%{severity}] [pid %{processid}:tid %{threadid}] [client: %{client}] %{message}`“.
+ `SYSLOG`— Das RFC3164 Syslog-Format. Jeder Protokolleintrag weist standardmäßig das folgende Muster auf: „`%{timestamp} %{hostname} %{program}[%{processid}]: %{message}`“.
`matchPattern`
Das reguläre Ausdrucksmuster, mit dem Werte aus den Protokolleinträgen extrahiert werden. Diese Einstellung wird verwendet, wenn Ihr Protokolleintrag nicht eines der vordefinierten Protokollformate aufweist. Bei dieser Einstellung müssen Sie auch `customFieldNames` angeben.
`customFieldNames`
Die benutzerdefinierten Feldnamen, die als Schlüssel in den einzelnen JSON-Schlüssel-Wert-Paaren verwendet werden. Mit dieser Einstellung können Sie Feldnamen für Werte definieren, die aus `matchPattern` extrahiert wurden, oder die Standardfeldnamen von vordefinierten Protokollformaten überschreiben.
**Example : LOGTOJSON-Konfiguration**
Nachfolgend ein Beispiel einer `LOGTOJSON`-Konfiguration für einen Apache Common Log-Eintrag, der in ein JSON-Format konvertiert wurde:
```
{
"optionName": "LOGTOJSON",
"logFormat": "COMMONAPACHELOG"
}
```
Vor der Konvertierung:
```
64.242.88.10 - - [07/Mar/2004:16:10:02 -0800] "GET /mailman/listinfo/hsdivision HTTP/1.1" 200 6291
```
Nach der Konvertierung:
```
{"host":"64.242.88.10","ident":null,"authuser":null,"datetime":"07/Mar/2004:16:10:02 -0800","request":"GET /mailman/listinfo/hsdivision HTTP/1.1","response":"200","bytes":"6291"}
```
**Example : LOGTOJSON-Konfiguration mit benutzerdefinierten Feldern**
Im Folgenden ein weiteres Beispiel einer `LOGTOJSON`-Konfiguration:
```
{
"optionName": "LOGTOJSON",
"logFormat": "COMMONAPACHELOG",
"customFieldNames": ["f1", "f2", "f3", "f4", "f5", "f6", "f7"]
}
```
Durch diese Konfigurationseinstellung wird der Apache Common Log-Eintrag aus dem vorherigen Beispiel wie folgt in ein JSON-Format konvertiert:
```
{"f1":"64.242.88.10","f2":null,"f3":null,"f4":"07/Mar/2004:16:10:02 -0800","f5":"GET /mailman/listinfo/hsdivision HTTP/1.1","f6":"200","f7":"6291"}
```
**Example : Konvertieren eines Apache Common Log-Eintrags**
Bei der folgenden Ablaufkonfiguration wird ein Apache Common Log-Eintrag in einen einzeiligen Datensatz im JSON-Format umgewandelt:
```
{
"flows": [
{
"filePattern": "/tmp/app.log*",
"kinesisStream": "my-stream",
"dataProcessingOptions": [
{
"optionName": "LOGTOJSON",
"logFormat": "COMMONAPACHELOG"
}
]
}
]
}
```
**Example : Konvertieren mehrzeiliger Datensätze**
Bei der folgenden Ablaufkonfiguration werden mehrzeilige Datensätze analysiert, deren erste Zeile mit „`[SEQUENCE=`“ beginnt. Jeder Datensatz wird in einen einzeiligen Datensatz konvertiert. Anschließend werden Werte aus dem Datensatz basierend auf einem Tabulatortrennzeichen extrahiert. Die extrahierten Werte werden zu angegebenen `customFieldNames`-Werten zugeordnet und ergeben so einen einzeiligen Datensatz im JSON-Format.
```
{
"flows": [
{
"filePattern": "/tmp/app.log*",
"kinesisStream": "my-stream",
"multiLineStartPattern": "\\[SEQUENCE=",
"dataProcessingOptions": [
{
"optionName": "SINGLELINE"
},
{
"optionName": "CSVTOJSON",
"customFieldNames": [ "field1", "field2", "field3" ],
"delimiter": "\\t"
}
]
}
]
}
```
**Example : LOGTOJSON-Konfiguration mit Übereinstimmungsmuster**
Nachfolgend ein Beispiel einer `LOGTOJSON`-Konfiguration für einen Apache Common Log-Eintrag, der in das JSON-Format konvertiert wurde. Das letzte Feld (Bytes) wurde ausgelassen:
```
{
"optionName": "LOGTOJSON",
"logFormat": "COMMONAPACHELOG",
"matchPattern": "^([\\d.]+) (\\S+) (\\S+) \\[([\\w:/]+\\s[+\\-]\\d{4})\\] \"(.+?)\" (\\d{3})",
"customFieldNames": ["host", "ident", "authuser", "datetime", "request", "response"]
}
```
Vor der Konvertierung:
```
123.45.67.89 - - [27/Oct/2000:09:27:09 -0400] "GET /java/javaResources.html HTTP/1.0" 200
```
Nach der Konvertierung:
```
{"host":"123.45.67.89","ident":null,"authuser":null,"datetime":"27/Oct/2000:09:27:09 -0400","request":"GET /java/javaResources.html HTTP/1.0","response":"200"}
```
## Verwenden Sie CLI-Befehle für Agenten
Automatisches Startup des Agenten beim Systemstart:
```
sudo chkconfig aws-kinesis-agent on
```
Prüfen des Status des Agenten:
```
sudo service aws-kinesis-agent status
```
Beenden des Agenten:
```
sudo service aws-kinesis-agent stop
```
Auslesen der Protokolldatei des Agenten von diesem Speicherort:
```
/var/log/aws-kinesis-agent/aws-kinesis-agent.log
```
Deinstallieren des Agenten:
```
sudo yum remove aws-kinesis-agent
```
## Häufig gestellte Fragen
### Gibt es einen Kinesis Agent für Windows?
[Kinesis Agent für Windows](https://docs.aws.amazon.com/kinesis-agent-windows/latest/userguide/what-is-kinesis-agent-windows.html) ist eine andere Software als Kinesis Agent für Linux-Plattformen.
### Warum wird Kinesis Agent langsamer and/or `RecordSendErrors` und stärker?
Dies ist normalerweise auf die Drosselung durch Kinesis zurückzuführen. Überprüfen Sie die `WriteProvisionedThroughputExceeded` Metrik für Kinesis Data Streams oder die `ThrottledRecords` Metrik für Firehose Delivery Streams. Jede Erhöhung dieser Metriken von 0 zeigt an, dass die Stream-Grenzwerte erhöht werden müssen. Weitere Informationen finden Sie unter [Kinesis-Datenstrom-Grenzwerte](https://docs.aws.amazon.com/streams/latest/dev/service-sizes-and-limits.html) und [Amazon Firehose Delivery Streams](https://docs.aws.amazon.com/firehose/latest/dev/limits.html).
Sobald Sie die Drosselung ausgeschlossen haben, überprüfen Sie, ob der Kinesis Agent so konfiguriert ist, dass er eine große Menge kleiner Dateien durchsucht. Es gibt eine Verzögerung, wenn der Kinesis Agent eine neue Datei überwacht, daher sollte der Kinesis-Agent eine kleine Menge größerer Dateien überwachen. Versuchen Sie, Ihre Protokolldateien in größeren Dateien zusammenzufassen.
### Warum erhalte ich `java.lang.OutOfMemoryError`-Ausnahmen?
Kinesis Agent verfügt nicht über genügend Arbeitsspeicher, um seinen aktuellen Workload zu bewältigen. Versuchen Sie, `JAVA_START_HEAP` und `JAVA_MAX_HEAP` in `/usr/bin/start-aws-kinesis-agent` zu erhöhen und den Agenten neu zu starten.
### Warum erhalte ich `IllegalStateException : connection pool shut down`-Ausnahmen?
Kinesis Agent verfügt nicht über genügend Verbindungen, um seinen aktuellen Workload zu bewältigen. Versuchen Sie, `maxConnections` und `maxSendingThreads` in den allgemeinen Konfigurationseinstellungen des Agenten unter `/etc/aws-kinesis/agent.json` zu erhöhen. Der Standardwert für diese Felder ist das 12-fache der verfügbaren Laufzeitprozessoren. Weitere Informationen zu den Einstellungen für erweiterte Agentenkonfigurationen finden Sie unter [AgentConfiguration.java](https://github.com/awslabs/amazon-kinesis-agent/blob/master/src/com/amazon/kinesis/streaming/agent/config/AgentConfiguration.java).
### Wie kann ich ein anderes Problem mit Kinesis Agent beheben?
`DEBUG`-Level-Protokolle können in `/etc/aws-kinesis/log4j.xml` aktiviert werden.
### Wie sollte ich Kinesis Agent konfigurieren?
Je kleiner das `maxBufferSizeBytes`, desto häufiger sendet der Kinesis Agent Daten. Dies kann nützlich sein, da es die Lieferzeit von Datensätzen verkürzt, aber es erhöht auch die Anfragen pro Sekunde an Kinesis.
### Warum sendet Kinesis Agent doppelte Datensätze?
Dies ist auf eine Fehlkonfiguration bei der Dateiüberwachung zurückzuführen. Stellen Sie sicher, dass jedes `fileFlow’s filePattern` nur einer Datei entspricht. Dies kann auch auftreten, wenn der verwendete `logrotate`-Modus im `copytruncate`-Modus ist. Versuchen Sie, den Modus auf den Standard- oder Erstellungsmodus zu ändern, um Duplikate zu vermeiden. Weitere Informationen zum Umgang mit doppelten Datensätzen finden Sie unter [Umgang mit doppelten Datensätzen](https://docs.aws.amazon.com/streams/latest/dev/kinesis-record-processor-duplicates.html).
# Schreiben Sie mithilfe anderer AWS Dienste in Kinesis Data Streams
Die folgenden AWS Services können direkt in Amazon Kinesis Data Streams integriert werden, um Daten in Kinesis-Datenstreams zu schreiben. Überprüfen Sie die Informationen für jeden Service, an dem Sie interessiert sind, und verweisen Sie auf die bereitgestellten Referenzen.
**Topics**
+ [Schreiben Sie in Kinesis Data Streams mit AWS Amplify](using-other-services-amplify.md)
+ [Schreiben Sie mit Amazon Aurora in Kinesis Data Streams](using-other-services-aurora.md)
+ [Schreiben Sie mit Amazon in Kinesis Data Streams CloudFront](using-other-services-CloudFront.md)
+ [Schreiben Sie mithilfe von Amazon CloudWatch Logs in Kinesis Data Streams](using-other-services-cw-logs.md)
+ [Schreiben Sie mit Amazon Connect in Kinesis Data Streams](using-other-services-connect.md)
+ [Schreiben Sie in Kinesis Data Streams mit AWS Database Migration Service](using-other-services-migration.md)
+ [Schreiben Sie mit Amazon DynamoDB in Kinesis Data Streams](using-other-services-ddb.md)
+ [Schreiben Sie mit Amazon in Kinesis Data Streams EventBridge](using-other-services-eventbridges.md)
+ [Schreiben Sie in Kinesis Data Streams mit AWS IoT Core](using-other-services-iot-core.md)
+ [Schreiben Sie mit Amazon Relational Database Service in Kinesis Data Streams](using-other-services-rds.md)
+ [Schreiben Sie mit Amazon Pinpoint in Kinesis Data Streams](using-other-services-pinpoint.md)
+ [Schreiben Sie mithilfe der Amazon Quantum Ledger Database (Amazon QLDB) in Kinesis Data Streams](using-other-services-quantum-ledger.md)
# Schreiben Sie in Kinesis Data Streams mit AWS Amplify
Sie können Amazon Kinesis Data Streams verwenden, um Daten aus Ihren mit AWS Amplify erstellten mobilen Anwendungen für die Echtzeitverarbeitung zu streamen. Sie können dann Echtzeit-Dashboards erstellen, Ausnahmen erfassen, Warnungen generieren, Empfehlungen erzeugen und in Echtzeit andere geschäftliche oder betriebliche Entscheidungen treffen. Sie können Daten auch an andere Dienste wie Amazon Simple Storage Service, Amazon DynamoDB und Amazon Redshift senden.
Weitere Informationen finden Sie unter [Verwenden von Amazon Kinesis](https://docs.amplify.aws/react/build-a-backend/more-features/analytics/streaming-data/) im *AWS Amplify Developer Center*.
# Schreiben Sie mit Amazon Aurora in Kinesis Data Streams
Sie können Amazon Kinesis Data Streams verwenden, um Aktivitäten auf Ihren Amazon Aurora-DB-Clustern zu überwachen. Mithilfe von Database Activity Streams überträgt Ihr Aurora-DB-Cluster Aktivitäten in Echtzeit an einen Amazon Kinesis Data Streams. Anschließend können Sie Anwendungen für das Compliance-Management entwickeln, die diese Aktivitäten nutzen, prüfen und Warnmeldungen generieren. Sie können auch Amazon Firehose verwenden, um die Daten zu speichern.
Weitere Informationen finden Sie unter [Datenbankaktivitätsstreams](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/DBActivityStreams.html) im *Entwicklerhandbuch zu Amazon Aurora*.
# Schreiben Sie mit Amazon in Kinesis Data Streams CloudFront
Sie können Amazon Kinesis Data Streams mit CloudFront Echtzeitprotokollen verwenden und Informationen über Anfragen an eine Distribution in Echtzeit abrufen. Sie können dann Ihren eigenen [Kinesis Data Stream Consumer](https://docs.aws.amazon.com/streams/latest/dev/building-consumers.html) erstellen oder Amazon Data Firehose verwenden, um die Protokolldaten an Amazon S3, Amazon Redshift, Amazon OpenSearch Service oder einen Protokollverarbeitungsservice eines Drittanbieters zu senden.
Weitere Informationen finden Sie unter [Echtzeitprotokolle](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/real-time-logs.html) im *Amazon CloudFront Developer Guide*.
# Schreiben Sie mithilfe von Amazon CloudWatch Logs in Kinesis Data Streams
Sie können CloudWatch Abonnements verwenden, um Zugriff auf einen Echtzeit-Feed mit Protokollereignissen von Amazon CloudWatch Logs zu erhalten und diesen zur Verarbeitung, Analyse und zum Laden in andere Systeme an einen Kinesis-Datenstream senden zu lassen.
Weitere Informationen finden Sie unter [Echtzeitverarbeitung von Protokolldaten mit Abonnements](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Subscriptions.html) im *Amazon CloudWatch Logs-Benutzerhandbuch*.
# Schreiben Sie mit Amazon Connect in Kinesis Data Streams
Sie können Kinesis Data Streams verwenden, um Kontaktdatensätze und Agentenereignisse in Echtzeit aus Ihrer Amazon-Connect-Instance zu exportieren. Sie können auch Datenstreaming von Amazon Connect Connect-Kundenprofilen aktivieren, um automatisch Updates für einen Kinesis-Datenstream über die Erstellung neuer Profile oder Änderungen an bestehenden Profilen zu erhalten.
Anschließend können Sie Verbraucheranwendungen erstellen, um die Daten in Echtzeit zu verarbeiten und zu analysieren. Mithilfe von Kontaktdatensätzen und Kundenprofildaten können Sie beispielsweise Ihre Quellsystemdaten, wie CRMs z. B. Marketingautomatisierungstools, auf up-to-date dem neuesten Stand halten. Mithilfe der Ereignisdaten der Agenten können Sie Dashboards erstellen, die Agenteninformationen und Ereignisse anzeigen und benutzerdefinierte Benachrichtigungen über bestimmte Agentenaktivitäten auslösen.
Weitere Informationen finden Sie unter [Datenstreaming für Ihre Instance](https://docs.aws.amazon.com/connect/latest/adminguide/data-streaming.html), [Echtzeit-Export einrichten](https://docs.aws.amazon.com/connect/latest/adminguide/set-up-real-time-export.html) und [Agenten-Event-Streams](https://docs.aws.amazon.com/connect/latest/adminguide/agent-event-streams.html) im *Amazon-Connect-Administratorhandbuch*.
# Schreiben Sie in Kinesis Data Streams mit AWS Database Migration Service
Sie können AWS Database Migration Service es verwenden, um Daten in einen Kinesis-Datenstream zu migrieren. Anschließend können Sie Verbraucheranwendungen erstellen, die die Datensätze in Echtzeit verarbeiten. Sie können Daten auch problemlos nachgelagert an andere Services wie Amazon Simple Storage Service, Amazon DynamoDB und Amazon Redshift senden
Weitere Informationen finden Sie unter [Nutzung von Kinesis Data Streams](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Target.Kinesis.html) im *Benutzerhandbuch für AWS Database Migration Service *.
# Schreiben Sie mit Amazon DynamoDB in Kinesis Data Streams
Sie können Amazon Kinesis Data Streams verwenden, um Änderungen an Amazon DynamoDB zu erfassen. Kinesis Data Streams erfasst Änderungen auf Elementebene in jeder DynamoDB-Tabelle und repliziert sie in einen Kinesis Data Stream. Ihre Verbraucheranwendungen können auf diesen Stream zugreifen, um Änderungen auf Artikelebene in Echtzeit anzuzeigen und diese Änderungen anschließend weiterzuleiten oder auf der Grundlage des Inhalts Maßnahmen zu ergreifen.
Weitere Informationen finden Sie unter [wie Kinesis Data Streams mit DynamoDB funktionieren](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/kds.html) im *Amazon-DynamoDB-Entwicklerhandbuch*.
# Schreiben Sie mit Amazon in Kinesis Data Streams EventBridge
Mit Kinesis Data Streams können Sie AWS [API-Aufrufereignisse](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-events.html) EventBridge an einen Stream senden, Verbraucheranwendungen erstellen und große Datenmengen verarbeiten. Sie können Kinesis Data Streams auch als Ziel in EventBridge Pipes verwenden und Datensätze nach optionaler Filterung und Anreicherung als Stream aus einer der verfügbaren Quellen bereitstellen.
Weitere Informationen finden [Sie unter Senden von Ereignissen an einen Amazon Kinesis Kinesis-Stream](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-relay-events-kinesis-stream.html) und [EventBridge Pipes](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-pipes.html) im * EventBridge Amazon-Benutzerhandbuch*.
# Schreiben Sie in Kinesis Data Streams mit AWS IoT Core
Mithilfe von IoT-Regelaktionen können Sie Daten in Echtzeit aus MQTT-Nachrichten in AWS AWS IoT Core schreiben. Anschließend können Sie Anwendungen erstellen, die die Daten verarbeiten, ihren Inhalt analysieren und Warnmeldungen generieren und sie an Analyseanwendungen oder andere AWS -Services weiterleiten.
Weitere Informationen finden Sie unter [Kinesis Data Streams](https://docs.aws.amazon.com/iot/latest/developerguide/kinesis-rule-action.html) im *AWS IoT Core-Entwicklerhandbuch*.
# Schreiben Sie mit Amazon Relational Database Service in Kinesis Data Streams
Sie können Amazon Kinesis Data Streams verwenden, um Aktivitäten auf Ihren Amazon-RDS-Instances zu überwachen. Mithilfe von Database Activity Streams überträgt Amazon RDS Aktivitäten in Echtzeit in einen Kinesis-Datenstream. Anschließend können Sie Anwendungen für das Compliance-Management entwickeln, die diese Aktivitäten nutzen, prüfen und Warnmeldungen generieren. Sie können auch Amazon Data Firehose verwenden, um die Daten zu speichern.
Weitere Informationen finden Sie unter [Datenbankaktivitätsstreams](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/DBActivityStreams.html) im *Entwicklerhandbuch zu Amazon RDS*.
# Schreiben Sie mit Amazon Pinpoint in Kinesis Data Streams
Sie können Amazon Pinpoint so einrichten, dass Ereignisdaten an Amazon Kinesis Data Streams gesendet werden. Amazon Pinpoint kann Ereignisdaten für Kampagnen, Reisen und transaktionale E-Mail- und SMS-Nachrichten senden. Sie können die Daten dann in Analyseanwendungen aufnehmen oder Ihre eigenen Verbraucheranwendungen erstellen, die auf der Grundlage des Inhalts der Ereignisse Maßnahmen ergreifen.
Weitere Informationen finden Sie unter [Streaming-Events](https://docs.aws.amazon.com/pinpoint/latest/developerguide/event-streams.html) im *Entwicklerhandbuch zu Amazon Pinpoint*.
# Schreiben Sie mithilfe der Amazon Quantum Ledger Database (Amazon QLDB) in Kinesis Data Streams
Sie können in Amazon QLDB einen Stream erstellen, der jede Dokumentrevision erfasst, die in Ihr Journal übernommen wurde, und diese Daten in Echtzeit an Amazon Kinesis Data Streams übermittelt. Ein QLDB-Stream ist ein kontinuierlicher Datenfluss aus dem Ledger-Journal zu einer Kinesis-Datenstromressource. Anschließend können Sie die Kinesis-Streaming-Plattform oder die Kinesis-Client-Bibliothek verwenden, um Ihren Stream zu nutzen, die Datensätze zu verarbeiten und den Dateninhalt zu analysieren. Ein QLDB-Stream schreibt Ihre Daten in drei Datensatztypen in Kinesis Data Streams: `control`, `block summary` und `revision details`.
Weitere Informationen finden Sie unter [Streams](https://docs.aws.amazon.com/qldb/latest/developerguide/streams.html) im *Amazon-QLDB-Entwicklerhandbuch*.
# Schreiben Sie mithilfe von Integrationen von Drittanbietern in Kinesis Data Streams
Sie können Daten mit einer der folgenden Drittanbieteroptionen, die in Kinesis Data Streams integriert sind, in Kinesis Data Streams schreiben. Wählen Sie die Option aus, über die Sie mehr erfahren möchten, und finden Sie Ressourcen und Links zu relevanter Dokumentation.
**Topics**
+ [Apache Flink](using-other-services-flink.md)
+ [Fluentd](using-other-services-Fluentd.md)
+ [Debezium](using-other-services-Debezium.md)
+ [Orakel GoldenGate](using-other-services-Oracle-GoldenGate.md)
+ [Kafka Connect](using-other-services-kafka-connect.md)
+ [Adobe Experience](using-other-services-adobe.md)
+ [Striim](using-other-services-Striim.md)
# Apache Flink
Apache Flink ist ein Framework und eine verteilte Verarbeitungs-Engine für statusbehaftete Berechnungen über unbegrenzte und begrenzte Datenströme. Weitere Informationen zum Schreiben von Apache Flink in Kinesis Data Streams finden Sie unter [Amazon Kinesis Data Streams Connector](https://nightlies.apache.org/flink/flink-docs-release-1.15/docs/connectors/datastream/kinesis/).
# Fluentd
Fluentd ist ein Open-Source-Datensammler für eine einheitliche Protokollierungsebene. Weitere Informationen zum Schreiben von Fluentd in Kinesis Data Streams. Weitere Informationen finden Sie unter [Stream-Verarbeitung mit Kinesis](https://docs.fluentd.org/how-to-guides/kinesis-stream).
# Debezium
Debezium ist eine verteilte Open-Source-Plattform für die Erfassung von Änderungsdaten. Weitere Informationen zum Schreiben von Debezium in Kinesis Data Streams finden Sie unter [Streaming von MySQL-Datenänderungen zu Amazon Kinesis](https://debezium.io/blog/2018/08/30/streaming-mysql-data-changes-into-kinesis/).
# Orakel GoldenGate
Oracle GoldenGate ist ein Softwareprodukt, mit dem Sie Daten von einer Datenbank in eine andere replizieren, filtern und transformieren können. Weitere Informationen zum Schreiben von Oracle GoldenGate in Kinesis Data Streams finden Sie unter [Datenreplikation nach Kinesis Data Stream mit](https://blogs.oracle.com/dataintegration/post/data-replication-to-aws-kinesis-data-stream-using-oracle-goldengate) Oracle. GoldenGate
# Kafka Connect
Kafka Connect ist ein Tool für skalierbares und zuverlässiges Streamen von Daten zwischen Apache Kafka und anderen Systemen. Weitere Informationen zum Schreiben von Apache Kafka in Kinesis Data Streams finden Sie unter [der Kinesis-Kafka-Konnektor](https://github.com/awslabs/kinesis-kafka-connector).
# Adobe Experience
Die Adobe Experience Platform ermöglicht es Unternehmen, Kundendaten aus jedem System zu zentralisieren und zu standardisieren. Anschließend werden Datenwissenschaft und Machine Learning angewendet, um das Design und die Bereitstellung umfassender, personalisierter Erlebnisse erheblich zu verbessern. Weitere Informationen zum Schreiben von Daten von der Adobe Experience Platform in Kinesis Data Streams finden Sie unter So erstellen Sie eine [Amazon-Kinesis-Verbindung](https://experienceleague.adobe.com/docs/experience-platform/destinations/catalog/cloud-storage/amazon-kinesis.html?lang=en).
# Striim
Striim ist eine vollständige end-to-end In-Memory-Plattform zum Sammeln, Filtern, Transformieren, Anreichern, Aggregieren, Analysieren und Bereitstellen von Daten in Echtzeit. Weitere Informationen zum Schreiben von Daten von Striim in Kinesis Data Streams finden Sie im [Kinesis Writer](https://www.striim.com/docs/en/kinesis-writer.html).
# Problembehandlung Amazon Kinesis Data Streams Streams-Produzenten
**Topics**
+ [Meine Producer-Anwendung schreibt langsamer als erwartet](#producer-writing-at-slower-rate)
+ [Ich erhalte einen unautorisierten KMS-Masterkey-Berechtigungsfehler](#unauthorized-kms-producer)
+ [Beheben Sie andere häufig auftretende Probleme von Herstellern](#misc-troubleshooting-producer)
## Meine Producer-Anwendung schreibt langsamer als erwartet
**Topics**
+ [Die Servicelimits wurden überschritten](#service-limits-exceeded)
+ [Ich möchte meinen Producer optimieren](#producer-optimization)
+ [Missbrauch von `flushSync()` Vorgängen](#misuse-tag)
### Die Servicelimits wurden überschritten
Wenn Sie wissen möchten, ob die Service Limits überschritten werden, prüfen Sie, ob Ihr Datenproduzent Ausnahmen im Service auslöst, und validieren Sie, welche API-Operationen gedrosselt werden. Beachten Sie, dass es je nach Aufruf verschiedene Limits gibt, siehe [Kontingente und -Einschränkungen](service-sizes-and-limits.md). Beispielsweise gelten zusätzlich zu den bekannten Limits für Schreib- und Lesevorgänge auf Shard-Ebene folgenden Limits auf Stream-Ebene:
+ [CreateStream](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_CreateStream.html)
+ [DeleteStream](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_DeleteStream.html)
+ [ListStreams](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_ListStreams.html)
+ [GetShardIterator](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_GetShardIterator.html)
+ [MergeShards](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_MergeShards.html)
+ [DescribeStream](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_DescribeStream.html)
+ [DescribeStreamSummary](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_DescribeStreamSummary.html)
Die Operationen `CreateStream``DeleteStream`, `ListStreams`, `GetShardIterator` und `MergeShards` dürfen maximal 5 mal pro Sekunde aufgerufen werden. Die `DescribeStream`-Operation ist auf 10 Aufrufe pro Sekunde begrenzt. Die `DescribeStreamSummary`-Operation ist auf 20 Aufrufe pro Sekunde begrenzt.
Wenn diese Aufrufe nicht das Problem sind, stellen Sie sicher, dass Sie einen Partitionsschlüssel ausgewählt haben, mit dem Sie die *PUT*-Operationen gleichmäßig auf alle Shards verteilen können, und dass Sie keinen Partitionsschlüssel haben, der die Service Limits ausschöpft, wenn der Rest dies nicht tut. Dazu müssen Sie den Spitzendurchsatz messen und die Anzahl der Shards im Stream berücksichtigen. Weitere Informationen zum Verwalten von Streams finden Sie unter [Kinesis-Datenstreams erstellen und verwalten](working-with-streams.md).
**Tipp**
Bitte beachten, dass Sie bei der Berechnung der Durchsatzdrosselung auf den nächsten Byte aufrunden müssen, wenn Sie die Einzeldatensatz-Operation [PutRecord](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_PutRecord.html) verwenden. Bei der Mehrfachdatensatz-Operation [PutRecords](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_PutRecords.html) wird die kumulative Anzahl der Datensätze in den einzelnen Aufrufen gerundet. Eine `PutRecords`-Anforderung mit 600 Datensätzen und einer Größe von 1,1 KB wird beispielsweise nicht gedrosselt.
### Ich möchte meinen Producer optimieren
Bevor Sie mit der Optimierung Ihres Producers beginnen, müssen Sie die folgenden wichtigen Aufgaben erledigen. Bestimmen Sie zunächst den gewünschten Spitzenwert hinsichtlich Datensatzgröße und Datensätze pro Sekunde. Schließen Sie dann die Stream-Kapazität als Begrenzungsfaktor aus ([Die Servicelimits wurden überschritten](#service-limits-exceeded)). Nutzen Sie die folgenden Tipps zur Fehlerbehebung und Optimierungsanleitungen für die beiden häufigsten Produzententypen, wenn Sie die Stream-Kapazität als Begrenzungsfaktor ausgeschlossen haben.
**Großer Produzent**
Ein großer Produzent wird in der Regel von einem lokalen Server oder einer Amazon-EC2-Instance ausgeführt. Für Kunden, die einen höheren Durchsatz eines großen Produzenten benötigen, ist in der Regel die Latenz pro Datensatz entscheidend. Zu den Strategien für den Umgang mit Latenz gehören die folgenden: Wenn der Kunde Datensätze per Mikro-Batch/Puffer speichern kann, verwendet er die [Amazon Kinesis Producer Library](https://docs.aws.amazon.com/kinesis/latest/dev/developing-producers-with-kpl.html) (die über eine erweiterte Aggregationslogik verfügt), die Operation mit mehreren Datensätzen oder aggregieren Sie Datensätze zu einer größeren Datei [PutRecords](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_PutRecords.html), bevor Sie den Einzeldatensatzvorgang verwenden. [PutRecord](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_PutRecord.html) Wenn Sie keine Stapel bilden und keine Pufferung verwenden können, nutzen Sie mehrere Threads, um gleichzeitig in Service Kinesis Data Streams schreiben zu können. Zu diesen AWS SDK für Java und anderen SDKs gehören asynchrone Clients, die dies mit sehr wenig Code bewerkstelligen können.
**Kleiner Produzent**
Eine kleiner Produzent ist in der Regel eine mobile App, ein IoT-Gerät oder ein Webclient. Wenn es sich um eine mobile App handelt, empfehlen wir, den `PutRecords` Vorgang oder den Kinesis Recorder auf dem AWS Handy SDKs zu verwenden. Weitere Informationen finden Sie in den Handbüchern „ AWS Mobile SDK für Android Erste Schritte“ und „ AWS Mobile SDK for iOS Erste Schritte“. Mobile Anwendungen müssen Verbindungsunterbrechungen bewältigen und benötigen eine Art Stapeleingabe, beispielsweise `PutRecords`. Wenn Sie aus irgendeinem Grund keine Stapel bilden können, lesen Sie sich die oben stehenden Informationen zu großen Produzenten durch. Ist der Produzent ein Browser, ist die Menge der generierten Dateien in der Regel sehr klein. Allerdings platzieren Sie *PUT*-Operationen im kritischen Pfad der Anwendung. Dies wird von uns nicht empfohlen.
### Missbrauch von `flushSync()` Vorgängen
Eine `flushSync()` falsche Verwendung kann die Schreibleistung erheblich beeinträchtigen. Der `flushSync()` Vorgang ist für Shutdown-Szenarien konzipiert, um sicherzustellen, dass alle gepufferten Datensätze gesendet werden, bevor die KPL-Anwendung beendet wird. Wenn Sie diesen Vorgang nach jedem Schreibvorgang implementieren, kann dies zu einer erheblichen zusätzlichen Latenz von etwa 500 ms pro Schreibvorgang führen. Stellen Sie sicher, dass Sie die Implementierung `flushSync()` nur für das Herunterfahren der Anwendung vorgenommen haben, um unnötige zusätzliche Verzögerungen bei der Schreibleistung zu vermeiden.
## Ich erhalte einen unautorisierten KMS-Masterkey-Berechtigungsfehler
Dieser Fehler tritt auf, wenn eine Produzentenanwendung ohne Berechtigung für den KMS-Masterschlüssel Daten in einen verschlüsselten Stream schreibt. Informationen zum Zuweisen von Berechtigungen zu einer Anwendung für den Zugriff auf einen KMS-Schlüssel finden Sie unter [Verwenden von Schlüsselrichtlinien in AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html) und [Verwenden von IAM-Richtlinien mit AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/iam-policies.html).
## Beheben Sie andere häufig auftretende Probleme von Herstellern
+ [Warum gibt mein Kinesis-Datenstrom einen 500 Internal Server Error zurück?](https://aws.amazon.com/premiumsupport/knowledge-center/kinesis-data-stream-500-error/)
+ [Wie behebe ich Timeout-Fehler beim Schreiben von Flink in Kinesis Data Streams?](https://aws.amazon.com/premiumsupport/knowledge-center/kinesis-flink-timeout/)
+ [Wie behebe ich Drosselungsfehler in Kinesis Data Streams?](https://aws.amazon.com/premiumsupport/knowledge-center/kinesis-data-stream-throttling-errors/)
+ [Warum drosselt mein Kinesis-Datenstrom?](https://aws.amazon.com/premiumsupport/knowledge-center/kinesis-data-stream-throttling/)
+ [Wie kann ich Datensätze mithilfe der KPL in einen Kinesis-Datenstrom einfügen?](https://aws.amazon.com/premiumsupport/knowledge-center/kinesis-data-stream-kpl/)
# Optimieren Sie Kinesis Data Streams Streams-Produzenten
Sie können Ihre Amazon Kinesis Data Streams Streams-Producer je nach dem spezifischen Verhalten, das Sie beobachten, weiter optimieren. Sehen Sie sich die folgenden Themen an, um Lösungen zu finden.
**Topics**
+ [Passen Sie KPL-Wiederholungsversuche und das Verhalten bei der Ratenbegrenzung an](kinesis-producer-adv-retries-rate-limiting.md)
+ [Wenden Sie bewährte Methoden auf die KPL-Aggregation an](kinesis-producer-adv-aggregation.md)
# Passen Sie KPL-Wiederholungsversuche und das Verhalten bei der Ratenbegrenzung an
Wenn Sie Benutzerdatensätze der Amazon Kinesis Producer Library (KPL) mithilfe des `addUserRecord()` KPL-Vorgangs hinzufügen, erhält ein Datensatz einen Zeitstempel und wird einem Puffer hinzugefügt, dessen Frist durch den `RecordMaxBufferedTime` Konfigurationsparameter festgelegt wird. Diese stamp/deadline Zeitkombination legt die Pufferpriorität fest. Datensätze werden aufgrund der folgenden Kriterien aus dem Puffer entfernt:
+ Puffer-Priorität
+ Aggregierungskonfiguration
+ Sammlungskonfiguration
Die Parameter der Aggregierungskonfiguration und der Sammlungskonfiguration, die das Pufferverhalten beeinflussen, sind:
+ `AggregationMaxCount`
+ `AggregationMaxSize`
+ `CollectionMaxCount`
+ `CollectionMaxSize`
Die gelöschten Datensätze werden dann mithilfe eines Aufrufs der API-Operation `PutRecords` von Kinesis Data Streams als Datensätze von Amazon Kinesis Data Streams an Ihren Kinesis-Datenstrom gesendet. Die Operation `PutRecords` sendet Anfragen an Ihre Stream, die gelegentlich vollständige oder teilweise Fehlschläge zeigen. Fehlgeschlagene Datensätze werden automatisch wieder dem KPL-Puffer hinzugefügt. Die neue Frist wird auf der Grundlage des kleineren dieser beiden Werte festgelegt:
+ Die Hälfte der aktuellen `RecordMaxBufferedTime`-Konfiguration
+ Der time-to-live Wert des Datensatzes
Mit dieser Strategie können erneut versuchte KPL-Benutzerdatensätze in nachfolgende Kinesis Data Streams Streams-API-Aufrufe aufgenommen werden, um den Durchsatz zu verbessern und die Komplexität zu reduzieren und gleichzeitig den Wert des Kinesis Data Streams Streams-Datensatzes durchzusetzen. time-to-live Es gibt keinen Backoff-Algorithmus, was dies zu einer relativ aggressiven Wiederholungsstrategie macht. Spamming aufgrund übermäßiger Wiederholungen wird durch die Quotengrenze bewirkt, die im nächsten Abschnitt erläutert wird.
## Ratenbegrenzung
Das KPL enthält eine Quotenbegrenzungsfunktion, die den pro Shard von einem einzelnen Producer gesendeten Durchsatz begrenzt. Die Quotenbegrenzung wird durch einen Token-Bucket-Algorithmus mit separaten Buckets für Datensätze von Kinesis Data Streams und Bytes implementiert. Jeder erfolgreiche Schreibvorgang in einen Kinesis-Datenstrom fügt jedem Bucket ein Token (oder mehrere Token) hinzu, bis ein bestimmter Grenzwert erreicht ist. Dieser Grenzwert ist konfigurierbar, ist aber standardmäßig um 50 % höher als das tatsächliche Shard-Limit eingestellt, um die Shard-Sättigung durch einen einzelnen Produzenten zu ermöglichen.
Sie können diesen Grenzwert herabsetzen, um Spamming durch übermäßig viele Wiederholungsversuche zu reduzieren. Die bewährte Methode besteht jedoch darin, dass jeder Produzent aggressiv einen maximalen Durchsatz durch Wiederholungen zu erzielen versucht und mit der daraus resultierenden, als übermäßig angesehenen Drosselung so umzugehen, dass die Kapazität des Streams erweitert und eine geeignete Partitionsschlüsselstrategie implementiert wird.
# Wenden Sie bewährte Methoden auf die KPL-Aggregation an
Das Sequenznummernschema der resultierenden Amazon Kinesis Data Streams Streams-Datensätze bleibt zwar gleich, aber die Aggregation führt dazu, dass die Indizierung der Benutzerdatensätze der Amazon Kinesis Producer Library (KPL), die in einem aggregierten Kinesis Data Streams Streams-Datensatz enthalten sind, bei 0 (Null) beginnt. Solange Sie sich jedoch nicht auf Sequenznummern verlassen, um Ihre KPL-Benutzerdatensätze eindeutig zu identifizieren, kann Ihr Code dies ignorieren, da die Aggregation (Ihrer KPL-Benutzerdatensätze) zu einer Kinesis Data Streams (Datensatz) und anschließende Deaggregation (eines Kinesis Data Streams-Datensatzes in Ihre KPL-Benutzerdatensätze) erledigt das automatisch für Sie. Dies gilt unabhängig davon, ob Ihr Kunde die KCL oder das AWS SDK verwendet. Um diese Aggregationsfunktion nutzen zu können, müssen Sie den Java-Teil der KPL in Ihren Build übernehmen, wenn Ihr Consumer mithilfe der im SDK bereitgestellten API geschrieben wurde. AWS
Wenn Sie beabsichtigen, Folgenummern als einzige Kennungen Ihrer KPL-Benutzerdatensätze zu verwenden, empfehlen wir die Verwendung der vertragsgemäßen Operationen `public int hashCode()` und `public boolean equals(Object obj)` in `Record` und `UserRecord` zur Aktivierung des Vergleichs Ihrer KPL-Benutzerdatensätze. Wenn Sie zudem die Teilsequenznummer des KPL;-Benutzerdatensatzes untersuchen möchten, können Sie eine Typumwandlung in eine `UserRecord`-Instance vornehmen und deren Teilsequenznummer abrufen.
Weitere Informationen finden Sie unter [Implementieren Sie die Deaggregation für Verbraucher](kinesis-kpl-consumer-deaggregation.md).