Verwenden des Echtzeitmodus in Lakeflow-Pipelines

Der Echtzeitmodus ermöglicht eine Datenverarbeitung mit extrem niedriger Latenz und zielt auf eine End-to-End-Latenz unter einer Sekunde ab, so niedrig wie fünf Millisekunden. Verwenden Sie den Echtzeitmodus für Betriebsarbeitslasten, die sofortige Reaktion auf Streamingdaten erfordern, z. B. Betrugserkennung und Echtzeitpersonalisierung.

Der Echtzeitmodus ist auch direkt in Structured Streaming außerhalb von Pipelines verfügbar. Sehen Sie sich den Echtzeitmodus im strukturierten Streaming an.

So erzielt der Echtzeitmodus eine niedrige Latenz

Der Echtzeitmodus unterscheidet sich von der standardmäßigen kontinuierlichen Verarbeitung auf drei wichtige Arten:

  • Lange laufende Batches: Das System verarbeitet Daten, sobald es in der Quelle innerhalb langer Batches verfügbar wird (Standardwert ist fünf Minuten).
  • Gleichzeitige Phasenplanung: Alle Abfragephasen werden gleichzeitig geplant. Die Computeressource muss über genügend verfügbare Vorgangsplätze verfügen, um alle Phasen gleichzeitig abzudecken. Siehe Dimensionierung der Rechenleistung.
  • Streaming-Shuffle: Daten werden zwischen den Phasen weitergegeben, sobald sie erzeugt werden, anstatt zu warten, bis eine vorgelagerte Phase abgeschlossen ist, bevor die nachgelagerte Phase beginnt.

Das Prüfpunktintervall (konfiguriert über pipelines.trigger.interval) legt fest, wie häufig Status und Quell-Offsets in einem dauerhaften Speicher gespeichert werden. Längere Intervalle verringern den Prüfpunkt-Overhead, erhöhen aber die Wiederherstellungszeit nach einem Ausfall und verzögern die Metrikberichterstattung. Kürzere Intervalle verbessern die Haltbarkeit, fügen aber mehr Aufwand hinzu.

Echtzeitmodus und fortlaufende Pipelines

Der Echtzeitmodus ist eine spezielle Art von fortlaufendem Trigger. Der kontinuierliche Modus ist weiterhin erforderlich; der Echtzeitmodus fügt zusätzlich Latenzoptimierungen auf Flussebene hinzu. Um den Echtzeitmodus zu verwenden, muss die Pipeline zuerst im fortlaufenden Modus ausgeführt werden. Der Echtzeitmodus wendet dann zusätzliche Optimierungen auf Flussebene an, um eine Sub-Second-Latenz zu erzielen, die über die standardmäßige fortlaufende Verarbeitung hinausgeht.

Für das Aktivieren des Echtzeitmodus sind drei Konfigurationsschritte erforderlich:

  1. Legen Sie die Pipeline auf den fortlaufenden Modus fest.
  2. Aktivieren Sie den Echtzeitmodus auf Pipelineebene.
  3. Definieren Sie einen Echtzeitaktualisierungsfluss.

Requirements

Requirement Value
Computetyp Klassisches Computing oder serverlos
Pipelinemodus Kontinuierlich

Konfigurieren des Echtzeitmodus

Schritt 1: Festlegen der Pipeline auf den fortlaufenden Modus

Legen Sie in den Pipelineeinstellungen den Pipelinemodus auf "Fortlaufend" fest, oder legen Sie ihn in der Pipeline-JSON fest:

{
  "continuous": true
}

Schritt 2: Aktivieren des Echtzeitmodus auf Pipelineebene

Fügen Sie in den Pipelineeinstellungen den folgenden Schlüssel zur Spark-Konfiguration unter "Erweiterte > Spark-Konfiguration" hinzu:

spark.databricks.streaming.realTimeMode.enabled = true

Sie können dies auch in der Pipeline-JSON festlegen:

{
  "continuous": true,
  "spark_conf": {
    "spark.databricks.streaming.realTimeMode.enabled": "true"
  }
}

Schritt 3: Definieren eines Echtzeitaktualisierungsflusses

Der Echtzeitmodus erfordert einen Aktualisierungsfluss. Verwenden Sie dp.create_sink() oder @dp.foreach_sink, um das Ausgangsziel zu definieren, und verwenden Sie dann den @dp.update_flow Decorator mit pipelines.trigger, das auf "RealTime" gesetzt ist, und target, das auf den Sink verweist.

from pyspark import pipelines as dp

# Define the output sink
dp.create_sink(
    "my_kafka_sink",
    "kafka",
    {
        "kafka.bootstrap.servers": "<bootstrap-servers>",
        "topic": "<output-topic>",
    }
)

# Define the real-time update flow targeting the sink
@dp.update_flow(
    name="my_rtm_flow",
    target="my_kafka_sink",
    spark_conf={
        "pipelines.trigger": "RealTime",
        "pipelines.trigger.interval": "5 minutes",  # optional; defaults to 5 minutes
    }
)
def my_real_time_flow():
    return (
        spark.readStream
            .format("kafka")
            .option("kafka.bootstrap.servers", "<bootstrap-servers>")
            .option("subscribe", "<input-topic>")
            .load()
    )

Konfigurationsparameter auf Flussebene:

Parameter Erforderlich Vorgabe Description
pipelines.trigger Yes — Auf "RealTime" festlegen, um den Echtzeitmodus für diesen Ablauf zu aktivieren.
pipelines.trigger.interval No "5 minutes" Prüfpunktintervall. Steuert, wie oft Status und Offsets gespeichert werden. Kürzere Werte verbessern die Wiederherstellbarkeit; längere Werte reduzieren den Mehraufwand.

Code-Beispiele

Kafka-zu-Kafka

Aus einem Kafka-Topic lesen und in ein Kafka-Ausgabeziel schreiben:

from pyspark import pipelines as dp

dp.create_sink("kafka_output_sink", "kafka", {
    "kafka.bootstrap.servers": broker_address,
    "topic": output_topic,
})

@dp.update_flow(
    name="kafka_rtm_flow",
    target="kafka_output_sink",
    spark_conf={
        "pipelines.trigger": "RealTime",
        "pipelines.trigger.interval": "5 minutes",
    }
)
def kafka_rtm_flow():
    return (
        spark.readStream
            .format("kafka")
            .option("kafka.bootstrap.servers", broker_address)
            .option("subscribe", input_topic)
            .option("startingOffsets", "latest")
            .load()
            .selectExpr("CAST(key AS STRING)", "CAST(value AS STRING)", "timestamp")
    )

Kafka in eine ForEach-Senke

Liest aus einem Kafka-Thema und verarbeitet jede Zeile mit einer Python-Funktion in einem ForEach Sink:

from pyspark import pipelines as dp

@dp.foreach_sink(name="events_foreach_sink")
def handle_event(row):
    # Custom per-row logic here, such as a call to an external API.
    ...

@dp.update_flow(
    name="foreach_rtm_flow",
    target="events_foreach_sink",
    spark_conf={
        "pipelines.trigger": "RealTime",
        "pipelines.trigger.interval": "5 minutes",
    }
)
def foreach_rtm_flow():
    return (
        spark.readStream
            .format("kafka")
            .option("kafka.bootstrap.servers", broker_address)
            .option("subscribe", input_topic)
            .option("startingOffsets", "latest")
            .load()
            .selectExpr("CAST(key AS STRING) AS key", "CAST(value AS STRING) AS value")
    )

Anreichern mit einem Broadcast-Join

Verbinden eines Kafka-Datenstroms mit einer statischen Nachschlagetabelle Der Echtzeitmodus unterstützt Broadcast-(stream-to-static-)Joins. Es unterstützt außerdem Stream-to-Stream-Inner Joins in Databricks Runtime 18 LTS und höher mit zusätzlicher Spark-Konfiguration, aber keine Stream-to-Stream-Outer Joins. Siehe Stream-zu-Stream-Joins.

from pyspark import pipelines as dp
from pyspark.sql.functions import broadcast, expr

dp.create_sink("enriched_output_sink", "kafka", {
    "kafka.bootstrap.servers": broker_address,
    "topic": enriched_output_topic,
})

@dp.update_flow(
    name="enriched_events_flow",
    target="enriched_output_sink",
    spark_conf={
        "pipelines.trigger": "RealTime",
        "pipelines.trigger.interval": "5 minutes",
    }
)
def enriched_events():
    lookup = spark.read.table("catalog.schema.lookup_table")
    return (
        spark.readStream
            .format("kafka")
            .option("kafka.bootstrap.servers", broker_address)
            .option("subscribe", input_topic)
            .load()
            .withColumn("event_key", expr("CAST(value AS STRING)"))
            .join(broadcast(lookup), expr("event_key = lookup_key"))
            .select("event_key", "lookup_value", "timestamp")
    )

Aggregation

Zählen von Ereignissen nach Schlüssel mithilfe eines zustandsbehafteten groupBy. Stellen Sie spark.sql.shuffle.partitions so ein, dass es der Anzahl der Eingabepartitionen für zustandsbehaftete Operationen entspricht:

from pyspark import pipelines as dp
from pyspark.sql.functions import col

dp.create_sink("event_counts_sink", "kafka", {
    "kafka.bootstrap.servers": broker_address,
    "topic": output_topic,
})

@dp.update_flow(
    name="event_counts_flow",
    target="event_counts_sink",
    spark_conf={
        "pipelines.trigger": "RealTime",
        "pipelines.trigger.interval": "5 minutes",
        "spark.sql.shuffle.partitions": "8",
    }
)
def event_counts():
    return (
        spark.readStream
            .format("kafka")
            .option("kafka.bootstrap.servers", broker_address)
            .option("subscribe", input_topic)
            .load()
            .selectExpr("CAST(key AS STRING) AS event_type", "timestamp")
            .groupBy(col("event_type"))
            .count()
    )

Unterstützte Quellen und Empfänger

Konnektor Als Quelle Als Spüle Hinweise
Apache Kafka ✓ ✓ —
Azure Event Hubs (Kafka Connector) ✓ ✓ Verwendet die kafka-kompatible Schnittstelle.
Delta Nicht unterstützt Nicht unterstützt —
ForEach-Senke Nicht anwendbar ✓ Führt Ihre Python-Funktion oder das Writer-Objekt für jede Zeile aus. Siehe Verwenden Sie eine ForEach-Senke, um jede Zeile in Pipelines zu schreiben.

Dimensionierung der Computekapazität

Serverless-Pipelines auf dem Vorschaukanal

Important

Das Ausführen mehrerer Echtzeitflüsse pro Pipeline ohne Task-Slot-Konkurrenz sowie adaptive Repartitionierung der Quellstufe befinden sich in der Beta-Phase. Sie sind nur auf serverlosen Pipelines verfügbar, die den Vorschaukanal verwenden.

Azure Databricks reserviert Task-Slots für jeden Real-Time-Flow, sodass Sie mehrere Real-Time-Flows in einer Pipeline ausführen können, ohne dass die Flüsse um Task-Slots konkurrieren. Sie müssen die benötigte Rechenleistung nicht dimensionieren.

Die adaptive Repartitionierung der Quellstufe passt automatisch die Anzahl der Aufgaben an, die aus jeder Kafka- oder Kinesis-Quelle lesen, um ihrem Datenverkehr gerecht zu werden. Um es zu verwenden, legen Sie maxPartitions bei Kafka-Quellen sowie maxPartitions und shardsPerTask bei Kinesis-Quellen nicht fest. Wenn Sie diese Optionen festlegen, verwendet die Quelle stattdessen die festgelegte Anzahl der von Ihnen konfigurierten Aufgaben. Die Shuffle-Partitionsanzahlen werden nicht angepasst, daher setzen Sie spark.sql.shuffle.partitions für zustandsbehaftete Flows, wie in Aggregation gezeigt.

Serverless-Pipelines auf dem aktuellen Kanal

Azure Databricks dimensioniert Compute für Sie. Die Anzahl der Aufgaben, die von jeder Quelle lesen, ist fest. Legen Sie daher maxPartitions für Kafka-Quellen oder maxPartitions bzw. shardsPerTask für Kinesis-Quellen fest, um Ihren Datenverkehrsspitzen zu bewältigen.

Klassisches Rechnen

Die Rechenleistung muss genügend Aufgabenslots haben, um alle Aufgaben gleichzeitig über alle Abfragephasen hinweg auszuführen. Die folgende Tabelle zeigt die erforderlichen Task-Slots für gängige Pipeline-Typen:

Pipelinetyp Configuration Erforderliche Aufgabenplätze
Einstufig zustandslos (Kafka-Quelle und -Senke) maxPartitions = 8 8
Zweistufig zustandsbehaftet (Kafka-Quelle und -Shuffle) maxPartitions = 8, Shuffle-Partitionen = 20 28 (8 + 20)
Drei Stufen (Kafka-Quelle + zwei Shuffles) maxPartitions = 8, zwei Shuffle-Phasen mit jeweils 20 48 (8 + 20 + 20)

Wenn Sie maxPartitions nicht festlegen, verwenden Sie die Anzahl der Partitionen im Kafka-Thema.

Operatorunterstützung

Kategorie Bediener Unterstützt
Zustandslos Auswahl, Projektion ✓
UDFs Skala UDF (*) (mit Einschränkungen)
UDFs Python-Benutzerdefinierte Funktion (UDF) (*) (mit Einschränkungen)
Aggregation Summe, Anzahl, Max, Min, Durchschnitt ✓
Windowing Stürzen, Gleiten ✓
Windowing Session Nicht unterstützt
Deduplication dropDuplicates ✔ (ungebundener Zustand)
Deduplication dropDuplicatesWithinWatermark ✓
Verknüpfungen Broadcast-Tabellen-Join ✓
Verknüpfungen Stream-zu-Stream-Inner Join ✓ (Databricks Laufzeit ab 18 LTS, mit zusätzlicher Spark-Konfiguration)
Verknüpfungen Stream-zu-Stream-Outer-Join Nicht unterstützt
Custom transformWithState • (mit Verhaltensunterschieden)
Custom union (*) (mit Einschränkungen)
Custom forEach ✓
Custom flatMapGroupsWithState Nicht unterstützt
Custom mapPartitions Nicht unterstützt
Custom forEachBatch Nicht unterstützt

transformWithState im Echtzeitmodus

transformWithState wird im Echtzeitmodus mit den folgenden Unterschieden gegenüber der Mikrobatch-Verarbeitung unterstützt:

  • handleInputRows wird einmal pro Zeile und nicht einmal pro Schlüssel pro Batch aufgerufen. Der inputRows Iterator liefert einen einzelnen Wert pro Aufruf.
  • Ereigniszeitgeber werden nicht unterstützt. Timer für die Verarbeitungszeit werden ausgelöst, wenn ein lange laufender Batch beendet wird, ohne dass Daten angekommen sind.
  • transformWithStateInPandas wird nicht unterstützt.

Pandas UDFs im Echtzeitmodus

Um die Latenz bei Pandas-UDFs zu minimieren, setzen Sie spark.sql.execution.arrow.maxRecordsPerBatch auf 1. Dadurch wird die Latenz auf Kosten des Durchsatzes optimiert. Wenn der Durchsatz ebenfalls wichtig ist, legen Sie diesen Wert auf 100 oder höher fest.

Überwachen der Leistung des Echtzeitmodus

Im Echtzeitmodus werden Latenzmetriken in StreamingQueryProgress unter dem latencies-Feld verfügbar gemacht. Greifen Sie auf diese Metriken über einen StreamingQueryListener oder durch Überprüfen der lastProgress-Eigenschaft der Streamingabfrage zu.

Metric Description
processingLatencyMs Zeit zwischen dem Einlesen eines Datensatzes durch den Flow und seiner vollständigen Verarbeitung durch den Flow
sourceQueuingLatencyMs Zeit zwischen dem erfolgreichen Schreiben eines Datensatzes in den Nachrichtenbus (z. B. Protokollanfügezeit in Kafka) und dem ersten Lesen durch den Flow
e2eLatencyMs Gesamte End-to-End-Latenz vom Zeitpunkt der Erstellung des Datensatzes an der Quelle bis zu dem Zeitpunkt, an dem er vom Datenfluss vollständig verarbeitet wurde

Jede Metrik wird in Form von p50-, p90-, p95- und p99-Perzentilen angegeben.

Einschränkungen

Bei klassischem Compute und serverlosen Pipelines, die den aktuellen Kanal verwenden, wird ein Echtzeitfluss pro Pipeline empfohlen. Mehrere Flows sind erlaubt, aber sie konkurrieren um Aufgabenplätze, was die Latenz erhöht. Um mehrere Echtzeit-Flows in einer Pipeline ohne diese Latenzzunahme auszuführen, siehe Serverless-Pipelines im Vorschaukanal.

Eine vollständige Liste der Operator- und Quellbeschränkungen finden Sie unter Einschränkungen des Echtzeitmodus.

Weitere Ressourcen