English version

Echtzeit-Prognose mit Databricks

Im Energiemarkt können neue Telemetrie- und Marktsignale alle 5 Minuten eintreffen. Diese Lektion zeigt, wie Databricks eine latenzarme Prognose-Pipeline unterstützt, die häufige Updates aufnimmt, Features aktualisiert und mit kurzem SLA eine neue Prognose schreibt.

Was „Echtzeit“ hier bedeutet

Für deinen Anwendungsfall bedeutet Echtzeit:

• Neue Anlagentelemetrie oder Marktdaten treffen alle 5 Minuten ein
• Eine Prognose, die kurz nach jedem Eintreffen aktualisiert wird
• Ein latenzarmer Produktionsfluss, der zugleich den Delta-basierten Analysezugriff erhält

Architekturmuster

Ingestion: Structured Streaming nach Bronze

Das ist der erste wichtige Schritt. Eine Micro-Batch-Pipeline erfasst jedes 5-Minuten-Payload und schreibt es mit Checkpointing in eine Delta-Bronze-Tabelle. Damit bleiben die Daten dauerhaft, abfragbar und wiederholbar.

from pyspark.sql.functions import col

streaming_df = (
    spark.readStream
         .format("cloudFiles")
         .option("cloudFiles.format", "json")
         .option("cloudFiles.schemaLocation", "/tmp/checkpoints/telemetry_schema")
         .option("cloudFiles.inferColumnTypes", "true")
         .load("/mnt/data/realtime/telemetry/")
         .select(
             col("asset_id"),
             col("timestamp"),
             col("wind_speed"),
             col("power_output"),
             col("market_price")
         )
)

query = (
    streaming_df.writeStream
        .format("delta")
        .option("checkpointLocation", "/tmp/checkpoints/bronze_telemetry")
        .outputMode("append")
        .trigger(processingTime="5 minutes")
        .table("prod.bronze.telemetry")
)

Inkrementelles Silver + Scoring

Nutze eine zweite Micro-Batch-Stufe, die den Bronze-Stream liest und alle 5 Minuten Silver-Features und Prognosen aktualisiert. Ein praxistaugliches Muster ist foreachBatch(): Es gibt dir deterministische Batch-Verarbeitung plus Schreibzugriffe auf Delta-Tabellen.

def process_batch(batch_df, batch_id):
    # 1) Telemetrie mit Anlagen-Metadaten anreichern
    enriched = (
        batch_df
        .join(spark.table("prod.silver.dim_assets"), "asset_id", "left")
        .withColumn("event_time", col("timestamp"))
    )

    # 2) Zeilen für die inkrementelle Feature-Tabelle erzeugen
    features = compute_features(enriched)

    # 3) Mit dem MLflow-Modell scoren
    model = mlflow.pyfunc.load_model("models:/wind-forecast/latest")
    scored = model.predict(features.toPandas())

    # 4) Gold-Prognose schreiben
    to_write = (
        features
        .withColumn("forecast", lit(scored))
        .withColumn("produced_at", current_timestamp())
    )

    (to_write.write
         .format("delta")
         .mode("append")
         .saveAsTable("prod.gold.forecast_ts"))

query = (
    spark.readStream
         .table("prod.bronze.telemetry")
         .writeStream
         .foreachBatch(process_batch)
         .option("checkpointLocation", "/tmp/checkpoints/silver_scoring")
         .trigger(processingTime="5 minutes")
         .start()
)

Hinweis: Wandle in Produktion nicht den gesamten Micro-Batch nach pandas um, außer der Batch ist klein. Für größere Flotten sind verteiltes Scoring in Spark oder ein MLflow-Model-Serving-Endpunkt die sicherere Wahl.

Leitlinien für Echtzeit-Reife

• Bronze roh halten: Bewahre jedes 5-Minuten-Ereignis auf, damit Analysten die schnelle Spur nachspielen und prüfen können.
• Delta für dualen Zugriff nutzen: Analyse und Produktion lesen dieselben Tabellen über Delta, sodass die schnellen Updates sofort abfragbar sind.
• Nach Anlage + Datum partitionieren: Das hilft sowohl latenzarmen Schreibvorgängen als auch effizienten Zeitreihen-Abfragen.
• Modellversion in Gold: Speichere model_version und produced_at für die Nachvollziehbarkeit.

Wann Micro-Batch besser ist als durchgehendes Streaming

Für deinen Prognose-Anwendungsfall passt eine 5-Minuten-Micro-Batch-Pipeline meistens am besten:

• Sie entspricht dem natürlichen Update-Takt der Telemetrie.
• Sie vereinfacht Feature-Berechnung und Modell-Scoring.
• Sie erhält die Delta-Semantik und erleichtert die Fehlersuche.

Durchgehendes Streaming ist sinnvoll, wenn die Latenz im Sekundenbereich liegen muss, bringt aber zusätzliche Komplexität bei State Management, Exactly-once-Joins und Betriebsaufwand. Für Prognose-Aktualisierungen alle 5 Minuten ist Micro-Batch der richtige Kompromiss.

Zentrale Implementierungsmuster

Verständnis prüfen

Primärquelle

Wie es weitergeht

Jetzt weißt du, wie du die schnelle Spur für 5-Minuten-Updates entwirfst. Bitte deinen Lehrer, die nächste Lektion um Echtzeit-Model-Serving oder Streaming-Feature-State in derselben Energiemarkt-Pipeline aufzubauen.

Brauchst du ein Beispiel-Notebook für 5-Minuten-Streaming-Ingestion und -Scoring? Frag mich, dann erstelle ich eines.

Rechtliches: Impressum