← Blog
Un entonnoir lavande avec un bord crème et une attache orange sur fond clair.
Publié le
2026-11-16

ETL ou ELT : où transformer vos données ?

L'ETL transforme les données avant de les charger dans une destination analytique. L'ELT charge d'abord les données extraites, puis les transforme dans cette destination. Ce choix détermine où s'effectue le traitement, quels champs bruts entrent dans le système et comment reprendre le travail lorsqu'une règle change.

Commencez par nommer la destination et les personnes qui peuvent y accéder. Déterminez ensuite quelles données doivent franchir cette limite. Ce guide compare les deux parcours avec les mêmes sept enregistrements fictifs et un exemple Python et DuckDB testé. Il montre l'ordre des opérations et le comportement de validation, sans affirmer qu'une approche est toujours plus rapide ou moins chère.

ETL et ELT : les différences principales

ETL signifie extraire, transformer, charger. ELT signifie extraire, charger, transformer. La différence porte sur la place de la transformation par rapport au chargement dans le système cible. Le comparatif ETL et ELT d'AWS décrit cette séquence. Pour une charge réelle, son intérêt dépend des capacités de traitement de la cible et de vos règles d'accès aux données.

DécisionETLELT
Lieu de transformationAvant l'entrée des données dans la destination choisieDans la destination, après chargement
Données reçues par la destinationLe résultat sélectionné et transforméL'entrée extraite prévue par le contrat de chargement
Traitement d'une valeur incorrecteLors du prétraitementLors de la validation ou de la transformation dans la destination
Besoin lors d'un changement de règleAccès aux entrées conservées ou nouvelle extractionDonnées brutes conservées et exploitables dans la destination, ou nouvelle extraction
Capacité nécessaireProcessus de traitement et destinationCapacité de traitement de la destination, en plus du stockage
Ce que le sigle ne garantit pasSécurité, vitesse, coût ou reprise fiableSécurité, vitesse, coût ou reprise fiable

Nommer la destination avant de dessiner le pipeline

Un pipeline peut comporter plusieurs étapes de stockage. Copier un fichier source dans un compartiment de stockage objet ne suffit pas à qualifier tout le processus d'ETL ou d'ELT. Si une tâche CPU transforme ce fichier avant de charger une base analytique, cette base reçoit toujours des données transformées. Décrivez la séquence par rapport au système que vous évaluez.

Notre exemple utilise deux bases DuckDB distinctes, en mémoire, comme destinations. Dans le parcours ETL, Python valide l'entrée, convertit les montants acceptés en décimaux et retire le champ de contact avant l'insertion. Dans le parcours ELT, la base reçoit les sept enregistrements et les quatre champs source, puis SQL construit la table des lignes acceptées.

Les tables finales contiennent les mêmes valeurs. L'exposition des données brutes diffère. En ELT, exclure un champ d'une table de reporting ne le retire pas de la table brute. En ETL, exclure un champ de la destination ne le supprime ni de la source ni du système de prétraitement. Ces emplacements nécessitent eux aussi des règles d'accès et de conservation.

Faire passer les mêmes données par les deux parcours

Le contrat source prévoit quatre champs de type chaîne ou null : identifiant de commande, catégorie, montant sous forme de texte et adresse de contact fictive. Les identifiants acceptés commencent par ord-, suivi de trois chiffres ASCII ; les catégories sont exactement books ou tools. Les montants en dollars américains vont de 0.00 à 9999.99, avec deux décimales. L'exemple refuse volontairement les remboursements, les catégories inattendues et les identifiants mal formés. Ce sont des règles métier de démonstration, pas des propriétés générales de l'ETL.

Utilisez Python 3.11 ou une version ultérieure et installez la dépendance à la version indiquée dans votre environnement de projet :

python -m pip install duckdb==2.0.0

Enregistrez le code suivant dans compare_pipelines.py. Les deux destinations restent en mémoire et se ferment à la fin de chaque appel. Le code n'ouvre aucune base existante et n'effectue aucune requête réseau.

import re
from decimal import Decimal

import duckdb

ID_PATTERN = r"ord-[0-9]{3}"
AMOUNT_PATTERN = r"(0|[1-9][0-9]{0,3})\.[0-9]{2}"
ROWS = [
    ("ord-001", "books", "12.50", "a@example.invalid"),
    ("ord-002", "books", "7.50", "b@example.invalid"),
    ("ord-003", "tools", "0.00", "c@example.invalid"),
    ("ord-004", "tools", "oops", "d@example.invalid"),
    ("ord-005", "tools", "-3.00", "e@example.invalid"),
    ("bad-id", "books", "2.00", "f@example.invalid"),
    ("ord-007", "other", "1.00", "g@example.invalid"),
]


def transform(row):
    order_id, category, amount, contact = row
    if order_id is None or not re.fullmatch(ID_PATTERN, order_id):
        return None, "invalid_id"
    if category not in ("books", "tools"):
        return None, "invalid_category"
    if amount is None or not re.fullmatch(AMOUNT_PATTERN, amount):
        return None, "invalid_amount"
    return (order_id, category, Decimal(amount)), None


def compare(rows):
    # This demonstration accepts four source fields, each a string or None.
    if any(len(row) != 4 or any(v is not None and not isinstance(v, str)
                               for v in row) for row in rows):
        raise ValueError("Expected four string-or-None fields per row")
    accepted, rejected = [], []
    for row in rows:
        cleaned, error = transform(row)
        if error:
            rejected.append((row[0], error))
        else:
            accepted.append(cleaned)

    # Separate in-memory destinations. No existing database is opened.
    etl = duckdb.connect(":memory:")
    elt = duckdb.connect(":memory:")
    try:
        etl.execute("CREATE TABLE accepted(order_id VARCHAR, category VARCHAR, amount DECIMAL(6,2))")
        if accepted:
            etl.executemany("INSERT INTO accepted VALUES (?, ?, ?)", accepted)

        elt.execute("CREATE TABLE raw(order_id VARCHAR, category VARCHAR, amount_text VARCHAR, contact VARCHAR)")
        if rows:
            elt.executemany("INSERT INTO raw VALUES (?, ?, ?, ?)", rows)
        elt.execute("""
            CREATE TABLE checked AS
            SELECT *, CASE
                WHEN NOT COALESCE(regexp_full_match(order_id, ?), FALSE)
                    THEN 'invalid_id'
                WHEN category IS NULL OR category NOT IN ('books', 'tools')
                    THEN 'invalid_category'
                WHEN NOT COALESCE(regexp_full_match(amount_text, ?), FALSE)
                    THEN 'invalid_amount'
                ELSE NULL
            END AS error
            FROM raw
        """, [ID_PATTERN, AMOUNT_PATTERN])
        elt.execute("""
            CREATE TABLE accepted AS
            SELECT order_id, category, TRY_CAST(amount_text AS DECIMAL(6,2)) AS amount
            FROM checked WHERE error IS NULL
        """)

        def snapshot(connection):
            return {
                "rows": connection.execute("SELECT * FROM accepted ORDER BY order_id").fetchall(),
                "columns": connection.execute("DESCRIBE accepted").fetchall(),
                "totals": connection.execute("SELECT category, SUM(amount) FROM accepted GROUP BY category ORDER BY category").fetchall(),
                "tables": connection.execute("SHOW TABLES").fetchall(),
            }

        return {
            "etl": snapshot(etl), "elt": snapshot(elt),
            "etl_rejected": rejected,
            "elt_rejected": elt.execute("SELECT order_id, error FROM checked WHERE error IS NOT NULL ORDER BY order_id").fetchall(),
            "elt_raw": elt.execute("SELECT * FROM raw ORDER BY order_id").fetchall(),
        }
    finally:
        etl.close()
        elt.close()


if __name__ == "__main__":
    result = compare(ROWS)
    assert result["etl"]["rows"] == result["elt"]["rows"]
    assert sorted(result["etl_rejected"]) == result["elt_rejected"]
    print("Accepted rows in each destination:", len(result["etl"]["rows"]))
    print("Rejected rows in each path:", len(result["etl_rejected"]))
    print("ELT raw rows retained during the run:", len(result["elt_raw"]))
    for category, total in result["etl"]["totals"]:
        print(f"{category}: {total:.2f} USD")

Exécutez la comparaison :

python compare_pipelines.py

Le jeu de données produit :

Accepted rows in each destination: 3
Rejected rows in each path: 4
ELT raw rows retained during the run: 7
books: 20.00 USD
tools: 0.00 USD

Le contrôle du montant précède sa conversion. Il empêche l'exemple d'accepter silencieusement une valeur comportant trop de décimales en l'arrondissant. DuckDB documente la correspondance d'un motif avec la chaîne entière, le retour de NULL par TRY_CAST en cas d'échec et les types DECIMAL à virgule fixe. Le script associe ces opérations à une politique d'acceptation explicite.

Interpréter le résultat à la mesure du test

Les deux parcours acceptent trois enregistrements, en refusent quatre et produisent des totaux de 20,00 USD pour les livres et de 0,00 USD pour les outils. La destination ETL contient uniquement la table des lignes acceptées. La destination ELT conserve aussi les tables brutes et contrôlées, avec les champs de contact fictifs, jusqu'à la fermeture de la connexion.

Les 10 tests locaux ont réussi avec CPython 3.12.14 et DuckDB 2.0.0 sous Windows. Ils vérifient les lignes acceptées, les motifs de rejet, les schémas des tables, les champs bruts conservés, les totaux, les limites des montants, les valeurs absentes, l'entrée vide, le contrat des champs source et la répétition de la démonstration. Des sous-cas refusent notamment NaN, la notation scientifique, les décimales supplémentaires et une catégorie dont la casse est incorrecte.

Il s'agit d'un exemple de justesse sur de petits jeux de données locaux. Les deux parcours s'exécutent dans un seul processus Python. Le test ne compare donc ni des serveurs distincts, ni les performances d'un entrepôt, ni l'application des droits d'accès, ni les coûts cloud. Répéter la démonstration crée de nouvelles bases ; cela ne prouve pas qu'ajouter deux fois le même lot à une table de production persistante est sans conséquence.

Pour un import qui valide un fichier quotidien avant de l'écrire dans PostgreSQL, consultez notre guide de pipeline ETL Python (en anglais). Distinguez le choix du lieu de transformation du fonctionnement d'un outil de chargement particulier.

Choisir selon la contrainte déterminante

Choisissez l'ETL lorsque la destination doit recevoir un résultat limité et validé. Une base de reporting peut avoir besoin de totaux mensuels sans devoir recevoir les coordonnées des clients. Le prétraitement peut sélectionner les colonnes nécessaires et refuser les valeurs invalides avant le chargement. Le processus de traitement relève alors de votre exploitation : il doit disposer de la capacité nécessaire, d'un accès contrôlé aux sources et d'une politique d'échec claire.

Choisissez l'ELT lorsque la destination sait traiter les données et que conserver les entrées brutes répond à un besoin défini. Une équipe analytique peut vouloir modifier ses regroupements ou construire plusieurs vues sur le même lot conservé. Cette souplesse dépend de données brutes exploitables, d'une capacité de traitement adaptée et de permissions distinguant les entrées brutes des résultats approuvés.

Certaines charges combinent les deux. Vous pouvez retirer un champ inutile avant le chargement, puis construire les modèles de reporting dans la destination. Documentez la séquence réelle. Une étiquette ne doit pas masquer les champs conservés ou le lieu d'exécution d'une transformation.

Aucune approche n'impose un format de fichier particulier et aucune ne rend automatiquement un pipeline temps réel. La fréquence d'extraction, le mode d'ingestion, la planification et la capacité de traitement déterminent le délai de disponibilité des données exploitables.

Prévoir ensemble la reprise, les échecs et les coûts

Définissez le sort d'une ligne invalide. L'exemple conserve un identifiant et un motif. Un pipeline réel peut isoler l'enregistrement source dans un emplacement à accès restreint, refuser le lot entier ou accepter un sous-ensemble documenté. Rendez les nombres de rejets visibles pour qu'une exécution terminée sans erreur ne masque pas des données manquantes.

Avant de relancer un chargement persistant, décidez comment la destination reconnaît un lot ou un enregistrement déjà reçu. Remplacer un instantané, fusionner à partir d'une clé métier stable et ajouter un événement ont des conséquences différentes. Enregistrez la version de l'entrée et celle de la transformation, puis testez les interruptions et la reprise selon le comportement choisi. Les sigles ETL et ELT n'apportent pas ces garanties.

Comparez les coûts avec le même volume d'entrée, le même délai de livraison, la même durée de conservation et le même résultat accepté. Incluez l'extraction, le calcul de transformation, le stockage temporaire et conservé, les transferts, la supervision et le temps de maintenance. Déplacer les transformations dans la destination peut changer le poste de facturation ; le traitement reste nécessaire.

Mesurez le délai jusqu'à la disponibilité des données utilisables, pas seulement jusqu'au chargement brut. Un dépôt rapide n'est utile que si la validation et la transformation qui suivent respectent aussi l'échéance du consommateur.

Relier la charge de travail à Hivenet

Les ressources de calcul de Hivenet fournissent une infrastructure CPU pour les tâches et services exploités par les clients. Présentez la taille des sources, les règles de traitement, la fréquence d'exécution, les besoins en mémoire et le système cible. Ces éléments permettent de dimensionner le processus ou la charge analytique que vous comptez exploiter.

Le stockage objet de Hivenet peut conserver les entrées, les jeux de données retenus et les fichiers produits à l'aide d'outils compatibles S3. Définissez séparément le stockage et le traitement. Cet exemple ne démontre ni un service ETL managé ni un stockage objet qui exécuterait vos transformations de base de données.

Un premier examen utile du projet part d'un lot représentatif, d'une destination explicite et d'une règle d'acceptation mesurable. Ces éléments rendent ensuite les choix de calcul et de stockage plus faciles à tester.

Votre prochaine charge de travail sur Hivenet.

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.