Apache Spark 4.2 vs Databricks 2026: Arsitektur, Performa, dan Pertanyaan Interview

Apache Spark 4.2 dan Databricks mewakili dua pendekatan berbeda dalam pemrosesan data terdistribusi di tahun 2026. Spark menawarkan fleksibilitas maksimal sebagai framework open-source, sementara Databricks membungkus Spark dalam platform lakehouse terkelola dengan peningkatan proprietary. Memahami perbedaan antara kedua opsi ini sangat penting untuk persiapan interview data engineering dan pengambilan keputusan arsitektur.

Apache Spark 4.2: Fitur Baru dan Arsitektur

Apache Spark 4.2, dirilis pada 14 Juli 2026, memperkenalkan beberapa fitur yang mengubah cara pipeline data beroperasi. Penambahan paling signifikan menargetkan change data capture, integrasi AI, dan workload streaming.

Auto CDC dan Klausa CHANGES

Spark 4.2 menjadikan change data capture sebagai fitur native di dalam engine. Sebelumnya, melacak perubahan data memerlukan solusi khusus yang melibatkan timestamp, perbandingan hash, atau tool CDC eksternal. Fitur Auto CDC yang baru menangani ini secara otomatis.

-- changes-query.sql
-- Query perubahan pada tabel Delta sejak versi 10
SELECT * FROM orders CHANGES SINCE VERSION 10;

-- Lacak perubahan dalam rentang waktu tertentu
SELECT * FROM customers 
CHANGES BETWEEN TIMESTAMP '2026-07-01' AND TIMESTAMP '2026-07-15';

Klausa CHANGES mengembalikan baris dengan kolom metadata yang menunjukkan apakah setiap baris diinsert, diupdate, atau dihapus. Ini menghilangkan kebutuhan untuk memelihara infrastruktur CDC terpisah untuk sebagian besar kasus penggunaan.

Metric Views: Semantic Layer Native

Metric Views membuat definisi bisnis yang terkelola langsung di Spark SQL. Tim mendefinisikan metrik sekali, memastikan kalkulasi yang konsisten di seluruh dashboard, laporan, dan aplikasi AI.

-- metric-views.sql
-- Definisikan metric view untuk kalkulasi revenue
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);

-- Query metric view
SELECT * FROM monthly_revenue WHERE month >= '2026-01-01';

Metric Views menegakkan konsistensi kalkulasi. Ketika tim finance melakukan query monthly_revenue, mereka mendapatkan angka yang sama dengan tim data science yang membangun model ML.

Real-Time Mode untuk PySpark

Spark 4.2 memperkenalkan Real-Time Mode, menyederhanakan workflow streaming di PySpark. Pengumuman Databricks menyoroti bagaimana ini mengurangi beban operasional dari manajemen checkpoint dan recovery dari kegagalan.

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

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

# Aktifkan Real-Time Mode untuk streaming yang disederhanakan
orders_stream = spark.readStream \
    .format("kafka") \
    .option("kafka.bootstrap.servers", "kafka:9092") \
    .option("subscribe", "orders") \
    .option("realtimeMode", "true") \
    .load()

# Agregasi order dalam window 5 menit
aggregated = orders_stream \
    .withWatermark("event_time", "10 minutes") \
    .groupBy(window(col("event_time"), "5 minutes"), col("region")) \
    .agg({"amount": "sum", "order_id": "count"})

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

Real-Time Mode menangani manajemen checkpoint secara internal, mengurangi kode boilerplate dan kompleksitas operasional untuk aplikasi streaming.

Arsitektur Platform Databricks di 2026

Databricks memperluas Spark dengan fitur proprietary yang memenuhi kebutuhan enterprise. Platform ini menggabungkan Delta Lake, Unity Catalog, Mosaic AI, dan engine OLTP Lakebase baru ke dalam lakehouse terintegrasi.

Unity Catalog: Governance Terpusat

Unity Catalog menyediakan kontrol akses granular di seluruh aset data. Keamanan tingkat kolom, filter baris, dan masking data diterapkan secara konsisten di seluruh query SQL, notebook, dan job training ML.

-- unity-catalog-policies.sql
-- Berikan akses baca ke kolom tertentu
GRANT SELECT (customer_id, order_date, product_id) 
ON TABLE sales.orders 
TO `analyst-team`;

-- Buat policy keamanan tingkat baris
CREATE ROW FILTER policy_regional_access 
ON sales.orders 
AS (region STRING) -> region = current_user_region();

-- Terapkan filter
ALTER TABLE sales.orders SET ROW FILTER policy_regional_access ON (region);

Dengan Spark yang dikelola sendiri, fungsionalitas setara memerlukan integrasi dengan Apache Ranger untuk kontrol akses, Apache Atlas untuk metadata, dan solusi khusus untuk pelacakan lineage.

Ekonomi Serverless Compute

Databricks serverless SQL menghilangkan biaya idle cluster. Menurut analisis harga Flexera, SQL Serverless berharga $0.70 per DBU di AWS Premium, tetapi untuk workload BI yang bursty, total biaya sering kali 20-35% di bawah SQL Pro karena jam idle menghilang.

| Tipe Compute | Tarif DBU (AWS Premium) | Terbaik Untuk | |--------------|------------------------|---------------| | Jobs Classic | $0.15 | Batch ETL, pemrosesan overnight | | Jobs Serverless | $0.28 | Workload variabel, jadwal tidak terprediksi | | SQL Pro | $0.55 | Query BI berkelanjutan, pola terprediksi | | SQL Serverless | $0.70 | Query bursty, dashboard on-demand | | Model Serving | $0.08 | Endpoint inferensi ML |

Trade-off-nya langsung: serverless memerlukan premium DBU 20-40% versus compute classic, tetapi menghilangkan biaya spin-up cluster dan idle yang dapat mendominasi total pengeluaran untuk workload variabel.

Perbandingan Arsitektur untuk Persiapan Interview

Interview data engineering sering mengeksplorasi trade-off antara Spark yang dikelola sendiri dan platform terkelola seperti Databricks. Perbandingan berikut mencakup topik interview yang paling umum.

Manajemen Cluster dan Scaling

Spark yang dikelola sendiri memerlukan konfigurasi cluster eksplisit. Tim memilih tipe instance, mengkonfigurasi policy autoscaling, dan mengelola interupsi spot instance.

# 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 mengabstraksi sebagian besar kompleksitas ini. Cluster policy menegakkan standar organisasi, dan instance yang dioptimalkan photon secara otomatis memilih konfigurasi yang sesuai.

Data Lineage dan Observability

Databricks Unity Catalog melacak lineage secara otomatis di seluruh tabel, notebook, dan model ML. Setiap operasi baca dan tulis membuat jejak yang dapat diaudit.

Dengan Spark yang dikelola sendiri, pelacakan lineage memerlukan tooling tambahan. Pendekatan umum termasuk integrasi dengan Apache Atlas atau membangun solusi khusus menggunakan Spark listener.

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

class LineageListener:
    def __init__(self, spark: SparkSession):
        self.spark = spark
        
    def track_read(self, table_name: str, query_id: str):
        # Log operasi baca ke lineage store
        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):
        # Log operasi tulis dengan jumlah baris yang terpengaruh
        lineage_record = {
            "operation": "write",
            "table": table_name,
            "query_id": query_id,
            "rows_affected": row_count,
            "timestamp": datetime.now().isoformat()
        }
        self._persist_lineage(lineage_record)

Opsi Storage Layer

Kedua pendekatan mendukung format tabel terbuka. Delta Lake berasal dari Databricks tetapi sepenuhnya open source. Apache Iceberg menyediakan alternatif dengan dukungan komunitas yang kuat.

| Fitur | Delta Lake | Apache Iceberg | |-------|------------|----------------| | Transaksi ACID | Ya | Ya | | Time Travel | Ya | Ya | | Evolusi Schema | Ya | Ya | | Evolusi Partisi | Terbatas | Penuh | | Hidden Partitioning | Tidak | Ya | | Integrasi Utama | Databricks | Multiple engine |

Untuk analisis lebih mendalam tentang format ini, lihat perbandingan Delta Lake vs Apache Iceberg.

Pertanyaan Interview Umum

Pertanyaan-pertanyaan berikut sering muncul dalam interview data engineering. Setiap pertanyaan mencakup konteks yang dicari interviewer dan kerangka respons terstruktur.

Pertanyaan 1: Kapan sebaiknya memilih Spark yang dikelola sendiri daripada Databricks?

Yang dinilai interviewer: Kesadaran biaya, kematangan operasional, dan pemahaman tentang kendala organisasi.

Kerangka respons yang kuat:

• Prediktabilitas biaya: Spark yang dikelola sendiri menghilangkan biaya per-DBU. Untuk organisasi dengan workload yang konsisten dan terprediksi yang berjalan 24/7, pengeluaran modal pada reserved instance sering kali lebih murah daripada pricing berbasis konsumsi.
• Kedaulatan data: Beberapa industri mengharuskan data tetap on-premises atau di yurisdiksi tertentu. Deployment yang dikelola sendiri pada infrastruktur dedicated memenuhi persyaratan ini.
• Keahlian yang ada: Tim dengan kemampuan operasi Kubernetes dan Spark yang kuat mungkin lebih memilih fleksibilitas deployment yang dikelola sendiri.
• Workload multi-engine: Organisasi yang menggunakan Spark bersama Presto, Flink, atau engine kustom mendapat manfaat dari manajemen cluster terpadu melalui YARN atau Kubernetes.

Pertanyaan 2: Bagaimana Databricks mengoptimalkan performa Spark?

Yang dinilai interviewer: Pemahaman tentang Delta Engine, Photon, dan optimisasi khusus platform.

Poin-poin kunci yang harus dibahas:

• Photon: Engine eksekusi vectorized native C++ yang menggantikan engine Spark SQL berbasis JVM untuk operasi yang didukung. Memberikan speedup 2-8x untuk workload yang heavy scan dan agregasi.
• Delta Cache: Layer caching berbasis SSD yang mempercepat pembacaan berulang dari cloud storage.
• Adaptive Query Execution: Versi enhanced dari AQE Spark dengan optimisasi tambahan untuk penanganan data skew dan pemilihan strategi join.
• Optimisasi IO: Optimisasi layout data otomatis, termasuk Z-ordering dan file compaction.

Pertanyaan 3: Jelaskan trade-off dari serverless compute

Yang dinilai interviewer: Keterampilan pemodelan biaya dan pemahaman tentang karakteristik workload.

# cost_comparison.py
def estimate_monthly_cost(workload_type: str, daily_dbus: float, hours_active: float):
    """Bandingkan biaya serverless vs classic compute."""
    
    # Tarif DBU (tier AWS Premium)
    rates = {
        "sql_classic": 0.55,
        "sql_serverless": 0.70,
        "jobs_classic": 0.15,
        "jobs_serverless": 0.28
    }
    
    # Cluster classic menimbulkan biaya idle
    cluster_hours_per_day = 10  # Cluster berjalan 10 jam untuk 4 jam kerja aktual
    serverless_hours = hours_active  # Hanya bayar untuk compute aktual
    
    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 cocok untuk workload bursty dan tidak terprediksi. Classic compute menang untuk pemrosesan yang berkelanjutan dan terprediksi di mana cluster berjalan mendekati kapasitas.

Pertanyaan 4: Bagaimana Auto CDC Spark 4.2 dibandingkan dengan tool CDC tradisional?

Yang dinilai interviewer: Pemahaman tentang pola change data capture dan trade-off operasional.

Poin perbandingan:

Rilis Apache Spark 4.2 menyematkan CDC ke dalam query engine:

| Aspek | Spark 4.2 Auto CDC | Debezium/Kafka | CDC Timestamp Kustom | |-------|-------------------|----------------|---------------------| | Kompleksitas Setup | Rendah | Tinggi | Sedang | | Latensi Real-time | Menit | Detik | Menit hingga jam | | Beban Database Sumber | Tidak ada | Pembacaan log | Berbasis query | | Query Historis | Built-in | Memerlukan retention | Terbatas | | Evolusi Schema | Otomatis | Perlu konfigurasi | Manual |

Auto CDC unggul untuk workload analitik di mana latensi tingkat menit dapat diterima. Untuk persyaratan sub-detik, Debezium dengan Kafka tetap menjadi pendekatan standar.

Kerangka Keputusan Praktis

Gunakan kerangka ini saat mengevaluasi Spark vs Databricks untuk organisasi atau proyek tertentu.

Pilih Spark yang Dikelola Sendiri Ketika:

• Tim memiliki keahlian Spark dan Kubernetes yang sudah ada
• Workload terprediksi dan berjalan terus-menerus
• Data harus tetap on-premises atau di region tertentu
• Organisasi sudah mengoperasikan infrastruktur platform data
• Sensitivitas biaya melebihi kenyamanan operasional

Pilih Databricks Ketika:

• Time-to-production lebih penting daripada biaya per-query
• Tim tidak memiliki keahlian operasi Spark yang mendalam
• Persyaratan governance dan compliance menuntut jejak audit
• Workflow ML membutuhkan experiment tracking dan model serving terintegrasi
• Workload BI mendapat manfaat dari serverless scaling

Untuk persiapan interview tentang orkestrasi pipeline Apache Airflow dan pola ETL, modul pertanyaan SharpSkill menyediakan latihan terstruktur.

Kesimpulan

• Apache Spark 4.2 menghadirkan Auto CDC, Metric Views, dan Real-Time Mode sebagai fitur native, mengurangi kebutuhan akan tooling eksternal
• Databricks menambahkan governance Unity Catalog, akselerasi Photon, dan serverless compute di atas fondasi Spark
• Spark yang dikelola sendiri menawarkan biaya lebih rendah untuk workload terprediksi dan fleksibilitas arsitektur maksimal
• Databricks mengurangi beban operasional dan mempercepat time-to-production untuk tim tanpa keahlian Spark yang mendalam
• Kesuksesan interview memerlukan pemahaman baik perbedaan teknis maupun trade-off bisnis yang mendorong pemilihan platform
• Pilihan yang tepat bergantung pada kemampuan tim, model biaya, persyaratan compliance, dan karakteristik workload