0Pricing
AWS Solutions Architect · Lektion

Kinesis Data Streams für die Echtzeit-Ereignisverarbeitung

Erzeugen und verarbeiten Sie ereignisreiche Streams mit hohem Durchsatz über Kinesis Data Streams, verwalten Sie Shards für den Durchsatz und verwenden Sie Lambda als Consumer.

Kinesis Data Streams für die Echtzeit-Ereignisverarbeitung ist eine kostenlose AWS Solutions Architect-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des AWS Solutions Architect-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der AWS Solutions Architect-Kurs umfasst insgesamt 4 Lektionen.

Grundlegende Konzepte von Kinesis Data Streams

Kinesis Data Streams (KDS) ist ein dauerhaft verfügbarer, geordneter Echtzeit-Datenstreamingdienst. Daten werden in einem Stream organisiert, der aus einem oder mehreren Shards besteht. Jeder Shard ist eine geordnete Folge von Datensätzen. Produzenten schreiben Datensätze mithilfe eines Partitionsschlüssels in Shards. Dieser bestimmt, welcher Shard den Datensatz empfängt. Konsumenten lesen Datensätze aus Shards und verarbeiten sie innerhalb jedes Shards in der Reihenfolge ihres Eintreffens.

Kapazität und Durchsatzlimits von Shards

Jeder Shard unterstützt einen Schreibdurchsatz von 1 MB/s oder 1.000 Datensätzen/s und einen Lesedurchsatz von 2 MB/s (geteilt unter allen Standard-Konsumenten dieses Shards). Die Gesamtkapazität eines Streams skaliert linear mit der Anzahl der Shards. Verwenden Sie die Formel: shards_needed = max(write_MB_per_s / 1, read_MB_per_s / 2). Wenn Produzenten das Schreiblimit erreichen, treten Fehler vom Typ ProvisionedThroughputExceededException auf. Beheben Sie das Problem, indem Sie Shards aufteilen oder die Partitionsschlüssel gleichmäßiger verteilen.

# Calculate shards needed for a stream:
# - Ingest rate: 5 MB/s writes
# - Read rate: 3 consumers x 2 MB/s = 6 MB/s reads
# shards = max(5/1, 6/2) = max(5, 3) = 5 shards needed

aws kinesis create-stream \
  --stream-name iot-telemetry \
  --shard-count 5

Partitionsschlüssel und Datenverteilung

Der Partitionsschlüssel ist eine Zeichenfolge, die Kinesis per Hashing (MD5) verarbeitet, um zu bestimmen, welcher Shard einen Datensatz empfängt. Ein gut gewählter Partitionsschlüssel verteilt Datensätze gleichmäßig auf die Shards (Vermeidung überlasteter Shards). Für IoT verwenden Sie die Geräte-ID. Für Clickstreams verwenden Sie die Sitzungs-ID oder die Benutzer-ID. Vermeiden Sie Partitionsschlüssel mit geringer Kardinalität (z. B. einen Ländernamen mit nur 5 möglichen Werten), da sie zu überlasteten Shards führen. Dabei erhält ein Shard unverhältnismäßig viel Schreibverkehr, während andere nicht ausgelastet sind.

import boto3, json

client = boto3.client('kinesis', region_name='us-east-1')

# Good: use device_id as partition key for even distribution
event = {'deviceId': 'sensor-42', 'temp': 23.5, 'ts': '2024-01-15T10:00:00Z'}
client.put_record(
    StreamName='iot-telemetry',
    Data=json.dumps(event),
    PartitionKey='sensor-42'  # high-cardinality -> even distribution
)

Standard-Konsumenten und Enhanced Fan-Out

Standard-Konsumenten teilen sich den Lesedurchsatz von 2 MB/s pro Shard und verwenden dafür GetRecords mit Polling. Wenn Sie 3 Konsumenten auf einem Shard haben, von denen jeder 2 MB/s benötigt, werden sie beim Teilen des Gesamtdurchsatzes von 2 MB/s gedrosselt. Enhanced Fan-Out (EFO) stellt jedem registrierten Konsumenten über eine persistente HTTP/2-Push-Verbindung (SubscribeToShard) eine eigene dedizierte Lesekapazität von 2 MB/s bereit. EFO verursacht Kosten pro Konsument-Shard-Stunde, beseitigt jedoch die Konkurrenz um den Lesedurchsatz vollständig.

# Register an Enhanced Fan-Out consumer
aws kinesis register-stream-consumer \
  --stream-arn arn:aws:kinesis:us-east-1:123456789012:stream/iot-telemetry \
  --consumer-name real-time-analytics

# List registered consumers
aws kinesis list-stream-consumers \
  --stream-arn arn:aws:kinesis:us-east-1:123456789012:stream/iot-telemetry

Lambda als Kinesis-Konsument

Lambda lässt sich über ein Event Source Mapping nativ in Kinesis Data Streams integrieren. Lambda fragt den Stream regelmäßig ab, liest Datensatzstapel und ruft Ihre Funktion auf. Konfigurieren Sie BatchSize (1–10.000 Datensätze), StartingPosition (TRIM_HORIZON für die ältesten, LATEST für die neuesten Datensätze) und BisectBatchOnFunctionError, um fehlgeschlagene Stapel aufzuteilen. Mit dem Parallelisation Factor (1–10) kann Lambda mehrere gleichzeitige Aufrufe pro Shard starten, um mit schnell eintreffenden Streams Schritt zu halten.

# Create a Lambda event source mapping for Kinesis
aws lambda create-event-source-mapping \
  --function-name ProcessIoTEvents \
  --event-source-arn arn:aws:kinesis:us-east-1:123456789012:stream/iot-telemetry \
  --batch-size 100 \
  --starting-position LATEST \
  --parallelization-factor 5 \
  --bisect-batch-on-function-error true \
  --destination-config '{
    "OnFailure": {
      "Destination": "arn:aws:sqs:us-east-1:123456789012:kinesis-dlq"
    }
  }'

Kinesis Client Library (KCL)

Die Kinesis Client Library (KCL) ist ein Anwendungsframework zum Erstellen robuster Kinesis-Konsumenten in Java (oder mehrsprachig über MultiLangDaemon). KCL übernimmt die Auflistung von Shards, die Lease-Verwaltung (die Verteilung von Shards auf Worker-Instanzen), das Speichern von Prüfpunkten für den Fortschritt in DynamoDB sowie das geordnete Aufteilen und Zusammenführen von Shards. Jeder KCL-Worker verarbeitet einen oder mehrere Shards. KCL verteilt Shards automatisch neu, wenn Worker horizontal skaliert werden oder ausfallen. Für Konsumenten-Anwendungen in der Produktion wird KCL dem direkten Polling über das SDK vorgezogen.

# KCL stores checkpoints in a DynamoDB table automatically
# Each shard has one row tracking the last successfully processed sequence number
# KCL lease table structure:
# leaseKey (shardId) | checkpoint (sequenceNumber) | leaseOwner (workerId)
#
# To start a KCL application (pseudocode):
# KinesisClientLibConfiguration config = new KinesisClientLibConfiguration(
#   'iot-app', 'iot-telemetry', credentialsProvider, 'worker-1');
# Worker worker = new Worker.Builder().config(config).recordProcessorFactory(factory).build();
# worker.run();

Datenaufbewahrung und Replay

Kinesis Data Streams speichert Datensätze standardmäßig 24 Stunden (erweiterbar auf 7 Tage oder mit Long-Term Retention gegen zusätzliche Kosten auf bis zu 365 Tage). Anders als bei SQS werden gelesene Datensätze nach dem Konsumieren nicht gelöscht – sie bleiben bis zum Ablauf der Aufbewahrungsfrist verfügbar. Dadurch können mehrere Konsumenten dieselben Datensätze unabhängig voneinander lesen. Außerdem ist ein Replay möglich, indem der Prüfpunkt eines Konsumenten auf eine frühere Sequenznummer zurückgesetzt wird – besonders nützlich für Fehlerbehebungen oder zum nachträglichen Befüllen neuer Services.

# Extend stream retention to 7 days
aws kinesis increase-stream-retention-period \
  --stream-name iot-telemetry \
  --retention-period-hours 168

# Get records from the oldest available record (replay)
SHARD_ITERATOR=$(aws kinesis get-shard-iterator \
  --stream-name iot-telemetry \
  --shard-id shardId-000000000000 \
  --shard-iterator-type TRIM_HORIZON \
  --query 'ShardIterator' --output text)

aws kinesis get-records --shard-iterator $SHARD_ITERATOR --limit 100

On-Demand-Kapazitätsmodus

Kinesis Data Streams unterstützt zwei Kapazitätsmodi. Provisioned mode: Sie verwalten die Anzahl der Shards manuell und zahlen pro Shard-Stunde. On-Demand mode: Kinesis skaliert die Shard-Kapazität automatisch anhand des eingehenden Durchsatzes (standardmäßig bis zu 200 MB/s beim Schreiben und 400 MB/s beim Lesen), und Sie zahlen pro GB geschriebener und abgerufener Daten. Der On-Demand-Modus eignet sich besonders für variable oder unvorhersehbare Verkehrsmuster, bei denen Sie die Shard-Skalierung nicht selbst verwalten möchten.

# Switch an existing stream to On-Demand mode
aws kinesis update-stream-mode \
  --stream-arn arn:aws:kinesis:us-east-1:123456789012:stream/iot-telemetry \
  --stream-mode-details StreamMode=ON_DEMAND

Garantierte Reihenfolge innerhalb von Shards

Kinesis garantiert die Reihenfolge innerhalb eines Shards – Datensätze mit demselben Partitionsschlüssel werden immer an denselben Shard gesendet und in der Reihenfolge gelesen, in der sie geschrieben wurden. Über Shards hinweg gibt es jedoch keine Garantie für die Reihenfolge. Wenn Ihre Anwendung eine globale Reihenfolge aller Datensätze erfordert, verwenden Sie einen einzelnen Shard (wodurch der Durchsatz auf 1 MB/s begrenzt wird) oder entwerfen Sie die Anwendung so um, dass die Reihenfolge nur innerhalb einer Gruppe von Partitionsschlüsseln erforderlich ist (z. B. eine Reihenfolge pro Gerät). Dies ist ein häufiger Prüfungsunterschied zu SQS FIFO, das eine strikte Deduplizierung und Reihenfolge bietet.

Sicherheit: Verschlüsselung und VPC

Kinesis Data Streams verschlüsselt Datensätze bei aktivierter serverseitiger Verschlüsselung serverseitig im Ruhezustand mithilfe von AWS KMS (CMK oder von AWS verwalteter Schlüssel). Alle Daten während der Übertragung werden mit TLS verschlüsselt. Verwenden Sie für Anwendungen in einer VPC, die Streamdaten nicht über das öffentliche Internet senden sollen, einen VPC Interface Endpoint (PrivateLink) für Kinesis. Dadurch bleibt der Datenverkehr vollständig innerhalb des AWS-Netzwerk-Backbones – ein wichtiger Aspekt für regulierte Workloads.

# Enable server-side encryption on a Kinesis stream
aws kinesis start-stream-encryption \
  --stream-name iot-telemetry \
  --encryption-type KMS \
  --key-id arn:aws:kms:us-east-1:123456789012:key/mrk-abc123

Kinesis Data Streams im Vergleich zu SQS und Kafka

Vergleichen Sie für die SAA-C03-Prüfung Kinesis Data Streams mit den Alternativen. Kinesis im Vergleich zu SQS: Kinesis bewahrt die Reihenfolge innerhalb eines Shards und unterstützt mehrere Konsumenten, die dieselben Daten lesen; SQS löscht Nachrichten nach dem Konsumieren. Kinesis im Vergleich zu MSK (Kafka): MSK ist verwaltetes Apache Kafka. Verwenden Sie es, wenn Sie Kompatibilität mit dem Kafka-Protokoll, erweiterte Topic-Konfigurationen oder eine Migration von einer lokalen Kafka-Installation benötigen. Verwenden Sie Kinesis für AWS-natives Streaming mit enger Integration in Lambda, Firehose und Flink. Wählen Sie Kinesis, sofern in der Frage nicht ausdrücklich Kafka oder Anforderungen an die Kafka-Kompatibilität erwähnt werden.

Kurze Überprüfung

Testen Sie Ihr Verständnis der Konzepte für AWS Solutions Architect (SAA-C03) aus dieser Lektion.

Zusammenfassung der Lektion

In dieser Lektion haben Sie Folgendes gelernt: Kinesis Data Streams stellt in Shards organisierte, geordnete und dauerhaft gespeicherte Streams mit einer standardmäßigen Aufbewahrungsfrist von 24 Stunden und Replay-Funktion bereit, Enhanced Fan-Out stellt jedem Konsumenten pro Shard dedizierte 2 MB/s bereit und beseitigt dadurch die Konkurrenz um den Lesedurchsatz und der On-Demand-Modus skaliert Shards bei unvorhersehbarem Datenverkehr automatisch. Als Nächstes beschäftigen wir uns mit den Mustern Choreografie und Orchestrierung in ereignisgesteuerten Architekturen.

Häufig gestellte Fragen

Ist die Lektion „Kinesis Data Streams für die Echtzeit-Ereignisverarbeitung“ kostenlos?

Ja — der vollständige Text von „Kinesis Data Streams für die Echtzeit-Ereignisverarbeitung“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des AWS Solutions Architect-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der AWS Solutions Architect-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Kinesis Data Streams für die Echtzeit-Ereignisverarbeitung“?

Erzeugen und verarbeiten Sie ereignisreiche Streams mit hohem Durchsatz über Kinesis Data Streams, verwalten Sie Shards für den Durchsatz und verwenden Sie Lambda als Consumer. Du übst AWS Solutions Architect mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um AWS Solutions Architect zu starten?

Keine Vorkenntnisse erforderlich. AWS Solutions Architect auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Kinesis Data Streams für die Echtzeit-Ereignisverarbeitung“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser AWS Solutions Architect-Lektion Code schreiben und ausführen?

Ja. Jede AWS Solutions Architect-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. EventBridge: Event Bus und Regeln
  2. Step Functions: Orchestrierung serverloser Workflows
  3. Kinesis Data Streams für die Echtzeit-Ereignisverarbeitung
  4. Muster: Choreografie im Vergleich zu Orchestrierung
← Zurück zu AWS Solutions Architect