TP2 : Data Lakehouse avec Apache Hive, Hadoop et Apache Iceberg

Troisième TP - De l'Entrepôt de Données au Lakehouse ACID Moderne

By Mariem ZAOUALI

TP2 : Data Lakehouse avec Apache Hive, Hadoop et Apache Iceberg

Objectifs du TP : Au terme de ce laboratoire complet, vous serez capable de :

  • Manipuler l’ensemble des commandes DDL/DML HQL (Hive Query Language) pour administrer, modéliser et requêter des données massives sur HDFS.
  • Comprendre et comparer les formats physiques de stockage (TextFile, Parquet, ORC)
  • Déployer des stratégies de partitionnement (statique, dynamique) et de Bucketing pour accélérer les jointures (Map-side Joins).
  • Orchestrer un pipeline d’ingestion RDBMS vers le Data Lake à l’aide de Sqoop et PostgreSQL.
  • Moderniser l’architecture vers le paradigme Data Lakehouse grâce à la brique Apache Iceberg.
  • Maîtriser les garanties transactionnelles ACID, les Snapshots, le Time Travel, le Rollback, le Partitionnement Caché (Hidden Partitioning) et l’Évolution de Schéma/Partition sans réécriture de données.

Architecture Globale de la Plateforme

La stack technique s’articule autour d’un cluster conteneurisé moderne combinant l’écosystème Hadoop traditionnel et la nouvelle couche Data Lakehouse :

+-----------------------------------------------------------------------------------+
|                                  APPLICATIONS                                     |
|             Beeline CLI  /  HiveServer2 JDBC  /  Spark SQL  /  PgAdmin            |
+-----------------------------------------------------------------------------------+
                                          |
                                          v
+-----------------------------------------------------------------------------------+
|                             MOTEURS DE CALCUL & EXECUTION                         |
|        Apache Hive 4.0.1 (Tez Engine)      |       Apache Spark 3.5.3             |
+-----------------------------------------------------------------------------------+
                                          |
                                          v
+-----------------------------------------------------------------------------------+
|                        COUCHE FORMAT DE TABLE LAKEHOUSE                           |
|                  Apache Iceberg (Format V2 - ACID, Metadata Tree)                 |
+-----------------------------------------------------------------------------------+
                                          |
                                          v
+-----------------------------------------------------------------------------------+
|                                 CATALOGUE & STOCKAGE                              |
|   Hive Metastore (Thrift :9083) + PostgreSQL DB  |   Hadoop HDFS (NameNode:9000)   |
+-----------------------------------------------------------------------------------+

SECTION 1 : MISE AU POINT DE L’ENVIRONNEMENT DOCKER

Le fichier docker-compose.yml :

version: "3.8"

# ============================================================
# NETWORK
# ============================================================

networks:
  net:
    name: bigdata-net
    driver: bridge
    ipam:
      config:
        - subnet: 172.22.0.0/24

# ============================================================
# SERVICES
# ============================================================

services:

  # ==========================================================
  # HADOOP NAMENODE
  # ==========================================================
  namenode:
    image: bde2020/hadoop-namenode:2.0.0-hadoop3.2.1-java8
    container_name: namenode
    hostname: namenode
    restart: always
    ports:
      - "9870:9870"
      - "9000:9000"
    volumes:
      - hadoop_namenode:/hadoop/dfs/name
      - ./hadoop-conf:/opt/hadoop-conf:ro
    environment:
      CLUSTER_NAME: test
      HADOOP_CONF_DIR: /opt/hadoop-conf
      CORE_CONF_fs_defaultFS: "hdfs://namenode:9000"
      HDFS_CONF_dfs_replication: 1
      HDFS_CONF_dfs_permissions_enabled: "false"
    env_file:
      - ./hadoop.env
    healthcheck:
      test: ["CMD-SHELL", "curl -f http://localhost:9870 || exit 1"]
      interval: 15s
      timeout: 5s
      retries: 5
      start_period: 20s
    networks:
      - net

  # ==========================================================
  # HADOOP DATANODE
  # ==========================================================
  datanode:
    image: bde2020/hadoop-datanode:2.0.0-hadoop3.2.1-java8
    container_name: datanode
    hostname: datanode
    restart: always
    depends_on:
      namenode:
        condition: service_started
    ports:
      - "9864:9864"
    volumes:
      - hadoop_datanode:/hadoop/dfs/data
      - ./hadoop-conf:/opt/hadoop-conf:ro
    environment:
      SERVICE_PRECONDITION: "namenode:9870"
      HADOOP_CONF_DIR: /opt/hadoop-conf
      CORE_CONF_fs_defaultFS: "hdfs://namenode:9000"
    env_file:
      - ./hadoop.env
    networks:
      - net

  # ==========================================================
  # HADOOP RESOURCE MANAGER (YARN)
  # ==========================================================
  resourcemanager:
    image: bde2020/hadoop-resourcemanager:2.0.0-hadoop3.2.1-java8
    container_name: resourcemanager
    hostname: resourcemanager
    restart: always
    depends_on:
      - namenode
      - datanode
    ports:
      - "8088:8088"
    environment:
      SERVICE_PRECONDITION: "namenode:9000 namenode:9870 datanode:9864"
    env_file:
      - ./hadoop.env
    networks:
      - net

  # ==========================================================
  # HADOOP NODE MANAGER (YARN)
  # ==========================================================
  nodemanager1:
    image: bde2020/hadoop-nodemanager:2.0.0-hadoop3.2.1-java8
    container_name: nodemanager
    hostname: nodemanager
    restart: always
    depends_on:
      - resourcemanager
    ports:
      - "8042:8042"
    environment:
      SERVICE_PRECONDITION: "namenode:9000 namenode:9870 datanode:9864 resourcemanager:8088"
    env_file:
      - ./hadoop.env
    networks:
      - net

  # ==========================================================
  # HADOOP HISTORY SERVER
  # ==========================================================
  historyserver:
    image: bde2020/hadoop-historyserver:2.0.0-hadoop3.2.1-java8
    container_name: historyserver
    hostname: historyserver
    restart: always
    depends_on:
      - resourcemanager
    ports:
      - "8188:8188"
    volumes:
      - hadoop_historyserver:/hadoop/yarn/timeline
    environment:
      SERVICE_PRECONDITION: "namenode:9000 namenode:9870 datanode:9864 resourcemanager:8088"
    env_file:
      - ./hadoop.env
    networks:
      - net

  # ==========================================================
  # POSTGRESQL - APPLICATION DATABASE (RDBMS / temp_db)
  # ==========================================================
  database:
    image: postgres:14
    container_name: postgres-db
    hostname: database
    restart: always
    environment:
      POSTGRES_DB: temp_db
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: passw0rd
      PGDATA: /var/lib/postgresql/data/pgdata
    volumes:
      - ./data_to_import:/var/lib/postgresql/data/lmwn
      - ./pgdata:/var/lib/postgresql/data
    ports:
      - "5433:5432"
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres -d temp_db"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 10s
    logging:
      options:
        max-size: 10m
        max-file: "3"
    networks:
      - net

  # ==========================================================
  # POSTGRESQL - HIVE METASTORE BACKEND
  # ==========================================================
  hive-metastore-postgresql:
    image: postgres:14
    container_name: hive-metastore-postgresql
    hostname: hive-metastore-postgresql
    restart: always
    environment:
      POSTGRES_DB: metastore
      POSTGRES_USER: hive
      POSTGRES_PASSWORD: hive_password
      PGDATA: /var/lib/postgresql/data/pgdata
    volumes:
      - hive_metastore_data:/var/lib/postgresql/data
    ports:
      - "5434:5432"
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U hive -d metastore"]
      interval: 10s
      timeout: 5s
      retries: 10
      start_period: 15s
    networks:
      - net

  # ==========================================================
  # HIVE 4 - METASTORE SERVICE (AVEC SUPPORT ICEBERG)
  # ==========================================================
  hive-metastore:
    image: apache/hive:4.0.1
    container_name: hive-metastore
    hostname: hive-metastore
    restart: always
    depends_on:
      hive-metastore-postgresql:
        condition: service_healthy
      namenode:
        condition: service_started
    environment:
      SERVICE_NAME: metastore
      DB_DRIVER: postgres
      HIVE_CUSTOM_CONF_DIR: /hive_custom_conf
      HADOOP_CONF_DIR: /opt/hadoop-conf
      SERVICE_OPTS: >-
        -Djavax.jdo.option.ConnectionDriverName=org.postgresql.Driver
        -Djavax.jdo.option.ConnectionURL=jdbc:postgresql://hive-metastore-postgresql:5432/metastore
        -Djavax.jdo.option.ConnectionUserName=hive
        -Djavax.jdo.option.ConnectionPassword=hive_password
        -Dhive.execution.engine=tez
        -Diceberg.engine.hive.enabled=true
    ports:
      - "9083:9083"
    volumes:
      - ./hive-conf:/hive_custom_conf:ro
      - ./hadoop-conf:/opt/hadoop-conf:ro
      - ./postgres-jdbc.jar:/opt/hive/lib/postgres.jar:ro
    healthcheck:
      test: ["CMD-SHELL", "nc -z localhost 9083 || exit 1"]
      interval: 10s
      timeout: 5s
      retries: 15
      start_period: 30s
    networks:
      - net

  # ==========================================================
  # HIVE 4 - HIVESERVER2 & ICEBERG RUNTIME
  # ==========================================================
  hive-server:
    image: apache/hive:4.0.1
    container_name: hive-server
    hostname: hive-server
    restart: always
    depends_on:
      hive-metastore:
        condition: service_healthy
    environment:
      SERVICE_NAME: hiveserver2
      IS_RESUME: "true"
      HIVE_CUSTOM_CONF_DIR: /hive_custom_conf
      HADOOP_CONF_DIR: /opt/hadoop-conf
      SERVICE_OPTS: >-
        -Dhive.metastore.uris=thrift://hive-metastore:9083
        -Djavax.jdo.option.ConnectionDriverName=org.postgresql.Driver
        -Djavax.jdo.option.ConnectionURL=jdbc:postgresql://hive-metastore-postgresql:5432/metastore
        -Djavax.jdo.option.ConnectionUserName=hive
        -Djavax.jdo.option.ConnectionPassword=hive_password
        -Dhive.execution.engine=tez
        -Diceberg.engine.hive.enabled=true
    ports:
      - "10000:10000"
      - "10002:10002"
    volumes:
      - ./hive-conf:/hive_custom_conf:ro
      - ./hadoop-conf:/opt/hadoop-conf:ro
      - ./postgres-jdbc.jar:/opt/hive/lib/postgres.jar:ro
      - ./others/sqoop:/opt/sqoop
      - ./data_to_import:/opt/data_to_import
    networks:
      - net

  # ==========================================================
  # SPARK 3.5 - MASTER (LAKEHOUSE ENGINE AVEC ICEBERG EXTENSIONS)
  # ==========================================================
  spark-master:
    image: apache/spark:3.5.3
    container_name: spark-master
    hostname: spark-master
    restart: always
    depends_on:
      - namenode
      - datanode
      - hive-metastore
    command:
      - /opt/spark/bin/spark-class
      - org.apache.spark.deploy.master.Master
    ports:
      - "8079:8080"
      - "7077:7077"
    environment:
      SPARK_MASTER_HOST: spark-master
      SPARK_CONF_DIR: /opt/spark-conf
      HADOOP_CONF_DIR: /opt/hadoop-conf
      SPARK_SUBMIT_OPTS: >-
        -Dspark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
        -Dspark.sql.catalog.iceberg=org.apache.iceberg.spark.SparkCatalog
        -Dspark.sql.catalog.iceberg.type=hive
        -Dspark.sql.catalog.iceberg.uri=thrift://hive-metastore:9083
        -Dspark.sql.catalog.iceberg.warehouse=hdfs://namenode:9000/user/hive/warehouse
    volumes:
      - ./spark-conf:/opt/spark-conf:ro
      - ./hadoop-conf:/opt/hadoop-conf:ro
      - ./data_to_import:/opt/spark/data
    networks:
      - net

  # ==========================================================
  # SPARK 3.5 - WORKER 1
  # ==========================================================
  spark-worker-1:
    image: apache/spark:3.5.3
    container_name: spark-worker-1
    hostname: spark-worker-1
    restart: always
    depends_on:
      - spark-master
    command:
      - /opt/spark/bin/spark-class
      - org.apache.spark.deploy.worker.Worker
      - spark://spark-master:7077
    ports:
      - "8081:8081"
    environment:
      SPARK_WORKER_WEBUI_PORT: 8081
      SPARK_CONF_DIR: /opt/spark-conf
      HADOOP_CONF_DIR: /opt/hadoop-conf
    volumes:
      - ./spark-conf:/opt/spark-conf:ro
      - ./hadoop-conf:/opt/hadoop-conf:ro
    networks:
      - net

  # ==========================================================
  # SPARK 3.5 - WORKER 2
  # ==========================================================
  spark-worker-2:
    image: apache/spark:3.5.3
    container_name: spark-worker-2
    hostname: spark-worker-2
    restart: always
    depends_on:
      - spark-master
    command:
      - /opt/spark/bin/spark-class
      - org.apache.spark.deploy.worker.Worker
      - spark://spark-master:7077
    ports:
      - "8082:8081"
    environment:
      SPARK_WORKER_WEBUI_PORT: 8081
      SPARK_CONF_DIR: /opt/spark-conf
      HADOOP_CONF_DIR: /opt/hadoop-conf
    volumes:
      - ./spark-conf:/opt/spark-conf:ro
      - ./hadoop-conf:/opt/hadoop-conf:ro
    networks:
      - net

# ============================================================
# PERSISTENT VOLUMES
# ============================================================

volumes:
  hadoop_namenode:
    name: hadoop_namenode
  hadoop_datanode:
    name: hadoop_datanode
  hadoop_historyserver:
    name: hadoop_historyserver
  hive_metastore_data:
    name: hive_metastore_data
  pgdata:
    name: postgres_app_data

Lancement des Conteneurs

Ouvrez un terminal dans le répertoire contenant le fichier docker-compose.yml :

docker compose up -d

Vérifiez que tous les services sont à l’état healthy ou running :

docker compose ps

Connexion au Service HiveServer2

Connectez-vous au conteneur Hive :

docker exec -it hive-server bash

Lancez la console Hive interactive :

hive

(Dans Hive 4, la commande hive invoque automatiquement le client Beeline connecté à HiveServer2). L’invite de commande apparaît :

hive>

Pour quitter à tout moment :

quit;

Diagnostics et résolutions des erreurs fréquentes :

  • NameNode is in Safe Mode : Si HDFS est en mode lecture seule au démarrage, exécutez sur l’hôte ou dans le NameNode :
    docker exec -it namenode hdfs dfsadmin -safemode leave
    
  • Metastore non joignable : Si hive-server démarre avant que PostgreSQL n’ait validé le schéma, vérifiez la santé de hive-metastore :
    docker logs hive-metastore
    

SECTION 2 : FONDAMENTAUX HIVE – FORMATS, TABLES ET STOCKAGE PHYSIQUE

2.1 Row Format et Séparateurs de Champs

Découvrons comment créer une table gérée dont les champs sont délimités par une virgule ,. Au niveau physique sur HDFS, les données brutes contiennent ces séparateurs.

Exécutez dans Hive CLI :

CREATE TABLE jobs (
    id INT, 
    title STRING, 
    salary INT, 
    posted TIMESTAMP
) 
ROW FORMAT DELIMITED 
FIELDS TERMINATED BY ',';

Vérifiez l’existence de la table dans la base default :

SHOW TABLES;

Insérez un premier enregistrement :

INSERT INTO jobs VALUES (1, 'Data Analyst', 135000, '2016-12-21 15:52:03');

Visualisez la ligne insérée :

SELECT * FROM jobs;

Quittez temporairement la console (quit;) et examinez le stockage physique sur HDFS. Le répertoire /user/hive/warehouse est l’emplacement par défaut :

hdfs dfs -ls /user/hive/warehouse
hdfs dfs -ls /user/hive/warehouse/jobs

Affichez le contenu brut du fichier généré :

hdfs dfs -cat /user/hive/warehouse/jobs/000000_0

Observation : Les chaînes et les timestamps ne comportent pas de guillemets dans HDFS. Les champs sont strictement séparés par des virgules : 1,Data Analyst,135000,2016-12-21 15:52:03.

Créez maintenant une table délimitée par une tabulation \t :

CREATE TABLE jobs_tsv (
    id INT, 
    title STRING, 
    salary INT, 
    posted TIMESTAMP
) 
ROW FORMAT DELIMITED 
FIELDS TERMINATED BY '\t';

INSERT INTO jobs_tsv VALUES (1, 'Data Analyst', 135000, '2016-12-21 15:52:03');

En inspectant /user/hive/warehouse/jobs_tsv/000000_0, vous remarquerez le séparateur \t. Le délimiteur tabulation est particulièrement recommandé lorsque les champs textuels métier contiennent naturellement des virgules.


2.2 Tables Internes (Managed) vs Tables Externes (External)

Par défaut, Hive gère à la fois le schéma logique (dans le Metastore) et le cycle de vie des fichiers physiques (sur HDFS). Une table EXTERNAL permet de décorréler le schéma logique des données brutes : la suppression de la table (DROP TABLE) ne supprime que le catalogue, sans détruire les données sur HDFS.

Créez une table externe :

CREATE EXTERNAL TABLE default.investors (
    name STRING, 
    amount INT, 
    share DECIMAL(4,3)
) 
ROW FORMAT DELIMITED 
FIELDS TERMINATED BY ',';

INSERT INTO default.investors (name, amount, share)
VALUES ('Karim Beguir', 10000, 0.325);

SHOW TABLES;

Vérifiez la présence des données dans HDFS :

hdfs dfs -ls /user/hive/warehouse/investors

Supprimez la table externe dans Hive :

DROP TABLE default.investors;

Vérifiez à nouveau le système de fichiers HDFS :

hdfs dfs -ls /user/hive/warehouse/investors

Constat majeur : Le dossier /user/hive/warehouse/investors et ses fichiers de données subsistent intégralement ! Si vous recréez la table avec le même schéma :

CREATE EXTERNAL TABLE default.investors(name STRING, amount INT, share DECIMAL(4,3));
SELECT * FROM investors;

Toutes les lignes réapparaissent instantanément sans réinsertion.


2.3 Formats de Fichiers : TEXTFILE vs PARQUET

Comparons l’impact du format de stockage :

-- Format texte standard
CREATE TABLE jobs_txt (
    id INT, 
    title STRING, 
    salary INT, 
    posted TIMESTAMP
) 
STORED AS TEXTFILE;

INSERT INTO jobs_txt VALUES (1, 'Data Analyst', 135000, '2016-12-21 15:52:03');

-- Format colonnaire Parquet
CREATE TABLE jobs_parquet (
    id INT, 
    title STRING, 
    salary INT, 
    posted TIMESTAMP
) 
STORED AS PARQUET;

INSERT INTO jobs_parquet VALUES (1, 'Data Analyst', 135000, '2016-12-21 15:52:03');

En examinant /user/hive/warehouse/jobs_txt, les fichiers sont lisibles en clair (hdfs dfs -cat ...). En examinant /user/hive/warehouse/jobs_parquet, le fichier est binaire, compressé et organisé par colonnes avec en-têtes et dictionnaires.


2.4 Personnalisation de l’Emplacement (LOCATION)

Il est possible d’assigner un répertoire HDFS arbitraire à une table :

CREATE TABLE jobs_training (
    id INT, 
    title STRING, 
    salary INT, 
    posted TIMESTAMP
) 
LOCATION '/user/training/jobs_training/';

INSERT INTO jobs_training VALUES (1, 'Data Analyst', 135000, '2016-12-21 15:52:03');

Vérifiez sur HDFS :

hdfs dfs -ls /user/training/jobs_training/

2.5 Clonage de Structure : LIKE et IF NOT EXISTS

Pour dupliquer un schéma existant sans copier immédiatement les données :

CREATE TABLE IF NOT EXISTS new_investors LIKE investors;

INSERT INTO new_investors SELECT * FROM investors;

SELECT * FROM new_investors;

2.6 Métadonnées et Altérations de Tables (ALTER)

Inspectez les détails techniques d’une table :

DESCRIBE jobs_txt;
DESCRIBE FORMATTED jobs_txt;

L’attribut table_type affiche MANAGED_TABLE ou EXTERNAL_TABLE.

Modifications avec ALTER :

-- Convertir une table interne en table externe
ALTER TABLE new_investors SET TBLPROPERTIES('EXTERNAL'='TRUE');

-- Renommer une table
ALTER TABLE new_investors RENAME TO companies;

-- Déplacer une table vers une autre base de données
CREATE DATABASE IF NOT EXISTS section;
ALTER TABLE default.companies RENAME TO section.companies;

2.7 Partitionnement Statique et Dynamique

Le partitionnement segmente physiquement les tables sous forme de sous-répertoires HDFS du type colonne=valeur. Cela permet au moteur d’ignorer la lecture de dossiers entiers (Partition Pruning).

A. Téléchargement et Chargement de customers.csv

Téléchargez le fichier customers.csv depuis l’espace de stockage du cours :

https://drive.google.com/drive/folders/1yHi5gPFu_4999GhdemwRD8ux2mllufU8?usp=drive_link

Placez-le dans le conteneur ou copiez-le sur HDFS :

hdfs dfs -put customers.csv /user/hive/warehouse/customers.csv

Créez la table de staging avec exclusion de l’en-tête CSV :

CREATE TABLE IF NOT EXISTS customers (
    id_cust INT,
    name STRING,
    country STRING
)
ROW FORMAT DELIMITED
FIELDS TERMINATED BY ','
TBLPROPERTIES ("skip.header.line.count"="1");

LOAD DATA INPATH '/user/hive/warehouse/customers.csv' INTO TABLE customers;

SELECT * FROM customers LIMIT 10;

B. Partitionnement Dynamique par Pays

Créez la table partitionnée :

CREATE TABLE customers_by_country (
    id_cust INT, 
    name STRING
)
PARTITIONED BY (country STRING)
ROW FORMAT DELIMITED
FIELDS TERMINATED BY ',';

Activez le partitionnement dynamique non strict dans la session Hive :

SET hive.exec.dynamic.partition.mode=nonstrict;

INSERT OVERWRITE TABLE customers_by_country
PARTITION(country)
SELECT id_cust, name, country FROM customers;

Visualisez les partitions créées :

SHOW PARTITIONS customers_by_country;

Vérifiez l’arborescence physique sous HDFS :

hdfs dfs -ls /user/hive/warehouse/customers_by_country

Chaque pays dispose désormais de son propre dossier (ex: country=France/, country=USA/).


2.8 Bucketing et Optimisation Map-Side Join

Le Bucketing (compartimentage) répartit les données en un nombre fixe de fichiers basé sur la fonction de hachage d’une clé (hash(col) % N).

Avantages Majeurs :

  1. Échantillonnage rapide (Sampling) : Exploration d’un échantillon représentatif sans scanner la totalité de la table.
  2. Map-Side Join : Si deux tables jointes sont bucketées sur la même clé avec des multiples compatibles de buckets, la jointure est résolue directement en mémoire côté Mapper (pas de phase Shuffle/Sort, pas de Reducer), ce qui multiplie les performances par 5 à 10.

Création de la table bucketée en 8 fragments :

CREATE TABLE customers_bucketed (
    id_cust INT,
    name STRING,
    country STRING
)
CLUSTERED BY (id_cust) INTO 8 BUCKETS
ROW FORMAT DELIMITED
FIELDS TERMINATED BY ',';

SET hive.enforce.bucketing = true;

INSERT INTO TABLE customers_bucketed
SELECT * FROM customers;

Extraction d’un échantillon (Bucket 3 sur 8) :

SELECT * FROM customers_bucketed TABLESAMPLE(BUCKET 3 OUT OF 8);

Vérifiez la présence exacte de 8 fichiers de données dans HDFS :

hdfs dfs -ls /user/hive/warehouse/customers_bucketed

2.9 Optimisations Avancées : Format ORC, CBO et PPD

Le format ORC (Optimized Row Columnar) combine compression par blocs, index intégrés (min/max par stripe) et dictionnaires.

CREATE TABLE IF NOT EXISTS customers_orc
STORED AS ORC AS
SELECT * FROM customers;

A. Cost-Based Optimizer (CBO)

Le CBO s’appuie sur le moteur Apache Calcite pour construire le plan d’exécution optimal en exploitant la distribution statistique des données :

SET hive.cbo.enable=true;
SET hive.compute.query.using.stats=true;

ANALYZE TABLE customers_orc COMPUTE STATISTICS FOR COLUMNS;

B. Predicate Pushdown (PPD)

Le PPD pousse les prédicats de filtrage (WHERE) directement au niveau du lecteur de stockage ORC. Les blocs dont les statistiques min/max excluent la valeur recherchée sont éliminés avant même toute décompression ou chargement en mémoire.

Activez les propriétés PPD :

SET hive.optimize.ppd = true;
SET hive.optimize.ppd.storage = true;
SET hive.orc.splits.include.file.footer = true;
SET hive.optimize.index.filter = true;

Inspectez le plan d’exécution avec EXPLAIN :

EXPLAIN SELECT * FROM customers_orc WHERE country = 'France';

Vérifiez dans la sortie :

TableScan
  alias: customers_orc
  PushedPredicate: country = 'France'

Le scan physique saute tous les stripes ORC ne contenant aucun client français.


SECTION 3 : PIPELINE D’INGESTION RDBMS -> DATA LAKE (SQOOP & POSTGRESQL)

Dans cette étape, nous simulons une extraction opérationnelle depuis un SGBD relationnel PostgreSQL (temp_db) vers Hive à l’aide de Sqoop.

+------------------------+             Sqoop Import             +-----------------------------+
| PostgreSQL (temp_db)   |  --------------------------------->  | Hive Data Lake              |
| Table: order_detail    |      (JDBC Driver + Mappers YARN)    | lab2_big_data.order_detail  |
+------------------------+                                      +-----------------------------+

1. Préparation de la Base PostgreSQL

Connectez-vous au conteneur PostgreSQL applicatif :

docker exec -it postgres-db psql -U postgres -d temp_db

Créez la table source order_detail :

DROP TABLE IF EXISTS order_detail;

CREATE TABLE IF NOT EXISTS order_detail (
    order_created_timestamp TIMESTAMP,
    status VARCHAR,
    price INT,
    discount FLOAT,
    id VARCHAR PRIMARY KEY NOT NULL,
    driver_id VARCHAR,
    user_id VARCHAR,
    restaurant_id VARCHAR
);

Chargez les données depuis le fichier CSV :

COPY order_detail 
FROM '/var/lib/postgresql/data/lmwn/order_detail.csv' 
DELIMITER ',' CSV HEADER;

SELECT COUNT(*) FROM order_detail;
\q

(Si order_detail.csv se trouve sur votre machine hôte, déposez-le au préalable dans le dossier ./data_to_import/).

2. Création de la Base Hive de Réception

Dans Hive :

CREATE DATABASE IF NOT EXISTS lab2_big_data;

3. Exécution de l’Import Sqoop

Depuis le conteneur hive-server :

docker exec -it hive-server bash

Lancez la commande d’import Sqoop :

/usr/lib/sqoop/bin/sqoop import \
  --connect jdbc:postgresql://database:5432/temp_db \
  --table order_detail \
  --username postgres \
  --password passw0rd \
  --hive-import \
  --hive-table lab2_big_data.order_detail_hive \
  --num-mappers 1 \
  --map-column-hive order_created_timestamp=STRING,status=STRING,price=INT,discount=FLOAT,id=STRING,driver_id=STRING,user_id=STRING,restaurant_id=STRING

Suivez la progression sur l’interface YARN ResourceManager : http://localhost:8088.

4. Ingestion de la Table restaurant_detail

Chargez également la table des restaurants dans lab2_big_data :

CREATE EXTERNAL TABLE IF NOT EXISTS lab2_big_data.restaurant_detail (
    id STRING,
    name STRING,
    address STRING,
    city STRING
)
ROW FORMAT DELIMITED
FIELDS TERMINATED BY ','
STORED AS TEXTFILE
LOCATION '/user/hive/warehouse/lab2_big_data.db/restaurant_detail'
TBLPROPERTIES ("skip.header.line.count"="1");

LOAD DATA INPATH '/user/hive/warehouse/restaurant_detail.csv' 
INTO TABLE lab2_big_data.restaurant_detail;

Vérifiez le succès des imports :

SELECT * FROM lab2_big_data.order_detail_hive LIMIT 5;
SELECT * FROM lab2_big_data.restaurant_detail LIMIT 5;

SECTION 4 : LA BRIQUE APACHE ICEBERG & ARCHITECTURE DATA LAKEHOUSE

Pourquoi moderniser vers Apache Iceberg ? Les tables Hive traditionnelles présentent des limites architecturales majeures en entreprise :

  • Absence de transactions ACID complètes : Risque de lectures corrompues (dirty reads) pendant les écritures concurrentes.
  • Partition Drift : Si une colonne de partition change ou si un développeur oublie la clause de partition dans un filtre, le moteur scanne l’intégralité du Data Lake.
  • Lenteur des métadonnées : Le Metastore Hive doit lister des milliers de répertoires HDFS (listStatus), ce qui sature le NameNode.
  • Impossibilité de versionner : Pas de Time Travel natif, pas de rollback instantané en cas d’erreur d’ingestion.

Apache Iceberg résout ces problématiques en introduisant une couche de format de table ouverte avec un arbre de métadonnées immuable sur le stockage objet/HDFS.


4.0 Vérifications Préalables de l’Environnement

Dans Hive Beeline (docker exec -it hive-server hive) :

-- 1. Vérification de la version Hive 4
SELECT version();

-- 2. Validation des bases et tables du TP2
SHOW DATABASES;
SHOW TABLES IN lab2_big_data;

-- 3. Création de la base dédiée au Lakehouse
CREATE DATABASE IF NOT EXISTS lab3;

-- 4. Test d'une table Iceberg élémentaire
CREATE TABLE lab3.test_ice (
    id INT,
    label STRING
) STORED BY ICEBERG;

INSERT INTO lab3.test_ice VALUES (1, 'ok');

SELECT * FROM lab3.test_ice;

Résultat attendu : Hive 4 apparaît, la table test_ice est créée et la requête retourne (1, 'ok'). Si le DDL échoue : vérifier le classpath Iceberg (iceberg-hive-runtime.jar), l’activation du moteur Tez (set hive.execution.engine=tez;), et la configuration du Metastore.


4.1 Anatomie d’une Table Iceberg : Snapshots et Métadonnées

Créons une table Iceberg version 2 et étudions comment Iceberg trace chaque commit.

CREATE TABLE lab3.jobs_ice (
    id INT, 
    title STRING, 
    salary INT, 
    posted TIMESTAMP
)
STORED BY ICEBERG
TBLPROPERTIES ('format-version'='2');

-- Premier commit (création du premier Snapshot)
INSERT INTO lab3.jobs_ice 
VALUES (1, 'Data Analyst', 135000, '2016-12-21 15:52:03');

-- Deuxième commit (création du second Snapshot)
INSERT INTO lab3.jobs_ice 
VALUES (2, 'Data Engineer', 150000, '2017-03-02 09:10:00');

A. Inspection des Snapshots

Interrogez la table système de métadonnées .snapshots :

SELECT snapshot_id, parent_id, committed_at, operation 
FROM lab3.jobs_ice.snapshots 
ORDER BY committed_at;

Observation : Deux INSERT distincts génèrent deux snapshots consécutifs reliés hiérarchiquement (parent_id). Chaque snapshot représente un état logique complet et figé de la table à un instant T.

B. Inspection Physique : Arbre de Métadonnées sur HDFS

Quittez Hive et inspectez l’organisation du dossier sous HDFS :

hdfs dfs -ls /user/hive/warehouse/lab3.db/jobs_ice
hdfs dfs -ls /user/hive/warehouse/lab3.db/jobs_ice/metadata
hdfs dfs -ls /user/hive/warehouse/lab3.db/jobs_ice/data
Table jobs_ice/
├── data/
│   ├── 00000-0-data-xxx.parquet          <-- Fichier écrit lors du commit 1
│   └── 00001-0-data-yyy.parquet          <-- Fichier écrit lors du commit 2
└── metadata/
    ├── v1.metadata.json                  <-- Schéma initial
    ├── v2.metadata.json                  <-- Pointeur Snapshot 1
    ├── v3.metadata.json                  <-- Pointeur Snapshot 2 (courant)
    ├── snap-12345-1-manifest-list.avro   <-- Liste des manifests du snapshot
    └── manifest-abcde.avro               <-- Fichiers de données et stats min/max

C. Rôles Respectifs des Composants

Composant Rôle Précis Ce qu’il gère
HDFS Stockage physique brut Fichiers Parquet et fichiers de métadonnées Avro/JSON
Hive Metastore Catalogue logique / Pointeur atomique Pointeur vers le fichier de métadonnées courant (v3.metadata.json)
Apache Iceberg Format de table & Gestion d’état Arbre de métadonnées, snapshots, partitions cachées, Field IDs
Hive / Tez Moteur de traitement SQL distribué Analyse de requête, optimisation, exécution des tâches de lecture/écriture

Question de Réflexion (Catalogue Indisponible) : Si le Metastore PostgreSQL devient indisponible, les données sont-elles perdues ? Réponse : Non. Les fichiers de données et l’intégralité de l’historique des snapshots restent intacts sur HDFS. Cependant, les moteurs SQL ne peuvent plus résoudre le nom logique lab3.jobs_ice vers le fichier de métadonnées courant. L’accès opérationnel est suspendu tant que le catalogue n’est pas restauré.


4.2 Migration des Données vers le Lakehouse

2.1 CTAS depuis la Table Texte Brute

Migrons les données de commandes du TP2 vers la table Bronze Iceberg :

SELECT COUNT(*) FROM lab2_big_data.order_detail_hive;

CREATE TABLE lab3.orders_bronze
STORED BY ICEBERG
AS SELECT * FROM lab2_big_data.order_detail_hive;

SELECT COUNT(*) FROM lab3.orders_bronze;

SELECT * FROM lab3.orders_bronze.snapshots;

Mécanisme : Le CTAS lit les données sources brutes et réécrit l’intégralité des données au format optimisé Parquet/Iceberg en créant un premier snapshot. La table source order_detail_hive reste inchangée.

2.2 Conversion In-Place (Sans Réécriture de Données)

Pour une table déjà au format colonnaire (ORC ou Parquet) et non-ACID, Iceberg permet une conversion instantanée sans copier les fichiers :

DESCRIBE FORMATTED lab2_big_data.customers_orc;

-- Conversion en place vers Iceberg via le StorageHandler
ALTER TABLE lab2_big_data.customers_orc 
SET TBLPROPERTIES ('storage_handler'='org.apache.iceberg.mr.hive.HiveIcebergStorageHandler');

DESCRIBE FORMATTED lab2_big_data.customers_orc;

SELECT * FROM lab2_big_data.customers_orc.snapshots;

Point Technique Clé : La conversion in-place n’a déplacé aucun octet de données. Iceberg a simplement scanné les fichiers ORC existants et généré le graphe de métadonnées Avro/JSON correspondant.

2.3 Comparaison : Snapshot / Add Files vs CTAS

Méthode Mécanisme Coût E/S & Réécriture Cas d’Usage Typique
CTAS Lecture source + réécriture complète en Parquet Iceberg Élevé (réécriture 100%) Source CSV/TextFile ou changement de schéma/types
In-place Convert Adoption des fichiers ORC/Parquet existants par métadonnées Nul (zéro réécriture) Tables existantes propres au bon format
Snapshot Procedure Adoption d’un jeu de fichiers externes via Spark/Iceberg API Quasi-nul Migration de répertoires externes volumineux
Add Files Ajout incrémental de fichiers compatibles à une table Iceberg Nul Ingestion batch de micro-lots externes

2.4 Création de restaurants_bronze

CREATE TABLE lab3.restaurants_bronze
STORED BY ICEBERG
AS SELECT * FROM lab2_big_data.restaurant_detail;

SELECT COUNT(*) FROM lab3.restaurants_bronze;

4.3 Architecture Médaillon (Bronze -> Silver -> Gold)

L’architecture Médaillon structure le Lakehouse en niveaux de maturité et de qualité croissants :

Raw CSV / Sqoop           Bronze (Raw Iceberg)          Silver (Cleaned & Partitioned)          Gold (Aggregated Business)
[ order_detail ]  ===>  [ lab3.orders_bronze ]  ===>  [ lab3.orders_silver ]            ===>  [ lab3.orders_gold ]
                         (Données brutes)              (Typage, Déduplication, Hidden Part)   (Chiffre d'affaires par Resto)

3.1 Diagnostic Qualité et Data Profiling sur Bronze

Avant de nettoyer les données, établissons un audit qualité rigoureux de orders_bronze :

-- Diagnostic fin : prix invalides, dates non convertibles, doublons
SELECT 
    COUNT(*) AS total_bronze,
    COUNT(DISTINCT id) AS ids_distincts,
    SUM(CASE WHEN price IS NULL THEN 1 ELSE 0 END) AS prix_nulls,
    SUM(CASE WHEN price <= 0 THEN 1 ELSE 0 END) AS prix_non_positifs,
    SUM(CASE WHEN order_created_timestamp IS NULL THEN 1 ELSE 0 END) AS dates_nulles_source,
    SUM(CASE WHEN order_created_timestamp IS NOT NULL 
             AND CAST(order_created_timestamp AS TIMESTAMP) IS NULL 
             THEN 1 ELSE 0 END) AS dates_non_convertibles
FROM lab3.orders_bronze;

Calculons la réconciliation exacte des lignes éligibles pour Silver :

WITH eligible AS (
    SELECT * 
    FROM lab3.orders_bronze
    WHERE price > 0 
      AND CAST(order_created_timestamp AS TIMESTAMP) IS NOT NULL
),
ranked AS (
    SELECT id, 
           ROW_NUMBER() OVER (
               PARTITION BY id 
               ORDER BY order_created_timestamp ASC
           ) AS rn
    FROM eligible
)
SELECT 
    (SELECT COUNT(*) FROM lab3.orders_bronze) AS total_bronze,
    (SELECT COUNT(*) FROM eligible) AS total_eligible,
    (SELECT COUNT(*) FROM ranked WHERE rn = 1) AS silver_attendu,
    (SELECT COUNT(*) FROM ranked WHERE rn > 1) AS doublons_ecartes;

3.2 Création de la Table Silver avec Partitionnement Caché

Nous appliquons deux transformations de partitionnement avancées :

  1. days(order_ts) : Partitionnement temporel journalier calculé automatiquement.
  2. bucket(8, restaurant_id) : Équilibrage en 8 compartiments pour éviter la dispersion en milliers de petits dossiers.
CREATE TABLE lab3.orders_silver (
    order_ts TIMESTAMP,
    status STRING,
    price INT,
    discount FLOAT,
    id STRING,
    driver_id STRING,
    user_id STRING,
    restaurant_id STRING
)
PARTITIONED BY SPEC (days(order_ts), bucket(8, restaurant_id))
STORED BY ICEBERG
TBLPROPERTIES ('format-version'='2');

3.3 Alimentation et Déduplication (Silver Ingestion)

Nous insérons uniquement les données valides, en dédoublonnant par identifiant de commande grâce à ROW_NUMBER() :

INSERT INTO lab3.orders_silver
SELECT 
    CAST(order_created_timestamp AS TIMESTAMP),
    status, 
    price, 
    discount, 
    id, 
    driver_id, 
    user_id, 
    restaurant_id
FROM (
    SELECT *,
           ROW_NUMBER() OVER (
               PARTITION BY id 
               ORDER BY order_created_timestamp ASC
           ) AS rn
    FROM lab3.orders_bronze
    WHERE price > 0
) t
WHERE rn = 1 
  AND CAST(order_created_timestamp AS TIMESTAMP) IS NOT NULL;

SELECT COUNT(*) FROM lab3.orders_silver;

3.4 Analyse du Partitionnement Caché (Hidden Partitioning)

Qu’apporte le Partitionnement Caché d’Iceberg par rapport à Hive ?

  • Dans Hive standard : L’utilisateur devait créer une colonne artificielle order_date STRING. Les requêtes devaient obligatoirement filtrer sur WHERE order_date = '2024-02-01' pour bénéficier du pruning. Si un analyste écrivait WHERE order_ts >= '2024-02-01', Hive lisait TOUTE la table !
  • Dans Apache Iceberg : La table n’expose pas de colonne redondante. L’utilisateur filtre directement sur sa colonne métier order_ts :
    SELECT * FROM lab3.orders_silver 
    WHERE order_ts BETWEEN '2024-02-01 00:00:00' AND '2024-02-01 23:59:59';
    

    Iceberg calcule la relation mathématique days(order_ts) et élague automatiquement les fichiers non concernés sans aucune intervention de l’utilisateur.

Vérifiez le plan d’exécution :

EXPLAIN SELECT * FROM lab3.orders_silver WHERE order_ts >= '2024-02-01 00:00:00';

3.5 Couche Gold : Agrégation Métier pour Consommation Analytique

Création de la vue matérialisée / table Gold calculant les métriques de performance par restaurant :

CREATE TABLE lab3.orders_gold
STORED BY ICEBERG
AS
SELECT 
    restaurant_id,
    COUNT(*) AS nb_commandes,
    SUM(price) AS montant_total_brut
FROM lab3.orders_silver
GROUP BY restaurant_id;

SELECT * FROM lab3.orders_gold ORDER BY montant_total_brut DESC LIMIT 10;

4.4 Évolution de Schéma et de Partition (Zero-Copy)

Dans un Data Lake traditionnel, renommer une colonne ou changer de partitionnement imposait la réécriture complète de téraoctets de données. Iceberg révolutionne cette maintenance grâce aux Field IDs.

A. Évolution du Schéma (Schema Evolution)

-- 1. Ajout d'une colonne (valeur par défaut NULL pour les lignes historiques)
ALTER TABLE lab3.orders_silver ADD COLUMNS (delivery_zone STRING);

-- 2. Renommage d'une colonne sans altérer les fichiers Parquet
ALTER TABLE lab3.orders_silver CHANGE COLUMN discount discount_rate FLOAT;

-- 3. Élargissement de type sécurisé (INT vers BIGINT)
ALTER TABLE lab3.orders_silver CHANGE COLUMN price price BIGINT;

Vérifiez le nouveau schéma :

DESCRIBE lab3.orders_silver;

Mécanisme des Field IDs : Iceberg attribue à chaque colonne un identifiant entier immuable unique (ex: price -> Field ID 3).

  • Lors d’un renommage (discount vers discount_rate), seul le JSON de métadonnées est modifié : le Field ID reste inchangé. À la lecture, Iceberg fait le lien direct.
  • Si une colonne est supprimée puis recréée avec le même nom, elle reçoit un NOUVEL ID, éliminant tout risque de collision ou de lecture de données zombies.

B. Évolution de la Spécification de Partition (Partition Evolution)

Supposons que le volume de données augmente et que le partitionnement journalier produise trop de petits fichiers. Nous décidons de passer à un partitionnement mensuel :

ALTER TABLE lab3.orders_silver 
SET PARTITION SPEC (months(order_ts), bucket(8, restaurant_id));

Comportement Révolutionnaire : Les anciens fichiers Parquet conservent leur partitionnement par jour. Les nouvelles insertions appliqueront le partitionnement par mois. Iceberg unifie les deux générations de partitions dans un plan de requête unique et transparent !


4.5 Snapshots, Time Travel et Rollback

A. Identification du Snapshot Courant

Listez les snapshots disponibles :

SELECT snapshot_id, committed_at, operation 
FROM lab3.orders_silver.snapshots 
ORDER BY committed_at;

Notez la valeur du snapshot_id initial (noté <S1>).

B. Mutation DML : Suppression de Données

Simulons la purge des commandes livrées :

DELETE FROM lab3.orders_silver WHERE status = 'DELIVERED';

SELECT COUNT(*) FROM lab3.orders_silver;

Le volume de lignes a diminué : un nouveau snapshot <S2> est publié.

C. Time Travel (Voyage dans le Temps)

Interrogeons la table telle qu’elle existait au snapshot <S1> :

-- Remplacez <S1> par l'identifiant numérique noté précédemment
SELECT COUNT(*) 
FROM lab3.orders_silver FOR SYSTEM_VERSION AS OF <S1>;

Le décompte initial réapparaît instantanément !

D. Restauration Atomique par Rollback

Rétablissons la table à son état d’origine en annulant l’opération DELETE :

ALTER TABLE lab3.orders_silver EXECUTE ROLLBACK(<S1>);

SELECT COUNT(*) FROM lab3.orders_silver;

Toutes les commandes livrées sont de nouveau présentes dans la table courante.

E. Politique de Rétention et Expiration des Snapshots

Pour libérer de l’espace disque et respecter les contraintes de gouvernance, nous expirons les snapshots antérieurs à une date donnée :

-- Syntaxe d'expiration des snapshots
ALTER TABLE lab3.orders_silver 
EXECUTE expire_snapshots('2026-11-01 00:00:00');
Opération Effet sur l’État Courant Effet sur l’Historique / Fichiers
DELETE Supprime des lignes de l’état actif Conserve les lignes dans les snapshots passés
ROLLBACK Rétablit un snapshot antérieur comme état actif Ne détruit pas les données (ajoute un commit)
EXPIRE SNAPSHOTS Inchangé Supprime définitivement les snapshots périmés et les fichiers orphelins sur HDFS

4.6 Branches, Tags et Pattern WAP (Write-Audit-Publish)

Le pattern WAP (Write-Audit-Publish) permet d’isoler les écritures de données dans une branche dédiée, de valider des tests de qualité automatisés, puis de promouvoir les données validées en production de manière atomique.

                    +------------------------------------+
                    |  Branche 'audit' (Ingestion lot)  |
                    |  --> Contrôle Qualité (Prix, IDs)  |
                    +------------------------------------+
                                      |
                     Fast-Forward     v  (Si Qualité OK)
main (Production) ==========================================> [ TAG: release_v1 ]

1. Création d’une Branche d’Audit

ALTER TABLE lab3.orders_silver CREATE BRANCH audit;

-- Visualisation des références actives (branches et tags)
SELECT name, type, snapshot_id FROM lab3.orders_silver.refs;

2. Écriture Isolée sur la Branche

Insérons un lot de test uniquement sur la branche audit :

INSERT INTO lab3.orders_silver.branch_audit VALUES (
    CAST('2024-02-01 10:00:00' AS TIMESTAMP),
    'DELIVERED', 
    320, 
    0.0,
    'audit-0001', 
    'd2', 
    'u2', 
    'r2',
    'Zone-Nord'
);

-- Vérification de l'isolation :
SELECT COUNT(*) FROM lab3.orders_silver.branch_audit;
SELECT COUNT(*) FROM lab3.orders_silver; -- La table de prod 'main' n'a pas bougé !

3. Contrôles Qualité Automatisés (Audit Phase)

Avant de publier, nous vérifions l’absence d’anomalies sur la branche :

-- Règle 1 : Unicité stricte des identifiants
SELECT id, COUNT(*) AS doublons
FROM lab3.orders_silver.branch_audit
GROUP BY id 
HAVING COUNT(*) > 1;

-- Règle 2 : Conformité des montants
SELECT COUNT(*) AS prix_invalides
FROM lab3.orders_silver.branch_audit
WHERE price <= 0;

-- Règle 3 : Validité des horodatages
SELECT COUNT(*) AS dates_invalides
FROM lab3.orders_silver.branch_audit
WHERE order_ts IS NULL;

4. Publication par Fast-Forward et Pose de Tag

Si tous les indicateurs sont au vert (0 anomalies), nous publions atomiquement :

-- Promotion de la branche audit vers main
ALTER TABLE lab3.orders_silver EXECUTE FAST-FORWARD 'main' 'audit';

-- Pose d'un tag immuable de versionnage
ALTER TABLE lab3.orders_silver CREATE TAG release_validated;

SELECT name, type, snapshot_id FROM lab3.orders_silver.refs;

La table principale lab3.orders_silver contient désormais les nouvelles données validées.


SECTION 5 : PROJETS D’INGÉNIERIE & DÉFIS AVANCÉS

Défi A : Performance, Compaction et Gestion des Petits Fichiers

L’arrivée continue de micro-batches d’ingestion crée une fragmentation en nombreux petits fichiers (Small Files Problem), ce qui dégrade les temps de réponse analytiques.

Action Corrective : Compaction Iceberg

Iceberg regroupe automatiquement les petits fichiers en gros fichiers optimisés (128 Mo / 512 Mo) sans interrompre les lectures en cours :

-- Déclenchement de la réécriture compactée des fichiers
ALTER TABLE lab3.orders_silver COMPACT 'major';
-- Ou selon la version Hive/Iceberg :
OPTIMIZE TABLE lab3.orders_silver REWRITE DATA;

Vérifiez la consolidation des fichiers dans la table système .files :

SELECT file_path, file_format, record_count, file_size_in_bytes 
FROM lab3.orders_silver.files;

Défi B : Fiabilité et Ingestion Idempotente via MERGE INTO

Pour éviter la duplication de lignes lors de rejeux de pipelines en échec, nous implémentons une stratégie d’Upsert idempotent :

-- Création d'une table de staging pour le nouveau lot entrant
CREATE TABLE IF NOT EXISTS lab3.orders_batch LIKE lab3.orders_silver;

-- Modèle de requête MERGE INTO idempotent
MERGE INTO lab3.orders_silver AS t
USING lab3.orders_batch AS s
ON t.id = s.id
WHEN MATCHED THEN UPDATE SET
    order_ts = s.order_ts,
    status = s.status,
    price = s.price,
    discount_rate = s.discount_rate,
    driver_id = s.driver_id,
    user_id = s.user_id,
    restaurant_id = s.restaurant_id,
    delivery_zone = s.delivery_zone
WHEN NOT MATCHED THEN INSERT VALUES (
    s.order_ts, s.status, s.price, s.discount_rate,
    s.id, s.driver_id, s.user_id, s.restaurant_id, s.delivery_zone
);

Défi C : Conformité RGPD et Historisation Temporelle (SCD Type 2)

1. Table d’Historisation SCD Type 2 pour les Restaurants

Pour tracer l’historique des modifications d’adresses des restaurants dans le temps :

CREATE TABLE lab3.restaurants_history (
    restaurant_id STRING,
    restaurant_name STRING,
    address STRING,
    valid_from TIMESTAMP,
    valid_to TIMESTAMP,
    is_current BOOLEAN
) STORED BY ICEBERG;

Lorsqu’un restaurant déménage :

  1. On met à jour la ligne active : SET valid_to = CURRENT_TIMESTAMP(), is_current = FALSE WHERE restaurant_id = '...' AND is_current = TRUE.
  2. On insère la nouvelle version : INSERT INTO ... VALUES (..., CURRENT_TIMESTAMP(), '9999-12-31', TRUE).

2. Droit à l’Oubli (RGPD) dans un Lakehouse

Une requête DELETE FROM orders_silver WHERE user_id = 'U123' suffit-elle pour respecter le RGPD ? Réponse d’Ingénierie : Non ! Les données de l’utilisateur continuent d’exister dans les snapshots historiques antérieurs (consultables via Time Travel). Pour une conformité légale complète, le protocole exige :

  1. Exécuter le DELETE sur la table courante.
  2. Purger les snapshots historiques contenant l’information (EXECUTE expire_snapshots).
  3. Déclencher le nettoyage des fichiers orphelins non référencés (remove_orphan_files).

SECTION 6 : QUESTIONS DE SOUTENANCE & GUIDE D’ÉVALUATION

Question de Soutenance Réponse Attendue & Justification Technique
Que voit un lecteur pendant une opération INSERT ou MERGE en cours ? Le lecteur bénéficie d’une isolation Snapshot (ACID). Il ne voit que le dernier état cohérent validé. Les fichiers temporaires en cours d’écriture sont invisibles tant que le commit n’a pas publié un nouveau snapshot.
Pourquoi ne faut-il jamais supprimer manuellement des fichiers avec hdfs dfs -rm ? Les fichiers physiques sont référencés par l’arbre de manifests Avro. Une suppression manuelle corrompt l’intégrité de la table, casse le Time Travel et génère des exceptions FileNotFoundException. Il faut utiliser expire_snapshots.
Pourquoi préférer bucket(8, restaurant_id) plutôt qu’un partitionnement direct par restaurant_id ? restaurant_id a une cardinalité élevée. Un partitionnement classique créerait des milliers de sous-répertoires contenant chacun quelques kilo-octets, saturant la mémoire du NameNode. Le bucketing borne strictement le nombre de fichiers à 8 par tranche.
Quelle est la différence fondamentale entre DELETE, ROLLBACK et EXPIRE SNAPSHOTS ? DELETE est une mise à jour logique publiant un nouvel état sans les lignes ciblées. ROLLBACK déplace le pointeur d’état courant vers un snapshot antérieur. EXPIRE SNAPSHOTS détruit définitivement les références historiques et libère le stockage physique.
Que devient un lot écrit sur une branche audit si la branche est supprimée avant FAST-FORWARD ? Le lot n’a jamais été publié sur main. Dès la suppression de la branche (DROP BRANCH), ses snapshots ne sont plus protégés par aucune référence et seront automatiquement purgés lors du prochain cycle d’expiration.

Références Techniques Officielles