Apache Iceberg

Apache Iceberg est un format de table open-source haute performance conçu pour gérer des ensembles de données pétaoctets dans les architectures de lac de données. Contrairement aux formats traditionnels comme Parquet ou ORC qui ne gèrent que le stockage de fichiers, Iceberg fournit une couche de gestion de tables avec des garanties transactionnelles, un suivi de schéma évolutif et des capacités de voyage temporel. Créé à Netflix et devenu projet Apache top-level, il résout les problèmes critiques de cohérence et de performance dans les architectures data modernes.

Fondements d'Apache Iceberg

• Architecture en trois couches : fichiers de données (Parquet/ORC/Avro), fichiers manifestes (listes de fichiers), et métadonnées de table (snapshots, schémas, partitionnement)
• Transactions ACID complètes avec isolation sérialisable, permettant des lectures cohérentes même pendant les écritures concurrentes
• Evolution de schéma sans réécriture : ajout, suppression et renommage de colonnes sans affecter les données existantes
• Partitionnement caché : transformations de partitionnement appliquées automatiquement sans exposer la structure aux requêtes

Avantages stratégiques

• Performance optimale : élagage de partitions et de fichiers basé sur des statistiques détaillées, réduisant drastiquement le volume de données scannées
• Time travel intégré : accès à n'importe quel snapshot historique de la table pour audits, reproductions ou rollbacks
• Compatibilité multi-moteur : fonctionne nativement avec Spark, Flink, Trino, Hive, Presto sans dépendance à un écosystème propriétaire
• Évolutivité des métadonnées : structure optimisée pour gérer des millions de partitions sans dégradation des performances de planification
• Opérations atomiques avancées : MERGE, UPDATE, DELETE effectués de manière transactionnelle sur des tables distribuées

Exemple concret : Architecture de table Iceberg

from pyspark.sql import SparkSession

# Configuration Spark pour Iceberg
spark = SparkSession.builder \
    .appName("IcebergDemo") \
    .config("spark.jars.packages", "org.apache.iceberg:iceberg-spark-runtime-3.3_2.12:1.4.0") \
    .config("spark.sql.extensions", "org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions") \
    .config("spark.sql.catalog.my_catalog", "org.apache.iceberg.spark.SparkCatalog") \
    .config("spark.sql.catalog.my_catalog.type", "hadoop") \
    .config("spark.sql.catalog.my_catalog.warehouse", "s3://my-bucket/warehouse") \
    .getOrCreate()

# Création d'une table Iceberg avec partitionnement caché
spark.sql("""
    CREATE TABLE my_catalog.db.events (
        event_id STRING,
        user_id LONG,
        event_type STRING,
        event_timestamp TIMESTAMP,
        metadata MAP<STRING, STRING>
    )
    USING iceberg
    PARTITIONED BY (days(event_timestamp), event_type)
    TBLPROPERTIES (
        'write.format.default' = 'parquet',
        'write.metadata.compression-codec' = 'gzip'
    )
""")

# Insertion de données
df = spark.read.json("s3://source/events/*.json")
df.writeTo("my_catalog.db.events").append()

# Time travel : lecture de la version d'il y a 2 heures
spark.read \
    .option("as-of-timestamp", "2024-01-15 10:00:00") \
    .table("my_catalog.db.events") \
    .show()

# Opération MERGE atomique
spark.sql("""
    MERGE INTO my_catalog.db.events t
    USING updates s
    ON t.event_id = s.event_id
    WHEN MATCHED THEN UPDATE SET *
    WHEN NOT MATCHED THEN INSERT *
""")

# Evolution de schéma sans downtime
spark.sql("""
    ALTER TABLE my_catalog.db.events
    ADD COLUMN device_type STRING AFTER event_type
""")

Mise en œuvre d'Apache Iceberg

1. Sélection du catalog : choisir entre Hive Metastore, AWS Glue, Nessie ou JDBC selon l'infrastructure existante
2. Configuration du stockage : définir le warehouse sur S3, ADLS, GCS ou HDFS avec les permissions appropriées
3. Intégration moteur de calcul : configurer Spark, Flink ou Trino avec les extensions et connecteurs Iceberg
4. Stratégie de partitionnement : définir les transformations cachées (days, hours, bucket) basées sur les patterns de requête
5. Politique de rétention : configurer les snapshots expiration et cleanup pour optimiser les coûts de stockage
6. Migration progressive : utiliser des procédures de migration pour convertir les tables existantes (Hive, Delta) vers Iceberg
7. Monitoring : mettre en place le suivi des métriques de compaction, snapshot count et table size

Outils et écosystème

• Apache Spark : moteur principal pour les opérations batch et streaming sur tables Iceberg
• Apache Flink : streaming temps-réel avec support natif des écritures Iceberg ACID
• Trino/Presto : requêtage SQL interactif haute performance sur lacs de données Iceberg
• Nessie : catalog Git-like offrant branches, tags et versioning pour tables Iceberg
• AWS Glue/Azure Purview : catalogs managés avec support Iceberg pour métadonnées centralisées
• dbt : transformations SQL avec support matérialisation incrémentale sur Iceberg
• Tableau/Looker : visualisation et BI directement sur tables Iceberg via connecteurs JDBC/ODBC

Apache Iceberg représente une évolution majeure dans l'architecture des lacs de données, apportant des garanties de type base de données à l'échelle du cloud storage. Sa capacité à offrir transactions ACID, time travel et evolution de schéma sans compromettre les performances en fait le choix privilégié pour les architectures data modernes nécessitant fiabilité et flexibilité. En unifiant les workloads batch et streaming sous un format standardisé et vendor-neutral, Iceberg réduit la complexité opérationnelle tout en améliorant la gouvernance des données et l'efficacité des coûts d'infrastructure.