
Le choix entre Iceberg et Parquet part souvent d’une question pratique : des fichiers suffisent-ils pour votre jeu de données, ou les lecteurs ont-ils besoin d’un état de table géré à travers ces fichiers ? Apache Parquet est un format de fichier colonnaire. Apache Iceberg est un format de table qui peut utiliser Parquet pour ses fichiers de données. Un même système peut employer les deux.
La différence devient utile lorsque les données changent. Lire un fichier renseigne sur son contenu. Lire une table Iceberg fait aussi intervenir des métadonnées qui identifient l’état demandé. Ce guide illustre cette distinction avec un catalogue local, deux snapshots validés et un fichier Parquet volontairement non enregistré dans la table.
| Couche | Ce qu’elle apporte | Le choix à faire |
|---|---|---|
| Fichier de données Parquet | Des données en colonnes et les métadonnées nécessaires pour interpréter le fichier. | Un format pris en charge et une configuration d’écriture. |
| Table Iceberg | Des métadonnées de table, des schémas, des snapshots et des références aux fichiers appartenant à un état. | Une version du format compatible avec les lecteurs et les outils d’écriture. |
| Catalogue | Un moyen de retrouver les tables par leur nom et de coordonner leurs mises à jour de métadonnées. | Une implémentation et un responsable de son exploitation. |
| Stockage et traitement | Un emplacement pour les fichiers et un logiciel pour les lire ou les écrire. | Un stockage, un moteur de traitement et les ressources de calcul nécessaires. |
Parquet possède ses propres métadonnées, notamment celles qui permettent de localiser les données des colonnes. Le qualifier de format de fichier ne signifie pas qu’il s’agit d’un bloc non structuré. La documentation du format Parquet décrit cette organisation ; la présentation du projet explique sa conception colonnaire.
Iceberg ajoute une description au niveau de la table. Sa spécification définit les snapshots et les métadonnées qui suivent leur contenu. Dans l’exemple en version 2 ci-dessous, les métadonnées du snapshot conduisent aux fichiers de données par des listes de manifestes et des manifestes. Les fichiers de données sont au format Parquet. Le catalogue localise les métadonnées courantes de la table ; il reste distinct du stockage des fichiers.
Commencez par l’organisation la plus simple qui répond au besoin. Un export figé, un petit jeu de données analytique ou un pipeline unique qui produit des lots complets et immuables peut fonctionner avec des fichiers Parquet. Il faut tout de même définir comment sélectionner les bons fichiers et savoir qu’un lot est prêt.
Envisagez une couche de table si les consommateurs ont besoin d’un état courant commun, de versions historiques explicites ou de changements coordonnés sur un jeu de données croissant. Qui valide chaque changement ? Comment les lecteurs sélectionnent-ils une version ? Que se passe-t-il si une écriture s’arrête en cours de route ? Si la réponse repose sur une accumulation de listes de fichiers et de scripts de coordination maison, examinez ce qu’un format de table et un catalogue pourraient remplacer.
Les changements de schéma et de partitionnement comptent aussi. Iceberg les présente dans son guide sur l’évolution des tables. Vérifiez les opérations effectivement prises en charge par le moteur, la bibliothèque, le catalogue et la version du format. L’exemple teste l’ajout de données et leur lecture, sans migration de schéma ni écriture distribuée.
L’exemple utilise PyIceberg, PyArrow et un catalogue SQL reposant sur SQLite. Toutes les données restent dans un nouveau dossier local. Le guide de démarrage PyIceberg présente ce type d’installation pour une démonstration et précise qu’il ne convient pas tel quel à la production. Aucun compte cloud ni serveur de catalogue séparé n’est nécessaire.
Créez un dossier de travail et installez les versions utilisées pour cet article. Les commandes emploient Windows PowerShell :
python -m venv .venv
.venv/Scripts/python.exe -m pip install "pyiceberg[sql-sqlite]==0.12.0" pyarrow==26.0.1 sqlalchemy==2.1.9
Enregistrez le code suivant dans iceberg_example.py. Chaque exécution crée un dossier au nom unique et refuse d’en réutiliser un existant. Le premier lot contient les identifiants 1 et 2 avec 3 et 5 unités ; le second ajoute l’identifiant 3 avec deux unités. Le code reste identique à la version anglaise testée.
import json
from pathlib import Path
from uuid import uuid4
import pyarrow as pa
import pyarrow.parquet as pq
from pyarrow.fs import FileSystem
from pyiceberg.catalog import load_catalog
from sqlalchemy.engine import URL
def open_catalog(root):
return load_catalog(
'local_demo', type='sql',
uri=URL.create('sqlite', database=str(root / 'catalog.db')).render_as_string(),
warehouse=(root / 'warehouse').as_posix(),
**{'py-io-impl': 'pyiceberg.io.pyarrow.PyArrowFileIO'},
)
def summarize(data):
rows = sorted(data.to_pylist(), key=lambda row: row['id'])
return {'ids': [row['id'] for row in rows],
'rows': len(rows), 'units': sum(row['units'] for row in rows)}
def members(table, snapshot_id):
return sorted(task.file.file_path
for task in table.scan(snapshot_id=snapshot_id).plan_files())
def run_example(root):
root = Path(root).resolve()
root.mkdir() # Refuse to overwrite an existing directory.
(root / 'warehouse').mkdir()
catalog = open_catalog(root)
catalog.create_namespace('demo')
schema = pa.schema([pa.field('id', pa.int64()), pa.field('units', pa.int64())])
table = catalog.create_table('demo.orders', schema=schema,
properties={'format-version': '2'})
table.append(pa.table({'id': [1, 2], 'units': [3, 5]}, schema=schema))
first = table.current_snapshot().snapshot_id
first_files = members(table, first)
table.append(pa.table({'id': [3], 'units': [2]}, schema=schema))
second = table.current_snapshot().snapshot_id
second_files = members(table, second)
current = summarize(table.scan().to_arrow())
earlier = summarize(table.scan(snapshot_id=first).to_arrow())
reopened = open_catalog(root).load_table('demo.orders')
# Deliberately place an unregistered file beside committed data files.
# This demonstrates why listing Parquet files is not an Iceberg scan.
_, local_path = FileSystem.from_uri(second_files[0])
data_dir = Path(local_path).parent
loose = data_dir / 'unregistered.parquet'
pq.write_table(pa.table({'id': [999], 'units': [99]}, schema=schema), loose)
raw_files = sorted(data_dir.glob('*.parquet'))
raw = summarize(pa.concat_tables([pq.ParquetFile(p).read() for p in raw_files]))
after_loose = summarize(reopened.scan().to_arrow())
report = {
'root': str(root), 'table_format_version': table.metadata.format_version,
'first_snapshot': first, 'second_snapshot': second,
'second_parent': table.current_snapshot().parent_snapshot_id,
'snapshot_count': len(table.snapshots()),
'first_files': first_files, 'second_files': second_files,
'current': current, 'earlier': earlier,
'reopened_snapshot': reopened.current_snapshot().snapshot_id,
'reopened': summarize(reopened.scan().to_arrow()),
'unregistered_file': loose.as_posix(), 'raw_directory': raw,
'after_unregistered_file': after_loose,
'committed_files_after': members(reopened, second),
'raw_parquet_files': len(raw_files),
'data_formats': sorted({str(t.file.file_format)
for t in table.scan().plan_files()}),
}
(root / 'report.json').write_text(json.dumps(report, indent=2), encoding='utf-8')
catalog.engine.dispose()
reopened.catalog.engine.dispose()
return report
if __name__ == '__main__':
result = run_example(Path.cwd() / ('iceberg-demo-' + uuid4().hex[:8]))
print(json.dumps(result, indent=2))
Exécutez-le depuis le dossier de travail :
.venv/Scripts/python.exe iceberg_example.py
Le script affiche un rapport et l’enregistre dans le nouveau dossier iceberg-demo-.... Conservez ce dossier pendant l’examen du résultat : il contient la base du catalogue, les métadonnées de table et les fichiers de données. Le script ne supprime pas son jeu de test et ne touche à aucun jeu de données existant.
Le premier ajout crée un snapshot de deux lignes. Le second en crée un nouveau avec trois lignes. table.scan() lit l’état courant, tandis que table.scan(snapshot_id=first) demande l’état antérieur. Les identifiants de snapshot sont générés et changent donc d’une exécution à l’autre.
Dans le test, le second snapshot a réutilisé le premier fichier Parquet et en a ajouté un autre. Il n’a pas nécessité une seconde copie complète des lignes initiales. La réouverture du catalogue a conservé le snapshot courant, et un processus Python distinct a pu lire les deux versions. La référence de l’API PyIceberg documente le chargement des tables, les écritures, l’inspection et les lectures.
| Lecture effectuée | Identifiants | Lignes | Total des unités |
|---|---|---|---|
| Premier snapshot après les deux ajouts | 1, 2 | 2 | 8 |
| Snapshot courant | 1, 2, 3 | 3 | 10 |
| Lecture brute du dossier après ajout du fichier isolé | 1, 2, 3, 999 | 4 | 109 |
| Lecture Iceberg après ajout du fichier isolé | 1, 2, 3 | 3 | 10 |
Les deux dernières lignes montrent la différence déterminante. Le script écrit volontairement unregistered.parquet à côté des fichiers validés. Une lecture brute de tous les fichiers Parquet du dossier inclut l’identifiant 999. La lecture Iceberg l’exclut, car ce fichier n’a jamais été ajouté à la table par une opération validée. Un nom de fichier et son emplacement ne suffisent pas à établir son appartenance à la table.
Cette démonstration artificielle et contrôlée ne recommande pas de déposer des fichiers isolés dans le dossier d’une vraie table. Elle montre pourquoi un lecteur Iceberg doit suivre les métadonnées au lieu de les remplacer par une recherche de fichiers. La comparaison brute utilise le lecteur ParquetFile de PyArrow, volontairement sans connaissance de la table.
Vérifications du 17 novembre 2026 : 18 contrôles ont réussi sous Windows avec Python 3.12.14. Ils portent sur la filiation des snapshots, les valeurs exactes, les fichiers référencés, la réouverture du catalogue et les lectures dans un nouveau processus. Le test utilise la version 2 du format Iceberg. Il ne couvre aucun stockage objet distant, écriture concurrente, reprise après panne, expiration de snapshot ou mesure de performances.
Les métadonnées permettent de décrire des versions ; leur exploitation demande toujours une responsabilité claire. Définissez le service qui écrit les tables, les personnes autorisées à modifier le catalogue, l’authentification des lecteurs et la sauvegarde cohérente du catalogue et des fichiers. Une lecture locale réussie ne répond pas à ces questions d’exploitation.
Les lectures historiques dépendent aussi de la conservation. L’expiration d’un snapshot le retire de l’historique accessible. Le nettoyage doit préserver les fichiers nécessaires aux snapshots conservés, et la suppression des fichiers orphelins doit tenir compte des écritures encore en cours. La documentation de maintenance Iceberg couvre l’expiration, les fichiers orphelins et la compaction. Utilisez les procédures prises en charge par votre installation au lieu de supprimer un fichier parce que son nom semble ancien.
Alignez les règles de cycle de vie du stockage sur cette politique. Une règle de bucket qui supprime un objet encore référencé peut casser les lectures même si le catalogue fonctionne. Testez la conservation et la récupération sur des données représentatives avant de les généraliser. L’exemple conserve son petit jeu de test et ne démontre pas le nettoyage.
Cette comparaison ne désigne pas non plus un vainqueur universel en vitesse. Les deux parcours peuvent lire des données Parquet. La planification, la taille des fichiers, les filtres, le partitionnement, le réseau et les capacités du moteur influencent le travail réalisé. Mesurez vos requêtes et vos mises à jour réelles, en tenant compte de la maintenance des métadonnées et de la compaction des petits fichiers.
Un bucket héberge les fichiers. Il ne fournit pas à lui seul un catalogue Iceberg ni le logiciel qui exécute les requêtes. Avant de déplacer l’exemple vers un stockage objet, vérifiez l’association moteur-catalogue, le point d’accès, les identifiants, les opérations objet nécessaires et les fonctions de table prises en charge. La référence de configuration PyIceberg distingue les réglages du catalogue et ceux des entrées-sorties de fichiers.
Hivenet Object Storage est une option à évaluer pour les fichiers de données et les métadonnées via son interface compatible S3. Précisez le moteur, le catalogue, les versions des bibliothèques et les opérations de lecture et d’écriture prévues. Validez cette combinaison avant de déplacer une table de production. Ce test local ne démontre ni l’interopérabilité avec Hivenet ni l’existence d’un service Iceberg géré.
Pour les traitements exploités par votre équipe, Compute avec Hivenet, page en anglais propose une option d’infrastructure CPU distincte. Dimensionnez-la selon la mémoire mesurée, la durée des requêtes et les travaux simultanés. Partez du comportement de table attendu, puis choisissez et testez les composants nécessaires.
Choisissez une charge de travail d’IA, de calcul ou de stockage à tester sur Hivenet, ou échangez avec notre équipe sur sa mise en production.