Apache Spark 4.2 vs Databricks 2026: Architektur, Performance und Interview-Fragen

Apache Spark 4.2 und Databricks repräsentieren zwei unterschiedliche Wege zur verteilten Datenverarbeitung im Jahr 2026. Spark bietet maximale Flexibilität als Open-Source-Framework, während Databricks Spark in eine vollständig verwaltete Lakehouse-Plattform mit proprietären Erweiterungen einbettet. Das Verständnis der Unterschiede zwischen diesen Optionen ist entscheidend für Data-Engineering-Interviews und architektonische Entscheidungen.

Apache Spark 4.2: Neue Funktionen und Architektur

Apache Spark 4.2, veröffentlicht am 14. Juli 2026, führt mehrere Funktionen ein, die die Arbeitsweise von Datenpipelines verändern. Die wichtigsten Neuerungen betreffen Change Data Capture, KI-Integration und Streaming-Workloads.

Auto CDC und die CHANGES-Klausel

Spark 4.2 macht Change Data Capture zu einer nativen Funktion der Engine. Bisher erforderte das Tracking von Datenänderungen individuelle Lösungen mit Zeitstempeln, Hash-Vergleichen oder externen CDC-Tools. Die neue Auto-CDC-Funktion übernimmt dies automatisch.

-- changes-query.sql
-- Abfrage von Änderungen einer Delta-Tabelle seit Version 10
SELECT * FROM orders CHANGES SINCE VERSION 10;

-- Änderungen innerhalb eines Zeitfensters verfolgen
SELECT * FROM customers 
CHANGES BETWEEN TIMESTAMP '2026-07-01' AND TIMESTAMP '2026-07-15';

Die CHANGES-Klausel gibt Zeilen mit Metadaten-Spalten zurück, die angeben, ob jede Zeile eingefügt, aktualisiert oder gelöscht wurde. Dies eliminiert die Notwendigkeit einer separaten CDC-Infrastruktur für die meisten Anwendungsfälle.

Metric Views: Native Semantische Schicht

Metric Views erstellen gouvernierte Geschäftsdefinitionen direkt in Spark SQL. Teams definieren Metriken einmal und gewährleisten konsistente Berechnungen über Dashboards, Berichte und KI-Anwendungen hinweg.

-- metric-views.sql
-- Definition einer Metric View für Umsatzberechnungen
CREATE METRIC VIEW monthly_revenue AS
SELECT 
    DATE_TRUNC('month', order_date) AS month,
    SUM(amount) AS total_revenue,
    COUNT(DISTINCT customer_id) AS unique_customers,
    SUM(amount) / COUNT(DISTINCT customer_id) AS revenue_per_customer
FROM orders
WHERE status = 'completed'
GROUP BY DATE_TRUNC('month', order_date);

-- Abfrage der Metric View
SELECT * FROM monthly_revenue WHERE month >= '2026-01-01';

Metric Views erzwingen Berechnungskonsistenz. Wenn das Finanzteam monthly_revenue abfragt, erhält es dieselben Zahlen wie das Data-Science-Team beim Erstellen von ML-Modellen.

Real-Time Mode für PySpark

Spark 4.2 führt den Real-Time Mode ein, der Streaming-Workflows in PySpark vereinfacht. Die Databricks-Ankündigung hebt hervor, wie dies den operativen Aufwand für Checkpoint-Management und Fehlerwiederherstellung reduziert.

# streaming_pipeline.py
from pyspark.sql import SparkSession
from pyspark.sql.functions import col, window

spark = SparkSession.builder.appName("RealTimeOrders").getOrCreate()

# Real-Time Mode für vereinfachtes Streaming aktivieren
orders_stream = spark.readStream \
    .format("kafka") \
    .option("kafka.bootstrap.servers", "kafka:9092") \
    .option("subscribe", "orders") \
    .option("realtimeMode", "true") \
    .load()

# Bestellungen in 5-Minuten-Fenstern aggregieren
aggregated = orders_stream \
    .withWatermark("event_time", "10 minutes") \
    .groupBy(window(col("event_time"), "5 minutes"), col("region")) \
    .agg({"amount": "sum", "order_id": "count"})

# In Delta Lake schreiben
aggregated.writeStream \
    .format("delta") \
    .outputMode("append") \
    .option("checkpointLocation", "/checkpoints/orders") \
    .toTable("order_aggregates")

Der Real-Time Mode verwaltet Checkpoints intern und reduziert Boilerplate-Code sowie die operative Komplexität für Streaming-Anwendungen.

Databricks-Plattformarchitektur 2026

Databricks erweitert Spark um proprietäre Funktionen, die Enterprise-Anforderungen adressieren. Die Plattform kombiniert Delta Lake, Unity Catalog, Mosaic AI und die neue Lakebase OLTP-Engine zu einem integrierten Lakehouse.

Unity Catalog: Zentralisierte Governance

Unity Catalog bietet feingranulare Zugriffskontrollen für alle Datenressourcen. Spaltenbasierte Sicherheit, Zeilenfilter und Datenmaskierung gelten konsistent für SQL-Abfragen, Notebooks und ML-Training-Jobs.

-- unity-catalog-policies.sql
-- Lesezugriff auf bestimmte Spalten gewähren
GRANT SELECT (customer_id, order_date, product_id) 
ON TABLE sales.orders 
TO `analyst-team`;

-- Row-Level-Security-Policy erstellen
CREATE ROW FILTER policy_regional_access 
ON sales.orders 
AS (region STRING) -> region = current_user_region();

-- Filter anwenden
ALTER TABLE sales.orders SET ROW FILTER policy_regional_access ON (region);

Bei selbstverwaltetem Spark erfordert äquivalente Funktionalität die Integration von Apache Ranger für Zugriffskontrolle, Apache Atlas für Metadaten und individuelle Lösungen für Lineage-Tracking.

Serverless Compute Wirtschaftlichkeit

Databricks Serverless SQL eliminiert Cluster-Leerlaufkosten. Laut Flexeras Preisanalyse kostet SQL Serverless 0,70 USD pro DBU auf AWS Premium, aber bei unregelmäßigen BI-Workloads liegen die Gesamtkosten oft 20-35% unter SQL Pro, da Leerlaufstunden entfallen.

| Compute-Typ | DBU-Rate (AWS Premium) | Geeignet für | |-------------|------------------------|---------------| | Jobs Classic | 0,15 USD | Batch-ETL, nächtliche Verarbeitung | | Jobs Serverless | 0,28 USD | Variable Workloads, unvorhersehbare Zeitpläne | | SQL Pro | 0,55 USD | Kontinuierliche BI-Abfragen, vorhersehbare Muster | | SQL Serverless | 0,70 USD | Unregelmäßige Abfragen, On-Demand-Dashboards | | Model Serving | 0,08 USD | ML-Inferenz-Endpunkte |

Der Trade-off ist eindeutig: Serverless hat einen 20-40% höheren DBU-Preis gegenüber Classic Compute, eliminiert aber die Cluster-Startzeit und Leerlaufkosten, die bei variablen Workloads die Gesamtausgaben dominieren können.

Architekturvergleich für die Interview-Vorbereitung

Data-Engineering-Interviews behandeln häufig die Trade-offs zwischen selbstverwaltetem Spark und verwalteten Plattformen wie Databricks. Der folgende Vergleich deckt die häufigsten Interview-Themen ab.

Cluster-Management und Skalierung

Selbstverwaltetes Spark erfordert explizite Cluster-Konfiguration. Teams wählen Instanztypen, konfigurieren Autoscaling-Richtlinien und verwalten Spot-Instance-Unterbrechungen.

# spark_cluster_config.py
from pyspark import SparkConf

conf = SparkConf() \
    .setAppName("ProductionETL") \
    .set("spark.executor.instances", "10") \
    .set("spark.executor.cores", "4") \
    .set("spark.executor.memory", "16g") \
    .set("spark.dynamicAllocation.enabled", "true") \
    .set("spark.dynamicAllocation.minExecutors", "2") \
    .set("spark.dynamicAllocation.maxExecutors", "50") \
    .set("spark.shuffle.service.enabled", "true")

Databricks abstrahiert einen Großteil dieser Komplexität. Cluster-Policies setzen organisatorische Standards durch, und Photon-optimierte Instanzen wählen automatisch geeignete Konfigurationen.

Data Lineage und Observability

Databricks Unity Catalog verfolgt Lineage automatisch über Tabellen, Notebooks und ML-Modelle hinweg. Jede Lese- und Schreiboperation erstellt einen auditierbaren Pfad.

Bei selbstverwaltetem Spark erfordert Lineage-Tracking zusätzliche Tools. Übliche Ansätze umfassen die Integration mit Apache Atlas oder den Aufbau individueller Lösungen mit Spark Listeners.

# custom_lineage_listener.py
from pyspark import SparkContext
from pyspark.sql import SparkSession

class LineageListener:
    def __init__(self, spark: SparkSession):
        self.spark = spark
        
    def track_read(self, table_name: str, query_id: str):
        # Leseoperation im Lineage-Store protokollieren
        lineage_record = {
            "operation": "read",
            "table": table_name,
            "query_id": query_id,
            "timestamp": datetime.now().isoformat(),
            "user": self.spark.sparkContext.sparkUser()
        }
        self._persist_lineage(lineage_record)
    
    def track_write(self, table_name: str, query_id: str, row_count: int):
        # Schreiboperation mit betroffener Zeilenanzahl protokollieren
        lineage_record = {
            "operation": "write",
            "table": table_name,
            "query_id": query_id,
            "rows_affected": row_count,
            "timestamp": datetime.now().isoformat()
        }
        self._persist_lineage(lineage_record)

Storage-Layer-Optionen

Beide Ansätze unterstützen offene Tabellenformate. Delta Lake stammt von Databricks, ist aber vollständig Open Source. Apache Iceberg bietet eine Alternative mit starker Community-Unterstützung.

| Funktion | Delta Lake | Apache Iceberg | |----------|------------|----------------| | ACID-Transaktionen | Ja | Ja | | Time Travel | Ja | Ja | | Schema-Evolution | Ja | Ja | | Partition-Evolution | Eingeschränkt | Vollständig | | Hidden Partitioning | Nein | Ja | | Primäre Integration | Databricks | Mehrere Engines |

Für eine tiefere Analyse dieser Formate siehe den Delta Lake vs Apache Iceberg Vergleich.

Häufige Interview-Fragen

Die folgenden Fragen erscheinen regelmäßig in Data-Engineering-Interviews. Jede Frage enthält den Kontext, den Interviewer suchen, und strukturierte Antwortrahmen.

Frage 1: Wann würden Sie selbstverwaltetes Spark gegenüber Databricks wählen?

Was Interviewer bewerten: Kostenbewusstsein, operative Reife und Verständnis organisatorischer Einschränkungen.

Starker Antwortrahmen:

• Kostenvorhersagbarkeit: Selbstverwaltetes Spark eliminiert DBU-Gebühren. Für Organisationen mit konsistenten, vorhersehbaren Workloads, die rund um die Uhr laufen, kosten Kapitalausgaben für reservierte Instanzen oft weniger als verbrauchsbasierte Preise.
• Datensouveränität: Einige Branchen erfordern, dass Daten On-Premises oder in bestimmten Jurisdiktionen verbleiben. Selbstverwaltete Deployments auf dedizierter Infrastruktur erfüllen diese Anforderungen.
• Vorhandene Expertise: Teams mit starken Kubernetes- und Spark-Betriebsfähigkeiten bevorzugen möglicherweise die Flexibilität selbstverwalteter Deployments.
• Multi-Engine-Workloads: Organisationen, die Spark neben Presto, Flink oder benutzerdefinierten Engines verwenden, profitieren von einheitlichem Cluster-Management durch YARN oder Kubernetes.

Frage 2: Wie optimiert Databricks die Spark-Performance?

Was Interviewer bewerten: Verständnis der Delta Engine, Photon und plattformspezifischer Optimierungen.

Wichtige Punkte:

• Photon: Native C++ vektorisierte Ausführungs-Engine, die die JVM-basierte Spark-SQL-Engine für unterstützte Operationen ersetzt. Bietet 2-8-fache Beschleunigung für scan- und aggregationslastige Workloads.
• Delta Cache: SSD-basierte Caching-Schicht, die wiederholte Lesevorgänge aus Cloud-Storage beschleunigt.
• Adaptive Query Execution: Erweiterte Version von Sparks AQE mit zusätzlichen Optimierungen für Data-Skew-Handling und Join-Strategie-Auswahl.
• IO-Optimierung: Automatische Datenlayout-Optimierung, einschließlich Z-Ordering und Dateikompaktierung.

Frage 3: Erklären Sie die Trade-offs von Serverless Compute

Was Interviewer bewerten: Kostenmodellierungsfähigkeiten und Verständnis von Workload-Charakteristiken.

# cost_comparison.py
def estimate_monthly_cost(workload_type: str, daily_dbus: float, hours_active: float):
    """Vergleich von Serverless- und Classic-Compute-Kosten."""
    
    # DBU-Raten (AWS Premium Tier)
    rates = {
        "sql_classic": 0.55,
        "sql_serverless": 0.70,
        "jobs_classic": 0.15,
        "jobs_serverless": 0.28
    }
    
    # Classic-Cluster verursachen Leerlaufkosten
    cluster_hours_per_day = 10  # Cluster läuft 10 Stunden für 4 Stunden tatsächliche Arbeit
    serverless_hours = hours_active  # Nur für tatsächliches Compute bezahlen
    
    classic_monthly = daily_dbus * cluster_hours_per_day * rates[f"{workload_type}_classic"] * 30
    serverless_monthly = daily_dbus * serverless_hours * rates[f"{workload_type}_serverless"] * 30
    
    return {
        "classic": classic_monthly,
        "serverless": serverless_monthly,
        "savings_percent": (classic_monthly - serverless_monthly) / classic_monthly * 100
    }

Serverless eignet sich für unregelmäßige, unvorhersehbare Workloads. Classic Compute gewinnt bei kontinuierlicher, vorhersehbarer Verarbeitung, bei der Cluster nahe der Kapazität laufen.

Frage 4: Wie vergleicht sich Spark 4.2s Auto CDC mit traditionellen CDC-Tools?

Was Interviewer bewerten: Verständnis von Change-Data-Capture-Mustern und operativen Trade-offs.

Vergleichspunkte:

Das Apache Spark 4.2 Release integriert CDC in die Query-Engine:

| Aspekt | Spark 4.2 Auto CDC | Debezium/Kafka | Custom Timestamp CDC | |--------|-------------------|----------------|---------------------| | Setup-Komplexität | Niedrig | Hoch | Mittel | | Echtzeit-Latenz | Minuten | Sekunden | Minuten bis Stunden | | Quelldatenbank-Last | Keine | Log-Lesen | Query-basiert | | Historische Abfragen | Eingebaut | Erfordert Retention | Begrenzt | | Schema-Evolution | Automatisch | Konfiguration nötig | Manuell |

Auto CDC eignet sich hervorragend für analytische Workloads, bei denen Latenz auf Minutenebene akzeptabel ist. Für Sub-Sekunden-Anforderungen bleibt Debezium mit Kafka der Standardansatz.

Praktischer Entscheidungsrahmen

Dieser Rahmen hilft bei der Evaluierung von Spark vs Databricks für eine bestimmte Organisation oder ein Projekt.

Wählen Sie selbstverwaltetes Spark wenn:

• Das Team vorhandene Spark- und Kubernetes-Expertise hat
• Workloads vorhersehbar sind und kontinuierlich laufen
• Daten On-Premises oder in bestimmten Regionen bleiben müssen
• Die Organisation bereits Datenplattform-Infrastruktur betreibt
• Kostensensitivität wichtiger ist als operativer Komfort

Wählen Sie Databricks wenn:

• Time-to-Production wichtiger ist als Kosten pro Abfrage
• Dem Team tiefe Spark-Betriebsexpertise fehlt
• Governance- und Compliance-Anforderungen Audit-Trails verlangen
• ML-Workflows integriertes Experiment-Tracking und Model-Serving benötigen
• BI-Workloads von Serverless-Skalierung profitieren

Für die Interview-Vorbereitung zu Apache Airflow Pipeline-Orchestrierung und ETL-Mustern bieten die SharpSkill-Fragenmodule strukturierte Übungen.

Fazit

• Apache Spark 4.2 bringt Auto CDC, Metric Views und Real-Time Mode als native Funktionen und reduziert die Notwendigkeit externer Tools
• Databricks fügt Unity Catalog Governance, Photon-Beschleunigung und Serverless Compute auf der Spark-Grundlage hinzu
• Selbstverwaltetes Spark bietet niedrigere Kosten für vorhersehbare Workloads und maximale architektonische Flexibilität
• Databricks reduziert den operativen Aufwand und beschleunigt die Time-to-Production für Teams ohne tiefe Spark-Expertise
• Interview-Erfolg erfordert das Verständnis sowohl der technischen Unterschiede als auch der geschäftlichen Trade-offs bei der Plattformauswahl
• Die richtige Wahl hängt von Team-Fähigkeiten, Kostenmodell, Compliance-Anforderungen und Workload-Charakteristiken ab