Zähle anhand des Textes die wichtigsten APIs in Kafka auf. Trenne sie mit einem Komma.
Kafka speichert Key-Value-Nachrichten, die von beliebig vielen Prozessen, sogenannten Producern, stammen. Die Daten können in verschiedene "Partitionen" innerhalb verschiedener "Topics" unterteilt werden. Innerhalb einer Partition werden die Nachrichten streng nach ihren Offsets (der Position einer Nachricht innerhalb einer Partition) geordnet, indiziert und zusammen mit einem Zeitstempel gespeichert. Andere Prozesse, sogenannte "Consumer", können Nachrichten aus Partitionen lesen. Für die Stream-Verarbeitung bietet Kafka die Streams API, mit der Java-Anwendungen geschrieben werden können, die Daten aus Kafka konsumieren und die Ergebnisse zurück nach Kafka schreiben. Apache Kafka arbeitet auch mit externen Streamverarbeitungssystemen wie Apache Apex, Apache Beam, Apache Flink, Apache Spark, Apache Storm und Apache NiFi zusammen.

Kafka läuft auf einem Cluster aus einem oder mehreren Servern (den sogenannten Brokern), und die Partitionen aller Topics sind auf die Knoten des Clusters verteilt. Außerdem werden die Partitionen auf mehrere Broker repliziert. Diese Architektur ermöglicht es Kafka, riesige Nachrichtenströme fehlertolerant zu übermitteln, und hat es ermöglicht, einige der herkömmlichen Nachrichtensysteme wie Java Message Service (JMS), Advanced Message Queuing Protocol (AMQP) usw. zu ersetzen. Seit der Version 0.11.0.0 bietet Kafka transaktionale Schreibvorgänge, die mit Hilfe der Streams-API eine einmalige Stream-Verarbeitung ermöglichen.

Kafka unterstützt zwei Arten von Topics: Reguläre und verdichtete Topics. Reguläre Topics können mit einer Aufbewahrungszeit oder einer Speicherplatzbegrenzung konfiguriert werden. Wenn es Datensätze gibt, die älter sind als die angegebene Aufbewahrungszeit oder wenn die Speicherplatzgrenze für eine Partition überschritten wird, kann Kafka alte Daten löschen, um Speicherplatz freizugeben. Standardmäßig sind Topics mit einer Aufbewahrungszeit von 7 Tagen konfiguriert, aber es ist auch möglich, Daten auf unbestimmte Zeit zu speichern. Bei komprimierten Topics verfallen die Datensätze nicht aufgrund von Zeit- oder Speicherplatzbeschränkungen. Stattdessen behandelt Kafka spätere Nachrichten als Aktualisierungen älterer Nachrichten mit demselben Schlüssel und garantiert, dass die neueste Nachricht pro Schlüssel niemals gelöscht wird. Nutzer können Nachrichten komplett löschen, indem sie eine sogenannte Tombstone-Nachricht mit einem Null-Wert für einen bestimmten Schlüssel schreiben.

Es gibt fünf wichtige APIs in Kafka:

Producer API - Ermöglicht es einer Anwendung, Datensatzströme zu veröffentlichen.
Consumer API - Ermöglicht es einer Anwendung, Themen zu abonnieren und Datensatzströme zu verarbeiten.
Connector API - Führt die wiederverwendbaren Producer- und Consumer-APIs aus, die die Topics mit den bestehenden Anwendungen verbinden können.
Streams API - Diese API wandelt die Input-Streams in Output um und erzeugt das Ergebnis.
Admin API - Dient der Verwaltung von Kafka-Themen, Brokern und anderen Kafka-Objekten.
Die Consumer- und Producer-APIs sind durch ein zugrunde liegendes Messaging-Protokoll von der Kernfunktionalität von Kafka entkoppelt. Dies ermöglicht das Schreiben kompatibler API-Schichten in jeder Programmiersprache, die genauso effizient sind wie die mit Kafka gebündelten Java-APIs. Das Apache Kafka-Projekt unterhält eine Liste solcher APIs von Drittanbietern.
Producer API, Consumer API, Connector API, Streams API, Admin API
From the passage provided, list the major APIs in Kafka. Separate them with a comma.
Kafka stores key-value messages that come from arbitrarily many processes called producers. The data can be partitioned into different "partitions" within different "topics". Within a partition, messages are strictly ordered by their offsets (the position of a message within a partition), and indexed and stored together with a timestamp. Other processes called "consumers" can read messages from partitions. For stream processing, Kafka offers the Streams API that allows writing Java applications that consume data from Kafka and write results back to Kafka. Apache Kafka also works with external stream processing systems such as Apache Apex, Apache Beam, Apache Flink, Apache Spark, Apache Storm, and Apache NiFi.

Kafka runs on a cluster of one or more servers (called brokers), and the partitions of all topics are distributed across the cluster nodes. Additionally, partitions are replicated to multiple brokers. This architecture allows Kafka to deliver massive streams of messages in a fault-tolerant fashion and has allowed it to replace some of the conventional messaging systems like Java Message Service (JMS), Advanced Message Queuing Protocol (AMQP), etc. Since the 0.11.0.0 release, Kafka offers transactional writes, which provide exactly-once stream processing using the Streams API.

Kafka supports two types of topics: Regular and compacted. Regular topics can be configured with a retention time or a space bound. If there are records that are older than the specified retention time or if the space bound is exceeded for a partition, Kafka is allowed to delete old data to free storage space. By default, topics are configured with a retention time of 7 days, but it's also possible to store data indefinitely. For compacted topics, records don't expire based on time or space bounds. Instead, Kafka treats later messages as updates to older message with the same key and guarantees never to delete the latest message per key. Users can delete messages entirely by writing a so-called tombstone message with null-value for a specific key.

There are five major APIs in Kafka:

Producer API – Permits an application to publish streams of records.
Consumer API – Permits an application to subscribe to topics and processes streams of records.
Connector API – Executes the reusable producer and consumer APIs that can link the topics to the existing applications.
Streams API – This API converts the input streams to output and produces the result.
Admin API – Used to manage Kafka topics, brokers, and other Kafka objects.
The consumer and producer APIs are decoupled from the core functionality of Kafka through an underlying messaging protocol. This allows writing compatible API layers in any programming language that are as efficient as the Java APIs bundled with Kafka. The Apache Kafka project maintains a list of such third party APIs.
Producer API, Consumer API, Connector API, Streams API, Admin API