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.
# 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 | -- | -- |