JSONL dans les pipelines ETL : Kafka, Airflow et entrepôts de données
Un guide pratique pour utiliser JSONL (JSON Lines) comme format d’échange dans les pipelines ETL modernes. Découvrez comment produire et consommer des événements JSONL avec Kafka, orchestrer des transformations JSONL dans des DAG Airflow et charger des données JSONL dans Snowflake, BigQuery et Redshift.
Pourquoi JSONL est le format d’échange idéal pour l’ETL
Les pipelines Extract-Transform-Load (ETL) transfèrent des données entre des systèmes qui partagent rarement le même schéma. JSONL se prête particulièrement bien à cet usage : chaque ligne constitue un document JSON autonome. Aucun en-tête ne risque de se perdre, aucun délimiteur n’est à échapper et aucun enregistrement sur plusieurs lignes n’est à reconstituer après un échec partiel. Chaque ligne peut être validée, transformée et acheminée indépendamment : c’est précisément ce dont ont besoin les systèmes distribués comme Kafka et Airflow.
Contrairement au CSV, JSONL conserve sans ambiguïté les structures imbriquées, les tableaux et les valeurs typées. Contrairement à Parquet ou Avro, il est directement lisible et ne nécessite aucun outil particulier pour examiner les données. Ces propriétés en font un format naturel pour relier les étapes d’un pipeline : les topics Kafka transportent des messages JSONL, les tâches Airflow lisent et écrivent des fichiers JSONL dans un stockage objet, et les entrepôts de données ingèrent du JSONL avec leurs commandes natives de chargement en masse. Ce guide présente des approches concrètes pour chacune de ces étapes, avec du code prêt pour la production.
Kafka + JSONL : streaming d’événements
Apache Kafka est au cœur de l’ETL en temps réel. Les producteurs émettent des événements sous forme de messages encodés en JSONL (un objet JSON par message Kafka), que les consommateurs lisent ligne par ligne pour alimenter les systèmes en aval. Chaque message Kafka correspondant à un seul enregistrement JSONL, ce format s’intègre parfaitement à l’architecture de Kafka fondée sur un journal. La sérialisation est simple, et les consommateurs peuvent analyser chaque message indépendamment, sans mise en mémoire tampon.
Ce producteur Kafka sérialise des dictionnaires Python en messages encodés en JSONL. Chaque message contient une seule ligne JSON, envoyée à un topic Kafka. Le paramètre value_serializer gère automatiquement l’encodage : il vous suffit de passer un dict à la méthode send().
import json
from kafka import KafkaProducer
producer = KafkaProducer(
bootstrap_servers=['localhost:9092'],
value_serializer=lambda v: json.dumps(v).encode('utf-8'),
acks='all',
retries=3,
)
# Lire un fichier JSONL et publier chaque ligne comme message Kafka
with open('events.jsonl', 'r') as f:
for line in f:
line = line.strip()
if not line:
continue
event = json.loads(line)
producer.send('etl-events', value=event)
producer.flush()
print('All events published to Kafka')Ce consommateur Kafka lit les messages JSONL et les écrit par lots dans un fichier JSONL local. L’écriture par lots réduit le surcoût des E/S et permet aux systèmes en aval de traiter davantage de données en une seule fois. Le consommateur ne valide les offsets qu’une fois le lot entièrement écrit, ce qui garantit une livraison au moins une fois.
import json
from kafka import KafkaConsumer
consumer = KafkaConsumer(
'etl-events',
bootstrap_servers=['localhost:9092'],
value_deserializer=lambda v: json.loads(v.decode('utf-8')),
group_id='etl-consumer-group',
enable_auto_commit=False,
auto_offset_reset='earliest',
)
BATCH_SIZE = 500
batch = []
for message in consumer:
batch.append(message.value)
if len(batch) >= BATCH_SIZE:
# Ecrire le lot dans un fichier JSONL
with open('output/batch.jsonl', 'a') as f:
for record in batch:
f.write(json.dumps(record) + '\n')
consumer.commit()
print(f'Committed batch of {len(batch)} records')
batch.clear()
# Vider les enregistrements restants
if batch:
with open('output/batch.jsonl', 'a') as f:
for record in batch:
f.write(json.dumps(record) + '\n')
consumer.commit()Apache Airflow : orchestrer les tâches JSONL
Apache Airflow est l’outil de référence pour orchestrer les traitements ETL par lots. Un pipeline Airflow reposant sur JSONL comporte généralement trois étapes : extraire les données brutes au format JSONL, transformer le fichier JSONL (filtrer, enrichir, restructurer), puis charger le résultat dans un entrepôt de données ou un stockage objet. Chaque étape lit et écrit des fichiers JSONL : vous pouvez ainsi examiner les données intermédiaires et relancer chaque tâche indépendamment.
Ce DAG Airflow complet extrait des données d’une API, les transforme au format JSONL et charge le résultat dans un stockage cloud. Les tâches échangent des fichiers JSONL sur un stockage partagé, ce qui facilite le débogage du pipeline et la relance des tâches en cas d’échec.
from airflow import DAG
from airflow.operators.python import PythonOperator
from airflow.providers.amazon.aws.hooks.s3 import S3Hook
from datetime import datetime, timedelta
import json
import requests
default_args = {
'owner': 'data-team',
'retries': 2,
'retry_delay': timedelta(minutes=5),
}
def extract(**context):
"""Extraire les donnees de l'API et ecrire du JSONL sur le disque local."""
ds = context['ds'] # date d'execution : AAAA-MM-JJ
response = requests.get(
'https://api.example.com/events',
params={'date': ds},
)
events = response.json()
path = f'/tmp/raw_{ds}.jsonl'
with open(path, 'w') as f:
for event in events:
f.write(json.dumps(event) + '\n')
return path
def transform(**context):
"""Lire le JSONL brut, filtrer et enrichir, ecrire le JSONL nettoye."""
ds = context['ds']
input_path = f'/tmp/raw_{ds}.jsonl'
output_path = f'/tmp/clean_{ds}.jsonl'
with open(input_path) as fin, open(output_path, 'w') as fout:
for line in fin:
record = json.loads(line)
if record.get('status') != 'valid':
continue
record['processed_at'] = datetime.utcnow().isoformat()
fout.write(json.dumps(record) + '\n')
return output_path
def load(**context):
"""Telecharger le JSONL nettoye vers S3."""
ds = context['ds']
local_path = f'/tmp/clean_{ds}.jsonl'
s3 = S3Hook(aws_conn_id='aws_default')
s3.load_file(
filename=local_path,
key=f'etl/events/{ds}/data.jsonl',
bucket_name='data-lake',
replace=True,
)
with DAG(
'jsonl_etl_pipeline',
default_args=default_args,
schedule_interval='@daily',
start_date=datetime(2026, 1, 1),
catchup=False,
) as dag:
t_extract = PythonOperator(task_id='extract', python_callable=extract)
t_transform = PythonOperator(task_id='transform', python_callable=transform)
t_load = PythonOperator(task_id='load', python_callable=load)
t_extract >> t_transform >> t_loadPour les fichiers JSONL trop volumineux pour tenir en mémoire, utilisez une transformation en streaming qui traite une ligne à la fois. Cette approche maintient une consommation mémoire constante, quelle que soit la taille du fichier. Elle convient bien aux tâches Airflow, dont les workers peuvent disposer de ressources limitées.
import json
from typing import Callable
def stream_transform(
input_path: str,
output_path: str,
transform_fn: Callable[[dict], dict | None],
batch_size: int = 5000,
) -> dict:
"""Transformer en streaming un fichier JSONL avec une fonction definie par l'utilisateur.
Retournez None depuis transform_fn pour ignorer un enregistrement."""
stats = {'input': 0, 'output': 0, 'skipped': 0}
batch = []
with open(input_path) as fin, open(output_path, 'w') as fout:
for line in fin:
line = line.strip()
if not line:
continue
stats['input'] += 1
record = json.loads(line)
result = transform_fn(record)
if result is None:
stats['skipped'] += 1
continue
batch.append(json.dumps(result))
if len(batch) >= batch_size:
fout.write('\n'.join(batch) + '\n')
stats['output'] += len(batch)
batch.clear()
if batch:
fout.write('\n'.join(batch) + '\n')
stats['output'] += len(batch)
return stats
# Utilisation dans une tache Airflow
def enrich(record):
if record.get('amount', 0) < 0:
return None # ignorer les invalides
record['currency'] = record.get('currency', 'USD').upper()
return record
stats = stream_transform(
'/tmp/raw.jsonl',
'/tmp/enriched.jsonl',
transform_fn=enrich,
)
print(f'Processed: {stats}')Charger des données JSONL dans un entrepôt de données
Les entrepôts de données modernes prennent en charge nativement l’ingestion de fichiers JSONL. Snowflake, BigQuery et Redshift peuvent charger directement ces fichiers depuis un stockage cloud, analyser le JSON à la volée et stocker les résultats dans des tables structurées. Vous évitez ainsi une conversion intermédiaire en CSV tout en conservant les types de données imbriqués.
Snowflake
COPY INTOSnowflake ingère les données JSONL avec la commande COPY INTO depuis des stages S3, GCS ou Azure Blob. Utilisez l’option FILE_FORMAT avec TYPE = 'JSON' pour que chaque ligne soit analysée comme un document JSON distinct. Le type de colonne VARIANT permet de stocker nativement les données semi-structurées.
BigQuery
NatifBigQuery charge les fichiers JSONL depuis Google Cloud Storage en détectant automatiquement le schéma. La commande bq load avec --source_format=NEWLINE_DELIMITED_JSON prend en charge JSONL nativement. BigQuery peut également déduire les types des colonnes à partir des valeurs JSON.
Redshift
COPYAmazon Redshift prend en charge le chargement de données JSONL depuis S3 avec la commande COPY et l’option FORMAT AS JSON. Vous pouvez fournir un fichier JSONPaths pour faire correspondre les clés JSON aux colonnes de la table et contrôler précisément le chargement.
Chargez un fichier JSONL depuis un stage S3 dans une table Snowflake. Chaque ligne devient une ligne avec une colonne VARIANT contenant le JSON analyse. Vous pouvez ensuite aplatir la colonne VARIANT en colonnes typees en utilisant le SQL Snowflake.
-- Creer un stage pointant vers votre bucket S3
CREATE OR REPLACE STAGE etl_stage
URL = 's3://data-lake/etl/events/'
CREDENTIALS = (AWS_KEY_ID = '...' AWS_SECRET_KEY = '...')
FILE_FORMAT = (TYPE = 'JSON' STRIP_OUTER_ARRAY = FALSE);
-- Creer la table cible
CREATE TABLE IF NOT EXISTS raw_events (
data VARIANT,
loaded_at TIMESTAMP_NTZ DEFAULT CURRENT_TIMESTAMP()
);
-- Charger les fichiers JSONL depuis le stage
COPY INTO raw_events (data)
FROM @etl_stage
FILE_FORMAT = (TYPE = 'JSON')
PATTERN = '.*\.jsonl'
ON_ERROR = 'CONTINUE';
-- Interroger les donnees chargees
SELECT
data:id::INT AS event_id,
data:user_id::STRING AS user_id,
data:event_type::STRING AS event_type,
data:timestamp::TIMESTAMP AS event_ts
FROM raw_events
LIMIT 10;Utilisez le client Python BigQuery pour charger un fichier JSONL depuis Google Cloud Storage dans une table BigQuery. Le client gere la detection de schema, le partitionnement et le rapport d'erreurs. Cette approche s'integre bien avec les taches Airflow.
from google.cloud import bigquery
client = bigquery.Client(project='my-project')
job_config = bigquery.LoadJobConfig(
source_format=bigquery.SourceFormat.NEWLINE_DELIMITED_JSON,
autodetect=True,
write_disposition=bigquery.WriteDisposition.WRITE_APPEND,
max_bad_records=10,
)
# Charger depuis GCS
uri = 'gs://data-lake/etl/events/2026-01-15/data.jsonl'
table_ref = 'my-project.analytics.raw_events'
load_job = client.load_table_from_uri(
uri,
table_ref,
job_config=job_config,
)
load_job.result() # Attendre la fin
table = client.get_table(table_ref)
print(f'Loaded {load_job.output_rows} rows')
print(f'Table now has {table.num_rows} total rows')Tolérance aux pannes et idempotence
Les pipelines ETL peuvent échouer : une connexion réseau se coupe, une API ne répond pas dans les délais ou un worker manque de mémoire. JSONL facilite la reprise, car chaque ligne est indépendante. Vous pouvez sauvegarder votre position (le numéro de ligne), reprendre à partir de la dernière ligne traitée avec succès et éviter de retraiter les données. En associant ce mécanisme à des écritures idempotentes, vous obtenez une sémantique de traitement exactement une fois, même avec une livraison au moins une fois.
Ce traitement utilise des points de reprise pour suivre sa progression par numéro de ligne. En cas d’échec du pipeline, il repart du dernier point de reprise validé au lieu de retraiter l’ensemble du fichier. Le point de reprise est enregistré dans un simple fichier texte contenant le numéro de la dernière ligne traitée avec succès.
import json
import os
def get_checkpoint(checkpoint_path: str) -> int:
"""Lire le dernier numero de ligne valide."""
if os.path.exists(checkpoint_path):
with open(checkpoint_path) as f:
return int(f.read().strip())
return 0
def save_checkpoint(checkpoint_path: str, line_num: int):
"""Sauvegarder atomiquement le point de controle actuel."""
tmp = checkpoint_path + '.tmp'
with open(tmp, 'w') as f:
f.write(str(line_num))
os.replace(tmp, checkpoint_path) # atomique sur POSIX
def process_with_checkpoint(
input_path: str,
output_path: str,
checkpoint_path: str,
batch_size: int = 1000,
):
"""Traiter un fichier JSONL avec reprise basee sur les points de controle."""
start_line = get_checkpoint(checkpoint_path)
processed = 0
with open(input_path) as fin, \
open(output_path, 'a') as fout:
for line_num, line in enumerate(fin, 1):
if line_num <= start_line:
continue # ignorer les lignes deja traitees
line = line.strip()
if not line:
continue
record = json.loads(line)
# --- votre logique de transformation ---
record['etl_version'] = 'v2'
fout.write(json.dumps(record) + '\n')
processed += 1
if processed % batch_size == 0:
fout.flush()
save_checkpoint(checkpoint_path, line_num)
print(f'Checkpoint at line {line_num}')
# Point de controle final
save_checkpoint(checkpoint_path, line_num)
print(f'Done. Processed {processed} records from line {start_line + 1}')
# Utilisation
process_with_checkpoint(
'input.jsonl',
'output.jsonl',
'checkpoint.txt',
batch_size=5000,
)Cette approche par points de reprise s’applique à toutes les étapes d’un pipeline JSONL. Pour les consommateurs Kafka, remplacez le point de reprise enregistré dans un fichier par les offsets validés. Avec Airflow, stockez le point de reprise dans XCom ou dans une base de données externe pour que les tâches relancées repartent du bon endroit. Le format ligne par ligne de JSONL simplifie le suivi de la position : un seul entier, le numéro de ligne ou l’offset en octets, suffit pour reprendre le traitement.
Validez vos données JSONL avant de les charger
Repérez les enregistrements mal formés avant qu’ils n’entrent dans votre pipeline. Utilisez nos outils en ligne gratuits pour valider, visualiser et convertir des fichiers JSONL dans votre navigateur.
Apprenez à streamer des données JSONL en Node.js et Python. Couvre SSE, WebSockets et le traitement de logs en temps réel.
Apprenez à importer et exporter des données JSONL avec les bases de données PostgreSQL, MongoDB, MySQL et SQLite.
Apprenez à valider des fichiers JSONL avec JSON Schema. Couvre Python, Node.js, les outils CLI et l’automatisation CI/CD.
Les stratégies pour traiter des gigaoctets de données JSONL : lecture en streaming, gestion de la mémoire, découpage des fichiers, compression et outils en ligne.
Validez vos fichiers JSONL ligne par ligne. Repérez immédiatement les erreurs de syntaxe et les problèmes d’encodage ou de format.