Iceberg, Delta Lake e Hudi: Scegliere un Table Format per il Data Lake
Un data lake, nella sua forma più semplice, è una cartella di file Parquet su object storage. Funziona sorprendentemente bene e per molto tempo. Poi arriva il giorno in cui un job si interrompe a metà scrittura e lascia file parziali, qualcuno rinomina una colonna e tutti i lettori a valle si rompono, e una query deve elencare decine di migliaia di oggetti prima di leggere un singolo byte utile. A quel punto i file non bastano più: serve un table format.
Questo articolo mette a confronto i tre formati più diffusi — Apache Iceberg, Delta Lake e Apache Hudi — partendo da cosa risolvono davvero e da come scegliere senza farsi guidare dalla moda.
Il problema: i file non raccontano una storia
Un lago di Parquet organizzato a mano in cartelle (anno=2025/mese=01/) ha alcuni difetti strutturali:
- Nessuna transazione. Se un job muore a metà, restano file scritti a metà. Il lettore non ha modo di sapere che quella partizione è incompleta.
- Schema implicito. Lo schema vive nei lettori, non nei dati. Aggiungere, rinominare o cambiare il tipo di una colonna è un'operazione rischiosa e coordinata a mano.
- Elenco dei file costoso. Senza metadati, per pianificare una query bisogna listare gli oggetti e aprirne gli header. Su storage a oggetti le LIST possono essere la voce di costo dominante.
- Nessun rollback. Se pubblichi dati sbagliati, l'unica via è riscrivere.
- Concorrenza assente. Due scrittori sulla stessa tabella si pestano i piedi.
Un table format non cambia il formato dei dati: i file restano Parquet aperti leggibili da chiunque. Aggiunge piuttosto un livello di metadati che descrive quali file compongono la tabella in un certo istante.
Cosa aggiunge un table format
Le funzionalità che ritrovi in tutti e tre i formati sono più o meno queste:
- ACID sulle tabelle, con scritture atomiche e letture consistenti grazie a snapshot isolation.
- Time travel: leggere la tabella com'era a una certa data o a un certo snapshot.
- Schema evolution: aggiungere colonne, cambiarne l'ordine o il tipo senza riscrivere i file storici.
- Pruning con statistiche: min/max, conteggio dei null e altre metriche per file e per colonna, così il motore salta i file che non possono contenere righe rilevanti.
- Compaction: un processo che ricompatta i file piccoli in file più grandi.
- Manutenzione controllata: rimozione degli snapshot vecchi, pulizia dei file orfani.
Il punto chiave: i dati restano tuoi e in formato aperto, il formato è un contratto su come leggerli.
I tre contendenti
Apache Iceberg
Nato in Netflix, oggi sotto Apache Software Foundation. È il formato con la specifica più aperta e la governance più indipendente, e questo si vede nell'ampiezza del supporto: Spark, Trino, Flink, Presto, DuckDB e diversi warehouse cloud lo leggono o lo scrivono.
I punti di forza più interessanti nella pratica sono due:
- Partizionamento nascosto. Dichiari la trasformazione (
days(data_ordine),bucket(16, cliente_id)) e il motore la applica da solo. Chi scrive query non deve conoscere lo schema fisico, e soprattutto non può sbagliare i filtri sulla partizione. - Partition evolution. Puoi cambiare il partizionamento di una tabella esistente senza riscriverla: i vecchi file restano col vecchio schema di partizione, i nuovi seguono il nuovo.
Iceberg separa nettamente il catalogo (chi tiene il puntatore allo snapshot corrente) dal formato: puoi usare Hive Metastore, un REST catalog, AWS Glue, Nessie o un catalogo JDBC. Questa separazione è comoda, ma è anche una delle cose che confonde di più chi inizia.
Delta Lake
Nato in Databricks, poi donato alla Linux Foundation. Il suo cuore è il transaction log: una cartella _delta_log con file JSON che elencano le operazioni, più checkpoint periodici in Parquet per non rileggere tutta la storia.
Il vantaggio è la semplicità concettuale e l'integrazione strettissima con Spark e Databricks. Se il tuo stack è già lì, Delta è la scelta a costo zero di attrito. Il time travel è immediato:
-- Illustrativo: la sintassi esatta dipende dal motore
SELECT * FROM vendite VERSION AS OF 12;
SELECT * FROM vendite TIMESTAMP AS OF '2025-01-31';
Da qualche tempo Delta supporta anche UniForm, che permette di scrivere in Delta e far leggere gli stessi dati come Iceberg o Hudi, utile per non chiudersi in un ecosistema.
Apache Hudi
Nato in Uber, è il formato con l'anima più transazionale e streaming-oriented. Nasce per un problema specifico: applicare upsert e delete continui su un lake, riga per riga, senza riscrivere intere partizioni.
Per farlo usa un indice a livello di record e supporta due modalità di tabella:
- Copy-on-write: a ogni scrittura riscrive i file coinvolti. Letture veloci, scritture più pesanti.
- Merge-on-read: scrive piccoli file di delta e li fonde in lettura. Scritture veloci, letture che pagano un prezzo.
La feature più caratteristica sono le incremental query: puoi chiedere solo i record cambiati dopo un certo istante. È l'ideale per propagare cambiamenti a valle senza rileggere tutto.
Confronto rapido
| Formato | Nato per | Punto di forza | Dove brilla | Nota |
|---|---|---|---|---|
| Iceberg | Analisi su più motori | Spec aperta, partizionamento nascosto, partition evolution | Stack eterogenei: Spark, Trino, Flink, DuckDB | Supporto ampio e in crescita |
| Delta Lake | Spark e Databricks | Transaction log semplice, ottima integrazione | Chi vive già in Spark/Databricks | UniForm per compatibilità |
| Hudi | Upsert e streaming | Indice record-level, query incrementali | CDC massivo verso il lake | Copy-on-write o merge-on-read |
I concetti che contano davvero
Al di là del marchio, ci sono quattro o cinque cose che determinano se il progetto funzionerà.
Snapshot e time travel
Ogni scrittura crea uno snapshot immutabile. Questo ti dà due cose: letture consistenti anche mentre qualcuno scrive, e la possibilità di rispondere a domande tipo "cosa vedeva la dashboard ieri mattina?". È anche uno strumento di debug formidabile: puoi confrontare due snapshot e capire quale job ha introdotto l'anomalia.
Schema evolution
Aggiungere una colonna nullable è l'operazione più comune e deve essere gratuita. Cambiare il tipo di una colonna è più delicato: i formati gestiscono i casi sicuri (int verso long, per esempio) e rifiutano quelli ambigui. Il consiglio è trattare il cambio di schema come un evento da registrare, non come un dettaglio.
Partizionamento nascosto
Partizionare troppo finemente è l'errore numero uno. Se partizioni per giorno e per ora su una tabella che produce pochi megabyte al giorno, ottieni milioni di file minuscoli e query più lente di prima. Il partizionamento va scelto in base a come filtri, non a come immagini i dati.
Small files e compaction
Ogni micro-batch di streaming crea file. Dopo qualche settimana hai migliaia di file da pochi kilobyte, e il tempo di pianificazione della query esplode. La compaction non è opzionale: va messa in calendario come un job, con soglie misurate.
Il catalogo
Spesso è il vero punto dolente. Il catalogo risponde alla domanda "qual è lo snapshot corrente di questa tabella?" ed è il collo di bottiglia quando più motori scrivono. Se prevedi scritture concorrenti da strumenti diversi, verifica prima che il catalogo che hai scelto le supporti.
Un esempio di pipeline
Uno schema ricorrente in ambito retail e operativo:
- Il gestionale produce cambiamenti, esposti via CDC.
- I cambiamenti finiscono come Parquet in una zona di landing.
- Un job applica un merge sulla tabella principale (Hudi o Delta sono particolarmente comodi qui).
- Un motore di query (Trino, Spark, DuckDB) legge la tabella per analisi e dashboard.
- Job di manutenzione: compaction, scadenza snapshot, controllo delle statistiche.
Il punto 5 è quello che nessuno pianifica e che fa la differenza dopo sei mesi.
Come scegliere
Le domande utili, in ordine:
- Quali motori leggono e scrivono? Un solo motore (Spark) semplifica tutto. Tre o quattro motori eterogenei spingono verso Iceberg.
- Il carico è batch o continuo? Upsert frequenti riga per riga e query incrementali sono terreno di Hudi.
- Dove gira già il resto? Se sei su Databricks, Delta è la strada con meno attrito. Non sottovalutare il costo di remare contro lo stack esistente.
- Chi gestisce il catalogo? È la decisione più vincolante e la più sottovalutata.
- Quali competenze hai in casa? Un formato leggermente meno adatto ma che il team conosce batte un formato perfetto che nessuno sa mantenere.
Vale la pena ricordare che la scelta non è irreversibile — esistono strumenti di conversione e formati di compatibilità — ma è costosa. Meglio decidere una volta, con criterio.
Errori comuni
- Partizionare in base all'intuito invece che ai pattern di filtro reali.
- Dimenticare la compaction fino a quando le query non rallentano.
- Trattare il catalogo come un dettaglio implementativo.
- Non misurare mai quanti file vengono effettivamente saltati dal pruning: è la metrica che dice se il partizionamento funziona.
- Migrare al table format "perché lo usano tutti" senza un problema concreto da risolvere.
Conclusione
I punti chiave:
- Un table format aggiunge metadati, transazioni, time travel e schema evolution sopra file Parquet che restano aperti.
- Iceberg è la scelta più neutrale e con il supporto più ampio tra motori diversi; brilla per partizionamento nascosto e partition evolution.
- Delta Lake è la scelta naturale dentro l'ecosistema Spark e Databricks, con UniForm come ponte verso gli altri formati.
- Hudi è pensato per upsert continui e query incrementali, quindi per carichi CDC e streaming verso il lake.
- Le decisioni che contano sul lungo periodo sono tre: partizionamento, compaction e catalogo.
- La domanda giusta non è quale formato sia il migliore in assoluto, ma quale si adatta ai motori, ai pattern di query e alle competenze che hai già in casa.
Foto di copertina di Scott Rodgerson su Unsplash.