JSONL in ETL-pipelines: Kafka, Airflow en datawarehouses
Een praktische handleiding voor JSONL (JSON Lines) als uitwisselingsformaat in moderne ETL-pipelines. Leer hoe je JSONL-events produceert en consumeert met Kafka, JSONL-transformaties orkestreert met Airflow-DAG’s en JSONL-data laadt in Snowflake, BigQuery en Redshift.
Waarom JSONL het ideale uitwisselingsformaat voor ETL is
Extract-Transform-Load-pipelines (ETL) verplaatsen data tussen systemen die zelden hetzelfde schema gebruiken. JSONL leent zich hier bij uitstek voor, omdat elke regel een op zichzelf staand JSON-document is. Er zijn geen headers die verloren kunnen gaan, geen scheidingstekens die je moet escapen en geen records over meerdere regels die je na een gedeeltelijke storing weer moet samenvoegen. Je kunt elke regel afzonderlijk valideren, transformeren en routeren. Dat is precies wat gedistribueerde systemen als Kafka en Airflow nodig hebben.
JSONL behoudt geneste structuren, arrays en waarden met hun datatype, zonder de ambiguïteit van CSV. Bovendien is JSONL, anders dan Parquet of Avro, direct leesbaar en heb je geen speciale tools nodig om de inhoud te bekijken. Daarmee is JSONL een logische keuze om de stappen van een pipeline met elkaar te verbinden: Kafka-topics bevatten JSONL-berichten, Airflow-taken lezen en schrijven JSONL-bestanden in object storage en datawarehouses laden JSONL met hun ingebouwde commando’s voor bulkladingen. In deze handleiding leer je concrete patronen voor elk van deze stappen, met code die je in productie kunt gebruiken.
Kafka + JSONL: events streamen
Apache Kafka vormt de basis van realtime ETL. Producers versturen events als JSONL-gecodeerde berichten (één JSON-object per Kafka-bericht) en consumers lezen die regel voor regel in voor verdere verwerking in andere systemen. Elk Kafka-bericht bevat precies één JSONL-record, waardoor het formaat naadloos aansluit op de logarchitectuur van Kafka. Serialiseren is eenvoudig en consumers kunnen elk bericht afzonderlijk parsen, zonder buffering.
Een Kafka-producer die Python-dictionaries serialiseert naar JSONL-gecodeerde berichten. Elk bericht bestaat uit één regel JSON en wordt naar een Kafka-topic verstuurd. De value_serializer verzorgt de encoding automatisch: je hoeft alleen een dict door te geven aan de send()-methode.
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,
)
# Lees een JSONL-bestand en publiceer elke regel als Kafka-bericht
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('Alle events gepubliceerd naar Kafka')Een Kafka-consumer die JSONL-berichten leest en in batches naar een lokaal JSONL-bestand schrijft. Werken met batches beperkt de I/O-overhead en laat volgende systemen grotere hoeveelheden data tegelijk verwerken. De consumer commit de offsets pas nadat de volledige batch is weggeschreven. Zo is at-least-once delivery gegarandeerd.
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:
# Schrijf batch naar JSONL-bestand
with open('output/batch.jsonl', 'a') as f:
for record in batch:
f.write(json.dumps(record) + '\n')
consumer.commit()
print(f'Batch van {len(batch)} records gecommitteerd')
batch.clear()
# Flush overgebleven records
if batch:
with open('output/batch.jsonl', 'a') as f:
for record in batch:
f.write(json.dumps(record) + '\n')
consumer.commit()Apache Airflow: JSONL-taken orkestreren
Apache Airflow is de standaardtool voor het orkestreren van batch-ETL. Een gebruikelijke Airflow-pipeline met JSONL bestaat uit drie stappen: ruwe data ophalen en opslaan als JSONL, het JSONL-bestand transformeren (filteren, verrijken en herstructureren) en het resultaat laden in een datawarehouse of object store. Elke stap leest en schrijft JSONL-bestanden. Daardoor kun je tussenresultaten bekijken en taken afzonderlijk opnieuw uitvoeren.
Een volledige Airflow-DAG die data ophaalt uit een API, deze als JSONL transformeert en het resultaat in cloudopslag laadt. De taken wisselen data uit via JSONL-bestanden op gedeelde opslag. Daardoor kun je de pipeline eenvoudig debuggen en opnieuw uitvoeren als er iets misgaat.
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):
"""Extraheer data van API en schrijf JSONL naar lokale schijf."""
ds = context['ds'] # uitvoeringsdatum: YYYY-MM-DD
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):
"""Lees ruwe JSONL, filter en verrijk, schrijf opgeschoonde JSONL."""
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):
"""Upload opgeschoonde JSONL naar 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_loadGebruik voor grote JSONL-bestanden die niet in het geheugen passen een streaming transformatie die telkens één regel verwerkt. Met dit patroon blijft het geheugengebruik constant, ongeacht de bestandsgrootte. Dat werkt goed in Airflow-taken, waar workers soms maar beperkte resources beschikbaar hebben.
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:
"""Stream-transformeer een JSONL-bestand met een door de gebruiker gedefinieerde functie.
Retourneer None vanuit transform_fn om een record over te slaan."""
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
# Gebruik binnen een Airflow-taak
def enrich(record):
if record.get('amount', 0) < 0:
return None # sla ongeldig over
record['currency'] = record.get('currency', 'USD').upper()
return record
stats = stream_transform(
'/tmp/raw.jsonl',
'/tmp/enriched.jsonl',
transform_fn=enrich,
)
print(f'Verwerkt: {stats}')JSONL laden in datawarehouses
Moderne datawarehouses bieden ingebouwde ondersteuning voor het laden van JSONL-bestanden. Snowflake, BigQuery en Redshift kunnen JSONL rechtstreeks uit cloudopslag laden, de JSON tijdens het laden parsen en de resultaten opslaan in gestructureerde tabellen. Je hoeft de data dus niet eerst naar CSV te converteren en geneste datatypes blijven behouden.
Snowflake
COPY INTOSnowflake laadt JSONL met het COPY INTO-commando vanuit stages voor S3, GCS of Azure Blob. Gebruik de FILE_FORMAT-optie met TYPE = 'JSON' om elke regel als een afzonderlijk JSON-document te parsen. Het kolomtype VARIANT biedt ingebouwde ondersteuning voor de opslag van semigestructureerde data.
BigQuery
NativeBigQuery laadt JSONL-bestanden uit Google Cloud Storage en detecteert het schema automatisch. Het bq load-commando ondersteunt JSONL rechtstreeks met de optie --source_format=NEWLINE_DELIMITED_JSON. BigQuery kan ook de kolomtypes automatisch afleiden uit de JSON-waarden.
Redshift
COPYAmazon Redshift kan JSONL uit S3 laden met het COPY-commando en FORMAT AS JSON. Met een JSONPaths-bestand kun je JSON-sleutels aan tabelkolommen koppelen, zodat je het laadproces nauwkeurig kunt sturen.
Laad een JSONL-bestand vanuit een S3-stage in een Snowflake-tabel. Elke regel wordt een rij met een VARIANT-kolom die de geparseerde JSON bevat. Je kunt vervolgens de VARIANT-kolom platmaken naar getypeerde kolommen met Snowflake SQL.
-- Maak een stage die naar je S3-bucket wijst
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);
-- Maak de doeltabel
CREATE TABLE IF NOT EXISTS raw_events (
data VARIANT,
loaded_at TIMESTAMP_NTZ DEFAULT CURRENT_TIMESTAMP()
);
-- Laad JSONL-bestanden vanuit de stage
COPY INTO raw_events (data)
FROM @etl_stage
FILE_FORMAT = (TYPE = 'JSON')
PATTERN = '.*\.jsonl'
ON_ERROR = 'CONTINUE';
-- Query de geladen data
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;Gebruik de BigQuery Python-client om een JSONL-bestand vanuit Google Cloud Storage in een BigQuery-tabel te laden. De client verzorgt schemadetectie, partitionering en foutrapportage. Deze aanpak integreert goed met Airflow-taken.
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,
)
# Laden vanuit 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() # Wacht op voltooiing
table = client.get_table(table_ref)
print(f'{load_job.output_rows} rijen geladen')
print(f'Tabel bevat nu {table.num_rows} rijen totaal')Fouttolerantie en idempotentie
ETL-pipelines kunnen uitvallen. Netwerkverbindingen vallen weg, API’s geven time-outs en workers hebben geen geheugen meer beschikbaar. Met JSONL is herstel eenvoudig, omdat elke regel op zichzelf staat. Je kunt je positie (het regelnummer) vastleggen in een checkpoint en de verwerking hervatten vanaf de laatste succesvol verwerkte regel, zonder data opnieuw te verwerken. In combinatie met idempotente schrijfbewerkingen levert dit exactly-once-semantiek op, ook bij at-least-once delivery.
Een processor die met checkpoints de voortgang bijhoudt aan de hand van regelnummers. Als de pipeline uitvalt, hervat de processor de verwerking vanaf het laatst vastgelegde checkpoint, in plaats van het hele bestand opnieuw te verwerken. Het checkpointbestand is een eenvoudig tekstbestand met het nummer van de laatst succesvol verwerkte regel.
import json
import os
def get_checkpoint(checkpoint_path: str) -> int:
"""Lees het laatst gecommitteerde regelnummer."""
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):
"""Sla het huidige checkpoint atomair op."""
tmp = checkpoint_path + '.tmp'
with open(tmp, 'w') as f:
f.write(str(line_num))
os.replace(tmp, checkpoint_path) # atomair op POSIX
def process_with_checkpoint(
input_path: str,
output_path: str,
checkpoint_path: str,
batch_size: int = 1000,
):
"""Verwerk een JSONL-bestand met checkpoint-gebaseerde hervatting."""
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 # sla reeds verwerkte regels over
line = line.strip()
if not line:
continue
record = json.loads(line)
# --- je transformatielogica ---
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 bij regel {line_num}')
# Laatste checkpoint
save_checkpoint(checkpoint_path, line_num)
print(f'Klaar. {processed} records verwerkt vanaf regel {start_line + 1}')
# Gebruik
process_with_checkpoint(
'input.jsonl',
'output.jsonl',
'checkpoint.txt',
batch_size=5000,
)Je kunt het checkpointpatroon in elke stap van een JSONL-pipeline gebruiken. Bij Kafka-consumers vervang je het checkpoint in een bestand door gecommitte offsets. In Airflow sla je het checkpoint op in XCom of een externe database, zodat taken bij een nieuwe poging vanaf de juiste positie verdergaan. Doordat JSONL uit afzonderlijke regels bestaat, is het eenvoudig om de positie bij te houden: één geheel getal (het regelnummer of de byte-offset) is genoeg om de verwerking te hervatten.
Valideer je JSONL voordat je de data laadt
Spoor onjuist gevormde records op voordat ze in je pipeline terechtkomen. Gebruik onze gratis online tools om JSONL-bestanden in je browser te valideren, te bekijken en te converteren.
Leer hoe je JSONL-data in realtime streamt met Node.js, Python, Server-Sent Events en WebSockets. Bouw streamingpipelines voor logs, metrics en live datafeeds.
Leer hoe je JSONL-gegevens importeert en exporteert met PostgreSQL, MongoDB, MySQL en SQLite databases.
Leer hoe je JSONL-bestanden valideert met JSON Schema. Behandelt Python, Node.js, CLI-tools en CI/CD-automatisering.
Strategieën om gigabytes aan JSONL-data te verwerken. Met aandacht voor lezen via streaming, geheugenbeheer, het splitsen van bestanden, compressie en online tools.
Valideer JSONL-bestanden regel voor regel. Spoor syntaxfouten, tekencoderingsproblemen en fouten in het formaat direct op.