Compression JSONL : gzip, zstd et Brotli
Un guide pratique pour compresser vos fichiers JSONL. Comparez les taux de compression et les performances, et découvrez quand utiliser gzip, zstd ou Brotli pour vos pipelines de données, le stockage cloud et la diffusion sur le web.
Pourquoi compresser les fichiers JSONL ?
Les fichiers JSONL grossissent vite. Une seule journée de logs applicatifs peut générer des gigaoctets de JSON à raison d’un enregistrement par ligne, et les jeux de données de machine learning atteignent couramment plusieurs dizaines de gigaoctets. Sans compression, le stockage coûte plus cher, les transferts prennent plus de temps et les entrées-sorties deviennent le goulot d’étranglement de votre pipeline de données. À grande échelle, la compression est indispensable pour traiter efficacement des données JSONL.
Le format JSONL se compresse particulièrement bien. Le JSON est un format texte répétitif : les mêmes clés, délimiteurs et structures reviennent sans cesse. Les algorithmes de compression exploitent cette redondance pour diviser la taille des fichiers par 5 à 15. Reste à choisir l’algorithme adapté à votre usage : gzip offre une compatibilité universelle, zstd le meilleur compromis entre vitesse et taux de compression, et Brotli la compression la plus poussée pour les ressources statiques. Ce guide compare les trois à l’aide de benchmarks réels, d’exemples de code fonctionnels et de recommandations concrètes.
Les algorithmes de compression en bref
Trois algorithmes dominent la compression des fichiers JSONL. Chacun repose sur des stratégies différentes et répond à des besoins spécifiques. Comprendre leurs avantages et leurs limites vous aidera à choisir celui qui convient à vos traitements.
gzip (DEFLATE)
UniverselLe standard universel. Présent depuis 1992, gzip est pris en charge partout : dans tous les langages de programmation, sur tous les systèmes d’exploitation, chez tous les fournisseurs cloud et dans tous les navigateurs web. Il repose sur l’algorithme DEFLATE, qui combine LZ77 et le codage de Huffman. Sans être le plus rapide ni le plus efficace, gzip reste une valeur sûre lorsque la compatibilité prime, grâce à sa prise en charge généralisée.
Zstandard (zstd)
RecommandéDéveloppé par Facebook en 2016, zstd est un algorithme moderne et polyvalent de compression de données. Il compresse et décompresse nettement plus vite que gzip, avec des taux de compression équivalents ou meilleurs. Zstd propose aussi la compression par dictionnaire, particulièrement efficace pour les fichiers JSONL dont toutes les lignes partagent la même structure de clés. C’est le meilleur choix pour les pipelines de données et le traitement en temps réel.
Brotli
Meilleur taux de compressionCréé par Google, Brotli offre les meilleurs taux de compression des trois algorithmes, surtout aux niveaux de compression maximaux. Il combine LZ77, le codage de Huffman et un dictionnaire statique intégré de contenus web courants. Brotli excelle pour compresser du JSONL destiné à être distribué par HTTP ou stocké sous forme statique. En revanche, aux niveaux élevés, sa compression est nettement plus lente que celle de gzip ou de zstd.
Comparaison des trois algorithmes
Le tableau suivant présente les principales différences entre gzip, zstd et Brotli selon les critères les plus pertinents pour la compression de fichiers JSONL. Il s’agit de caractéristiques générales avec les réglages par défaut : les performances réelles dépendent des données et du niveau de compression.
| Critère | gzip | zstd | Brotli |
|---|---|---|---|
| Taux de compression | Bon (5-8x) | Très bon (6-10x) | Excellent (7-12x) |
| Vitesse de compression | Modérée | Rapide | Lente à modérée |
| Vitesse de décompression | Modérée | Très rapide | Rapide |
| Utilisation du CPU | Modérée | Faible à modérée | Élevée (au niveau maximal) |
| Prise en charge par les navigateurs | Tous les navigateurs | Chrome 123+, Firefox 126+ | Tous les navigateurs modernes |
| Prise en charge du streaming | Oui (natif) | Oui (natif) | Limitée |
Résultats des benchmarks : fichier JSONL de 100 Mo
Voici des chiffres concrets obtenus en compressant un fichier JSONL de 100 Mo contenant des logs applicatifs. Chaque enregistrement comporte 12 champs, dont des horodatages, des niveaux de log, des messages textuels et des objets de métadonnées imbriqués. Les tests ont été réalisés sur un AMD Ryzen 7 avec 32 Go de RAM et un stockage NVMe.
| Algorithme et niveau | Taille compressée | Ratio | Temps de compression | Temps de décompression |
|---|---|---|---|---|
| gzip (niveau 6) | 14,2 Mo | 7,0x | 2,8s | 0,9s |
| gzip (niveau 9) | 13,1 Mo | 7,6x | 8,4s | 0,9s |
| zstd (niveau 3) | 12,8 Mo | 7,8x | 0,6s | 0,3s |
| zstd (niveau 1) | 15,1 Mo | 6,6x | 0,3s | 0,3s |
| Brotli (niveau 6) | 11,5 Mo | 8,7x | 3,2s | 0,5s |
| Brotli (niveau 11) | 9,8 Mo | 10,2x | 42,1s | 0,4s |
Ces benchmarks sont représentatifs de logs JSONL typiques. Les résultats varient selon la cardinalité des champs, l’entropie des valeurs et la structure des enregistrements. Les fichiers dont les clés se répètent beaucoup et dont les valeurs ont une faible entropie, comme les niveaux de log ou les codes de statut, se compressent mieux que ceux contenant des chaînes uniques à forte entropie.
Exemples de code pour compresser du JSONL
Voici des exemples pratiques pour compresser et décompresser des fichiers JSONL en Python, en Node.js et en ligne de commande. Ils montrent comment utiliser chacun des trois algorithmes.
Python prend en charge gzip nativement. Pour zstd et Brotli, installez les paquets pyzstd et brotli. Le principe est le même pour les trois : ouvrez un fichier compressé, puis utilisez l’objet fichier obtenu pour lire ou écrire les lignes JSONL.
import gzip
import json
# === gzip (integre) ===
# Ecrire du JSONL compresse
with gzip.open('data.jsonl.gz', 'wt', encoding='utf-8') as f:
for record in records:
f.write(json.dumps(record, ensure_ascii=False) + '\n')
# Lire du JSONL compresse
with gzip.open('data.jsonl.gz', 'rt', encoding='utf-8') as f:
for line in f:
record = json.loads(line)
# === zstd (pip install pyzstd) ===
import pyzstd
# Ecrire du JSONL compresse
with pyzstd.open('data.jsonl.zst', 'wt', encoding='utf-8') as f:
for record in records:
f.write(json.dumps(record, ensure_ascii=False) + '\n')
# Lire du JSONL compresse
with pyzstd.open('data.jsonl.zst', 'rt', encoding='utf-8') as f:
for line in f:
record = json.loads(line)
# === Brotli (pip install brotli) ===
import brotli
# Compresser un fichier JSONL entier
with open('data.jsonl', 'rb') as f:
raw = f.read()
compressed = brotli.compress(raw, quality=6)
with open('data.jsonl.br', 'wb') as f:
f.write(compressed)
# Decompresser
with open('data.jsonl.br', 'rb') as f:
raw = brotli.decompress(f.read())
for line in raw.decode('utf-8').splitlines():
record = json.loads(line)Node.js prend en charge gzip et Brotli nativement via le module zlib. Pour zstd, utilisez le paquet npm @aspect-build/zstd ou fzstd. L’API de streaming est idéale pour traiter de gros fichiers JSONL sans les charger entièrement en mémoire.
import { createReadStream, createWriteStream } from 'fs';
import { createGzip, createGunzip, createBrotliCompress,
createBrotliDecompress } from 'zlib';
import { createInterface } from 'readline';
import { pipeline } from 'stream/promises';
// === compression gzip ===
await pipeline(
createReadStream('data.jsonl'),
createGzip({ level: 6 }),
createWriteStream('data.jsonl.gz')
);
// === decompression gzip et analyse ===
const gunzip = createGunzip();
const rl = createInterface({
input: createReadStream('data.jsonl.gz').pipe(gunzip),
});
for await (const line of rl) {
if (line.trim()) {
const record = JSON.parse(line);
// traiter l'enregistrement
}
}
// === compression Brotli ===
await pipeline(
createReadStream('data.jsonl'),
createBrotliCompress(),
createWriteStream('data.jsonl.br')
);
// === decompression Brotli et analyse ===
const br = createBrotliDecompress();
const rl2 = createInterface({
input: createReadStream('data.jsonl.br').pipe(br),
});
for await (const line of rl2) {
if (line.trim()) {
const record = JSON.parse(line);
}
}Les outils en ligne de commande sont le moyen le plus rapide de compresser des fichiers JSONL. gzip est préinstallé sur tous les systèmes Unix. Pour les deux autres algorithmes, installez zstd et brotli avec votre gestionnaire de paquets.
# === gzip ===
# Compresser (garde l'original par defaut avec -k)
gzip -k data.jsonl # -> data.jsonl.gz
gzip -9 -k data.jsonl # compression maximale
# Decompresser
gzip -d data.jsonl.gz
# ou : gunzip data.jsonl.gz
# === zstd ===
# Installer : brew install zstd / apt install zstd
zstd data.jsonl # -> data.jsonl.zst
zstd -3 data.jsonl # niveau 3 (defaut)
zstd --fast data.jsonl # compression la plus rapide
# Decompresser
zstd -d data.jsonl.zst
# ou : unzstd data.jsonl.zst
# === Brotli ===
# Installer : brew install brotli / apt install brotli
brotli data.jsonl # -> data.jsonl.br
brotli -q 6 data.jsonl # qualite 6
brotli -q 11 data.jsonl # compression maximale
# Decompresser
brotli -d data.jsonl.br
# === Piping avec jq ===
# Compresser du JSONL filtre
cat data.jsonl | jq -c 'select(.level == "error")' | gzip > errors.jsonl.gz
# Decompresser et compter les lignes
zstd -dc data.jsonl.zst | wc -lStratégies de compression pour le stockage cloud
Pour les fichiers JSONL conservés dans un stockage objet cloud, la compression réduit à la fois les coûts de stockage et les temps de transfert. La plupart des fournisseurs cloud proposent une décompression transparente de gzip et de Brotli via leurs CDN, mais les stratégies d’envoi et de stockage diffèrent.
Envoyez vos fichiers JSONL compressés vers S3 en renseignant correctement l’en-tête Content-Encoding. S3 stocke les octets compressés, et CloudFront peut distribuer ces fichiers avec décompression automatique. Pour les traitements sur un data lake, des outils comme AWS Athena et Spark lisent nativement les fichiers JSONL compressés avec gzip ou zstd.
import boto3
import gzip
import json
s3 = boto3.client('s3')
# Telecharger du JSONL compresse en gzip vers S3
def upload_compressed_jsonl(records, bucket, key):
# Compresser en memoire
compressed = gzip.compress(
'\n'.join(
json.dumps(r, ensure_ascii=False) for r in records
).encode('utf-8')
)
s3.put_object(
Bucket=bucket,
Key=f'{key}.jsonl.gz',
Body=compressed,
ContentType='application/x-ndjson',
ContentEncoding='gzip',
)
print(f'Uploaded {len(compressed)} bytes (compressed)')
# Telecharger et decompresser
def download_compressed_jsonl(bucket, key):
response = s3.get_object(Bucket=bucket, Key=key)
raw = gzip.decompress(response['Body'].read())
return [
json.loads(line)
for line in raw.decode('utf-8').splitlines()
if line.strip()
]Google Cloud Storage prend en charge le transcodage gzip. Si vous envoyez un objet compressé avec gzip en définissant l’en-tête Content-Encoding: gzip, GCS peut automatiquement servir sa version décompressée lorsque les clients envoient Accept-Encoding: gzip. Pour les imports dans BigQuery, utilisez directement les fichiers JSONL compressés avec gzip.
from google.cloud import storage
import gzip
import json
client = storage.Client()
bucket = client.bucket('my-data-bucket')
# Telecharger du JSONL compresse en gzip
def upload_compressed(records, blob_name):
blob = bucket.blob(f'{blob_name}.jsonl.gz')
blob.content_encoding = 'gzip'
blob.content_type = 'application/x-ndjson'
data = '\n'.join(
json.dumps(r, ensure_ascii=False) for r in records
).encode('utf-8')
blob.upload_from_string(
gzip.compress(data),
content_type='application/x-ndjson',
)
# BigQuery : charger du JSONL compresse directement
# bq load --source_format=NEWLINE_DELIMITED_JSON \
# my_dataset.my_table gs://bucket/data.jsonl.gz schema.jsonBonnes pratiques : quel algorithme choisir selon l’usage ?
Aucun algorithme de compression n’est le meilleur dans tous les cas. Le choix dépend de votre priorité : réduire l’espace de stockage, accélérer les traitements, garantir la compatibilité ou trouver un équilibre entre les trois. Voici des recommandations pour les usages courants du JSONL.
Archivage et stockage à froid
Utilisez Brotli (qualité 9-11) ou zstd (niveau 19+) pour une compression maximale.
Pour l’archivage, le temps de compression compte moins : vous compressez une fois et décompressez rarement. Avec une qualité de 11, Brotli peut réduire la taille des données JSONL d’un facteur de 10 ou plus, ce qui diminue nettement les coûts de stockage à long terme.
Pipelines de données en temps réel
Utilisez zstd (niveau 1-3) pour le meilleur compromis entre vitesse et taux de compression.
Dans les pipelines de streaming (Kafka, Kinesis, Flink), la vitesse de compression et de décompression influe directement sur le débit et la latence. Au niveau 1, zstd compresse plus vite que gzip tout en offrant de meilleurs taux de compression. Son mode dictionnaire est idéal pour les données JSONL à schéma fixe.
Diffusion sur le web et API
Utilisez Brotli pour les fichiers statiques et gzip en solution de repli pour une compatibilité maximale.
Tous les navigateurs modernes prennent en charge Brotli via Accept-Encoding: br. Les CDN comme Cloudflare et CloudFront peuvent compresser automatiquement avec Brotli. Prévoyez gzip en solution de repli pour les clients plus anciens. La prise en charge de zstd progresse dans les navigateurs, mais elle n’est pas encore universelle.
ETL et traitement par lots
Utilisez gzip pour une compatibilité maximale, ou zstd pour de meilleures performances.
La plupart des outils de traitement de données (Spark, Athena, BigQuery, pandas) prennent en charge gzip nativement. La prise en charge de zstd progresse rapidement. Si vos outils le permettent, privilégiez zstd : la compression est 3 à 5 fois plus rapide, à taux de compression comparables.
Essayez nos outils JSONL gratuits
Compressez vos fichiers JSONL avant de les envoyer, ou validez-les et convertissez-les avec nos outils en ligne gratuits. Aucune installation nécessaire.
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.
Maîtrisez les bonnes pratiques JSONL : mise en forme, cohérence des schémas, gestion des erreurs, optimisation des performances et organisation des fichiers. Des exemples concrets vous aident à éviter les pièges courants.
Divisez les grands fichiers JSONL en morceaux plus petits et gérables par nombre de lignes.
Combinez plusieurs fichiers JSONL en un seul avec dédoublonnage.
Comparez JSONL et Parquet pour savoir quel format utiliser pour vos pipelines de données, vos analyses, l’entraînement de modèles de machine learning et le stockage. Retrouvez des benchmarks de performances et un guide d’architecture hybride.