# Apache Beam vs Spark 2026: Pipeline Unificate e Domande per Colloqui

> Confronto tra Apache Beam 2.76 e Spark 4.2 per pipeline di dati. Portabilità, performance, domande da colloquio e criteri decisionali per Data Engineer.

- Published: 2026-09-10
- Updated: 2026-09-10
- Author: Anthony Fillion-Maillet
- Reading time: 5 min

---

Apache Beam vs Spark rappresenta una delle scelte architetturali più comuni nel data engineering moderno. Beam 2.76 (agosto 2026) e Spark 4.2 (luglio 2026) gestiscono entrambi workload batch e streaming, ma le loro filosofie di progettazione differiscono fondamentalmente: Beam astrae il motore di esecuzione, mentre Spark fornisce un runtime strettamente integrato.

> **Framework Decisionale Rapido**
>
> Scegliere Beam quando la portabilità tra runner (Dataflow, Flink, Spark) è importante o quando si utilizza Google Cloud Dataflow. Scegliere Spark quando si gestisce un cluster autogestito, si usa Databricks o si necessita dell'integrazione ML con MLlib.

## Modello di Portabilità di Beam vs Engine Unificata di Spark

Apache Beam separa il modello di programmazione dall'esecuzione. Una singola definizione di pipeline funziona su [Google Cloud Dataflow](https://cloud.google.com/dataflow), Apache Flink, Apache Spark o altri runner senza modifiche al codice. Questa astrazione deriva dal Beam SDK che genera una rappresentazione portabile della pipeline che qualsiasi runner compatibile interpreta.

Spark 4.2 adotta l'approccio opposto. La DataFrame API, Structured Streaming e MLlib condividono lo stesso Catalyst optimizer e Tungsten execution engine. Questo stretto accoppiamento consente ottimizzazioni come [Adaptive Query Execution](https://spark.apache.org/docs/latest/sql-performance-tuning.html) che adattano i piani in runtime basandosi sulle statistiche effettive dei dati.

```python
# beam_pipeline.py
import apache_beam as beam
from apache_beam.options.pipeline_options import PipelineOptions

# Same code runs on Dataflow, Flink, or Spark runner
options = PipelineOptions([
    '--runner=DataflowRunner',  # Switch to FlinkRunner or SparkRunner
    '--project=my-project',
    '--region=us-central1',
    '--temp_location=gs://my-bucket/temp'
])

with beam.Pipeline(options=options) as pipeline:
    (pipeline
     | 'ReadEvents' >> beam.io.ReadFromPubSub(topic='projects/p/topics/events')
     | 'ParseJSON' >> beam.Map(lambda x: json.loads(x))
     | 'FilterValid' >> beam.Filter(lambda e: e.get('status') == 'valid')
     | 'WindowByMinute' >> beam.WindowInto(beam.window.FixedWindows(60))
     | 'CountPerWindow' >> beam.combiners.Count.Globally()
     | 'WriteToBQ' >> beam.io.WriteToBigQuery('project:dataset.table'))
```

L'equivalente Spark si lega direttamente al runtime Spark:

```python
# spark_streaming.py
from pyspark.sql import SparkSession
from pyspark.sql.functions import from_json, col, window

spark = SparkSession.builder \
    .appName("EventProcessing") \
    .config("spark.sql.adaptive.enabled", "true") \
    .getOrCreate()

# Spark 4.2: ANSI mode enabled by default, stricter type checking
events = spark.readStream \
    .format("kafka") \
    .option("kafka.bootstrap.servers", "broker:9092") \
    .option("subscribe", "events") \
    .load()

processed = events \
    .select(from_json(col("value").cast("string"), schema).alias("data")) \
    .filter(col("data.status") == "valid") \
    .groupBy(window(col("data.timestamp"), "1 minute")) \
    .count()

processed.writeStream \
    .format("bigquery") \
    .option("table", "project.dataset.table") \
    .outputMode("append") \
    .start()
```

La portabilità di Beam consente architetture cloud-agnostiche ma aggiunge uno strato di traduzione. L'esecuzione diretta di Spark mostra tipicamente latenza inferiore per operazioni equivalenti sullo stesso hardware.

## Windowing ed Elaborazione Event-Time a Confronto

Entrambi i framework gestiscono la semantica event-time, ma le loro API riflettono eredità differenti. Il modello di windowing di Beam deriva dal [Dataflow Model paper](https://research.google/pubs/pub43864/) (2015), trattando le window come elementi di pipeline di prima classe. Spark ha adattato il suo windowing per Structured Streaming, integrandolo con la DataFrame API.

| Funzionalità | Beam 2.76 | Spark 4.2 |
|---------|-----------|----------|
| Fixed windows | `FixedWindows(duration)` | `window(col, duration)` |
| Sliding windows | `SlidingWindows(size, period)` | `window(col, size, period)` |
| Session windows | `Sessions(gap)` | Non nativo (usare `flatMapGroupsWithState`) |
| Custom windows | Sottoclasse `WindowFn` | Limitato |
| Late data handling | Trigger integrati | Ritardi watermark |
| Allowed lateness | Configurazione per-window | Watermark globale |

Le session windows rivelano la differenza più chiaramente. Beam tratta le sessioni come strategia di windowing nativa:

```python
# beam_sessions.py
from apache_beam import window

# 30-minute session gap, allow 1 hour late data
windowed = (
    events
    | 'SessionWindow' >> beam.WindowInto(
        window.Sessions(30 * 60),  # 30 min gap closes session
        trigger=beam.trigger.AfterWatermark(
            early=beam.trigger.AfterProcessingTime(60),
            late=beam.trigger.AfterCount(1)
        ),
        allowed_lateness=3600,  # Accept data up to 1 hour late
        accumulation_mode=beam.trigger.AccumulationMode.ACCUMULATING
    )
)
```

Spark richiede elaborazione stateful per le sessioni:

```python
# spark_sessions.py
from pyspark.sql.streaming import GroupState, GroupStateTimeout

def update_session(key, events, state: GroupState):
    # Manual session management with state API
    session_data = state.getOption() or {"count": 0, "start": None, "end": None}
    
    for event in events:
        ts = event.timestamp
        if session_data["end"] and (ts - session_data["end"]).seconds > 1800:
            # Gap exceeded 30 min, emit previous session
            yield session_data
            session_data = {"count": 0, "start": ts, "end": ts}
        
        session_data["count"] += 1
        session_data["end"] = ts
        if not session_data["start"]:
            session_data["start"] = ts
    
    state.update(session_data)
    state.setTimeoutDuration(30 * 60 * 1000)  # 30 min timeout

# Spark 4.2 Arbitrary State API v2
result = events \
    .groupByKey(lambda e: e.user_id) \
    .flatMapGroupsWithState(
        update_session,
        outputMode="append",
        stateType=session_schema,
        timeoutConf=GroupStateTimeout.ProcessingTimeTimeout
    )
```

Per la preparazione ai colloqui su questi argomenti, consultare il modulo [domande per colloqui Apache Beam e Dataflow](/technologies/data-engineering/interview-questions/apache-beam-dataflow).

## Performance: Dati Benchmark del 2026

I confronti diretti richiedono una configurazione accurata poiché Beam può funzionare su Spark come opzione runner. Il confronto rilevante è Beam-su-Dataflow vs Spark nativo.

I benchmark recenti di Databricks e Google Cloud mostrano:

| Workload | Spark 4.2 (Databricks) | Beam 2.76 (Dataflow) | Note |
|----------|------------------------|---------------------|-------|
| Batch ETL (1TB Parquet) | 4,2 min | 5,1 min | Vantaggio Photon engine di Spark |
| Streaming (100K eventi/sec) | 45ms latenza p99 | 120ms latenza p99 | Overhead autoscaling Dataflow |
| Scritture sink exactly-once | Nativo | Nativo | Entrambi supportano dal 2024 |
| Costo (workload sostenuto) | $0,12/GB elaborato | $0,08/GB elaborato | Pricing Dataflow Flex |

I miglioramenti delle performance di Spark 4.2 derivano da diverse funzionalità:
- **Modalità ANSI di default**: semantica SQL più rigorosa rileva errori prima
- **Tipo dato VARIANT**: gestione nativa di dati semi-strutturati
- **Adaptive Query Execution**: ottimizzazione del piano a runtime
- **Supporto Java 21**: i virtual thread riducono l'overhead

Beam 2.76 risponde con:
- **Supporto runner Flink 2.0**: streaming stateful production-ready
- **CDC offset persistence**: DebeziumIO FileSystemOffsetRetainer
- **Integrazione ADK**: supporto Google Agent Development Kit nel Python SDK

## Domande Comuni nei Colloqui: Beam vs Spark

I colloqui tecnici per ruoli di data engineering confrontano frequentemente questi framework. Ecco le domande che appaiono nei colloqui del 2026, con la profondità di risposta attesa.

**Q1: Quando scegliere Beam rispetto a Spark nativo?**

Punti di risposta attesi:
- Deployment multi-cloud o ibridi dove il codice della pipeline deve funzionare senza modifiche
- Ambienti Google Cloud dove Dataflow fornisce infrastruttura gestita
- Semantica event-time complessa che richiede session windows o trigger personalizzati
- Team con esperienza Beam esistente da background Dataflow

Risposta red flag: "Beam è sempre migliore perché è portabile." La portabilità ha costi di overhead.

**Q2: Come influisce l'astrazione runner di Beam sul debugging?**

Punti di risposta attesi:
- Gli stack trace referenziano sia il Beam SDK che l'implementazione del runner
- Le ottimizzazioni specifiche del runner possono comportarsi diversamente (checkpoint Flink vs checkpoint Spark)
- La Metrics API fornisce monitoring unificato, ma le dashboard dei runner mostrano dettagli diversi
- Testing con DirectRunner prima del deployment sul runner di produzione

**Q3: Spiegare la semantica exactly-once in entrambi i framework.**

Risposta attesa:

```python
# Beam: exactly-once via runner guarantees
# Dataflow provides exactly-once for both sources and sinks
# The SDK handles deduplication and checkpoint coordination

with beam.Pipeline() as p:
    (p
     | beam.io.ReadFromPubSub(subscription='...')  # Exactly-once read
     | beam.Map(process)
     | beam.io.WriteToBigQuery(...)  # Exactly-once write with retries
    )

# Spark: exactly-once via checkpointing and idempotent sinks
spark.readStream \
    .format("kafka") \
    .load() \
    .writeStream \
    .option("checkpointLocation", "/checkpoint")  # State recovery
    .foreachBatch(idempotent_write)  # Application-level deduplication
    .start()
```

Per ulteriori argomenti da colloquio sullo streaming, consultare il [modulo PySpark](/technologies/data-engineering/interview-questions/pyspark).

**Q4: Come si migrerebbe un job batch Spark a Beam?**

Questa domanda testa la comprensione di entrambe le API. Punti chiave:

1. Mappare le operazioni DataFrame a PCollections e transform
2. Sostituire `spark.read` con i connettori Beam I/O appropriati
3. Convertire le UDF in funzioni `beam.Map` o `beam.ParDo`
4. Gestire il partizionamento diversamente (`Reshuffle` di Beam vs `repartition` di Spark)
5. Testare con DirectRunner prima del deployment sul runner di produzione

## Scegliere lo Strumento Giusto: Matrice Decisionale

La scelta dipende più dal contesto organizzativo che dalle capacità tecniche. Entrambi i framework gestiscono competentemente la maggior parte dei workload di data engineering.

| Fattore | Favorisce Beam | Favorisce Spark |
|--------|-------------|-------------|
| Cloud provider | Google Cloud | AWS EMR, Databricks, on-prem |
| Esperienza team | Esperienza Dataflow esistente | Competenze Spark/PySpark esistenti |
| Integrazione ML | Limitata (strumenti separati) | MLlib, Spark ML |
| Analisi interattiva | Non progettato per questo | Spark SQL, notebook |
| Session windows | Supporto nativo | Gestione stato manuale |
| Modello costi | Pay-per-use (Dataflow) | Provisioning cluster |
| Vendor lock-in | Minore (più runner) | Maggiore (codice specifico Spark) |

Per le [decisioni sui pattern ETL/ELT](/technologies/data-engineering/interview-questions/etl-elt-patterns), considerare il volume dei dati e i requisiti di latenza prima di selezionare un framework.

## Architettura Reale: Approccio Ibrido

Molte organizzazioni utilizzano entrambi i framework. Un pattern comune:

```
[Streaming Ingestion]     [Batch Processing]     [ML Training]
        |                        |                    |
   Beam/Dataflow           Spark on Databricks    Spark MLlib
        |                        |                    |
        v                        v                    v
    BigQuery  <----- dbt -----> Delta Lake -----> Model Registry
```

Beam gestisce lo streaming ingestion dove l'autoscaling di Dataflow corrisponde ai pattern di traffico. Spark elabora i workload batch dove l'economia dei cluster favorisce il calcolo sostenuto. Entrambi alimentano un data warehouse unificato.

Questa architettura appare nel [tutorial Apache Spark](/blog/data-engineering/apache-spark-pyspark-data-pipelines-tutorial) con dettagli implementativi.

## Punti Chiave per la Scelta Beam vs Spark

- Beam 2.76 fornisce portabilità tra runner su Dataflow, Flink 2.0 e Spark, scambiando performance per flessibilità di deployment
- Spark 4.2 offre un'integrazione più stretta tra workload SQL, streaming e ML con funzionalità come tipi VARIANT e Adaptive Query Execution
- Session windows e trigger complessi favoriscono il modello di windowing nativo di Beam
- Le performance batch su hardware equivalente tipicamente favoriscono Spark grazie all'ottimizzazione Catalyst/Tungsten
- Le domande da colloquio si concentrano sui trade-off piuttosto che dichiarare un framework superiore
- Le architetture ibride che usano entrambi i framework sono comuni negli ambienti di produzione
- Il confronto dei costi dipende dai pattern di workload: pricing per-GB di Dataflow vs provisioning cluster Spark

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/it/blog/data-engineering/apache-beam-vs-spark-2026-unified-pipelines-interview-questions