Par Jerry Fan

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)

Universel

Le 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 compression

Créé 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èregzipzstdBrotli
Taux de compressionBon (5-8x)Très bon (6-10x)Excellent (7-12x)
Vitesse de compressionModéréeRapideLente à modérée
Vitesse de décompressionModéréeTrès rapideRapide
Utilisation du CPUModéréeFaible à modéréeÉlevée (au niveau maximal)
Prise en charge par les navigateursTous les navigateursChrome 123+, Firefox 126+Tous les navigateurs modernes
Prise en charge du streamingOui (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 niveauTaille compresséeRatioTemps de compressionTemps de décompression
gzip (niveau 6)14,2 Mo7,0x2,8s0,9s
gzip (niveau 9)13,1 Mo7,6x8,4s0,9s
zstd (niveau 3)12,8 Mo7,8x0,6s0,3s
zstd (niveau 1)15,1 Mo6,6x0,3s0,3s
Brotli (niveau 6)11,5 Mo8,7x3,2s0,5s
Brotli (niveau 11)9,8 Mo10,2x42,1s0,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.

Python : gzip, zstd et Brotli
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.

Node.js : gzip et Brotli avec zlib
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.

Ligne de commande : gzip, zstd et Brotli
# === 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 -l

Straté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.

Utiliser la compression avec AWS S3
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.

Utiliser la compression avec Google Cloud Storage
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.json

Bonnes 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.

Manipulez vos fichiers JSONL en ligne

Consultez, validez et convertissez des fichiers JSONL jusqu’à 1 Go directement dans votre navigateur. Aucun fichier n’est envoyé sur un serveur : vos données restent 100% privées.

Questions fréquentes

Références