Di Jerry Fan

Compressione JSONL: gzip vs zstd vs Brotli

Una guida pratica per comprimere i file JSONL. Confronta i rapporti di compressione e i benchmark di velocità e scopri quando usare gzip, zstd o Brotli nelle tue pipeline di dati, nello storage cloud e nella distribuzione via web.

Perché comprimere i file JSONL?

I file JSONL crescono in fretta. Una sola giornata di log applicativi può generare gigabyte di JSON con un record per riga, mentre i dataset di machine learning raggiungono abitualmente le decine di gigabyte. Senza compressione, spendi di più per lo storage, i trasferimenti richiedono più tempo e l'I/O diventa il collo di bottiglia della tua pipeline di dati. Su larga scala, la compressione è indispensabile per lavorare in modo efficiente con i dati JSONL.

La buona notizia è che i file JSONL si comprimono molto bene. Il formato JSON contiene molte ripetizioni di chiavi, delimitatori e strutture: gli algoritmi di compressione sfruttano questa ridondanza per ridurre le dimensioni di un fattore da 5x a 15x. Il punto è scegliere l'algoritmo più adatto al tuo caso d'uso: gzip offre compatibilità universale, zstd il miglior compromesso tra velocità e rapporto di compressione, e Brotli la compressione più spinta per le risorse statiche. Questa guida mette a confronto tutti e tre con benchmark reali, esempi di codice funzionanti e consigli pratici.

Panoramica degli algoritmi di compressione

Tre algoritmi sono i più usati per comprimere i file JSONL. Ognuno adotta strategie diverse ed è ottimizzato per scenari specifici. Conoscerne vantaggi e limiti ti aiuta a scegliere quello più adatto al tuo carico di lavoro.

gzip (DEFLATE)

Universale

Lo standard universale. gzip esiste dal 1992 ed è supportato ovunque: da ogni linguaggio di programmazione, sistema operativo, provider cloud e browser web. Usa l'algoritmo DEFLATE, che combina LZ77 e la codifica di Huffman. Non è il più veloce né il più efficiente, ma la sua diffusione lo rende una scelta predefinita affidabile quando la compatibilità è la priorità.

Zstandard (zstd)

Consigliato

Sviluppato da Facebook nel 2016, zstd è un punto di riferimento moderno per la compressione dei dati. Comprime e decomprime molto più velocemente di gzip, con rapporti di compressione uguali o migliori. Supporta anche la compressione con dizionario, particolarmente efficace per i file JSONL in cui ogni riga presenta la stessa struttura delle chiavi. È la scelta migliore per le pipeline di dati e l’elaborazione in tempo reale.

Brotli

Miglior rapporto di compressione

Creato da Google, Brotli offre i rapporti di compressione più elevati fra i tre algoritmi, soprattutto ai livelli massimi. Combina LZ77, la codifica di Huffman e un dizionario statico integrato di contenuti web comuni. È particolarmente efficace per comprimere file JSONL destinati alla distribuzione via HTTP e allo storage statico, ma ai livelli più alti la compressione è molto più lenta rispetto a gzip o zstd.

Confronto diretto

La tabella seguente riassume le principali differenze tra gzip, zstd e Brotli in base alle metriche più rilevanti per la compressione dei file JSONL. Sono indicazioni generali riferite alle impostazioni predefinite: le prestazioni effettive dipendono dai dati e dal livello di compressione.

MetricagzipzstdBrotli
Rapporto di compressioneBuono (5-8x)Molto buono (6-10x)Eccellente (7-12x)
Velocità di compressioneModerataVeloceDa lenta a moderata
Velocità di decompressioneModerataMolto veloceVeloce
Utilizzo della CPUModeratoDa basso a moderatoAlto (al livello massimo)
Supporto nei browserTutti i browserChrome 123+, Firefox 126+Tutti i browser moderni
Supporto allo streamingSì (nativo)Sì (nativo)Limitato

Risultati dei benchmark: file JSONL da 100 MB

Per avere un riferimento concreto, ecco i risultati dei benchmark sulla compressione di un file JSONL da 100 MB contenente log applicativi. Ogni record comprende 12 campi, tra cui timestamp, livelli di log, messaggi di testo e oggetti di metadati annidati. I test sono stati eseguiti su un AMD Ryzen 7 con 32 GB di RAM e storage NVMe.

Algoritmo e livelloDimensioni del file compressoRapportoTempo di compressioneTempo di decompressione
gzip (livello 6)14.2 MB7.0x2.8s0.9s
gzip (livello 9)13.1 MB7.6x8.4s0.9s
zstd (livello 3)12.8 MB7.8x0.6s0.3s
zstd (livello 1)15.1 MB6.6x0.3s0.3s
Brotli (livello 6)11.5 MB8.7x3.2s0.5s
Brotli (livello 11)9.8 MB10.2x42.1s0.4s

Questi benchmark sono rappresentativi dei comuni dati di log in formato JSONL. I risultati dipendono dalla cardinalità dei campi, dall’entropia dei valori e dalla struttura dei record. I file con chiavi che si ripetono spesso e valori a bassa entropia, come livelli di log o codici di stato, si comprimono meglio di quelli con stringhe univoche ad alta entropia.

Esempi di codice per la compressione

Ecco alcuni esempi pratici per comprimere e decomprimere file JSONL in Python, Node.js e da riga di comando. Ogni esempio illustra come usare tutti e tre gli algoritmi.

Python supporta gzip in modo nativo. Per zstd e Brotli, installa i pacchetti pyzstd e brotli. Il procedimento è lo stesso per tutti e tre: apri un file compresso e usa l’handle ottenuto per leggere o scrivere le righe JSONL.

Python: gzip, zstd e Brotli
import gzip
import json


# === gzip (built-in) ===
# Write compressed JSONL
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')


# Read compressed JSONL
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


# Write compressed JSONL
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')


# Read compressed JSONL
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


# Compress an entire JSONL file
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)


# Decompress
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 supporta sia gzip sia Brotli tramite il modulo integrato zlib. Per zstd, usa il pacchetto npm @aspect-build/zstd oppure fzstd. L’API basata su stream è ideale per elaborare file JSONL di grandi dimensioni senza caricarli interamente in memoria.

Node.js: gzip e Brotli con zlib
import { createReadStream, createWriteStream } from 'fs';
import { createGzip, createGunzip, createBrotliCompress,
         createBrotliDecompress } from 'zlib';
import { createInterface } from 'readline';
import { pipeline } from 'stream/promises';


// === gzip compress ===
await pipeline(
  createReadStream('data.jsonl'),
  createGzip({ level: 6 }),
  createWriteStream('data.jsonl.gz')
);


// === gzip decompress & parse ===
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);
    // process record
  }
}


// === Brotli compress ===
await pipeline(
  createReadStream('data.jsonl'),
  createBrotliCompress(),
  createWriteStream('data.jsonl.br')
);


// === Brotli decompress & parse ===
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);
  }
}

Gli strumenti da riga di comando sono il modo più rapido per comprimere i file JSONL. gzip è preinstallato su tutti i sistemi Unix. Per usare gli altri due algoritmi, installa zstd e brotli con il tuo gestore di pacchetti.

Riga di comando: gzip, zstd e Brotli
# === gzip ===
# Compress (keeps original by default with -k)
gzip -k data.jsonl                # -> data.jsonl.gz
gzip -9 -k data.jsonl              # max compression


# Decompress
gzip -d data.jsonl.gz
# or: gunzip data.jsonl.gz


# === zstd ===
# Install: brew install zstd / apt install zstd
zstd data.jsonl                    # -> data.jsonl.zst
zstd -3 data.jsonl                 # level 3 (default)
zstd --fast data.jsonl             # fastest compression


# Decompress
zstd -d data.jsonl.zst
# or: unzstd data.jsonl.zst


# === Brotli ===
# Install: brew install brotli / apt install brotli
brotli data.jsonl                  # -> data.jsonl.br
brotli -q 6 data.jsonl             # quality 6
brotli -q 11 data.jsonl            # max compression


# Decompress
brotli -d data.jsonl.br


# === Piping with jq ===
# Compress filtered JSONL
cat data.jsonl | jq -c 'select(.level == "error")' | gzip > errors.jsonl.gz


# Decompress and count lines
zstd -dc data.jsonl.zst | wc -l

Strategie di compressione per lo storage cloud

Quando archivi file JSONL nello storage a oggetti del cloud, la compressione riduce sia i costi di storage sia i tempi di trasferimento. La maggior parte dei provider cloud supporta la decompressione trasparente di gzip e Brotli tramite le proprie CDN, ma le strategie di caricamento e archiviazione variano.

Carica i file JSONL compressi su S3 impostando correttamente l’header Content-Encoding. S3 memorizza i byte compressi e CloudFront può distribuirli con decompressione automatica. Nei carichi di lavoro dei data lake, strumenti come AWS Athena e Spark leggono nativamente i file JSONL compressi con gzip e zstd.

Compressione con AWS S3
import boto3
import gzip
import json


s3 = boto3.client('s3')


# Upload gzip-compressed JSONL to S3
def upload_compressed_jsonl(records, bucket, key):
    # Compress in memory
    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)')


# Download and decompress
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 supporta la transcodifica gzip. Quando carichi un oggetto compresso con gzip impostando l’header Content-Encoding: gzip, GCS può distribuire automaticamente la versione decompressa quando i client inviano Accept-Encoding: gzip. Per le importazioni in BigQuery, usa direttamente i file JSONL compressi con gzip.

Compressione con Google Cloud Storage
from google.cloud import storage
import gzip
import json


client = storage.Client()
bucket = client.bucket('my-data-bucket')


# Upload gzip-compressed JSONL
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: load compressed JSONL directly
# bq load --source_format=NEWLINE_DELIMITED_JSON \
#   my_dataset.my_table gs://bucket/data.jsonl.gz schema.json

Buone pratiche: quale algoritmo usare e quando

Non esiste un algoritmo di compressione migliore in assoluto. La scelta dipende dalla tua priorità: ridurre lo spazio occupato, velocizzare l’elaborazione, garantire la compatibilità o trovare un equilibrio fra questi tre aspetti. Ecco alcuni consigli per i casi d’uso più comuni di JSONL.

Archiviazione a lungo termine e cold storage

Usa Brotli (qualità 9-11) o zstd (livello 19+) per ottenere la massima compressione.

Nell’archiviazione a lungo termine, il tempo di compressione conta meno: comprimi una volta e decomprimi raramente. Brotli con qualità 11 può raggiungere un rapporto di compressione di 10x+ sui dati JSONL, riducendo sensibilmente i costi di storage nel tempo.

Pipeline di dati in tempo reale

Usa zstd (livello 1-3) per il miglior compromesso tra velocità e rapporto di compressione.

Nelle pipeline di streaming (Kafka, Kinesis, Flink), la velocità di compressione e decompressione influisce direttamente su throughput e latenza. Al livello 1, zstd comprime più velocemente di gzip e offre rapporti di compressione migliori. La modalità con dizionario è ideale per i file JSONL con schema fisso.

Distribuzione via web e API

Usa Brotli per i file statici e gzip come fallback per garantire la massima compatibilità.

Tutti i browser moderni supportano Brotli tramite Accept-Encoding: br. Le CDN come Cloudflare e CloudFront possono comprimere automaticamente i contenuti con Brotli. Usa gzip come fallback per i client meno recenti. Il supporto a zstd nei browser è in crescita, ma non è ancora universale.

ETL ed elaborazione batch

Usa gzip per la massima compatibilità oppure zstd per prestazioni migliori.

La maggior parte degli strumenti per l’elaborazione dei dati (Spark, Athena, BigQuery, pandas) supporta gzip in modo nativo. Il supporto a zstd sta migliorando rapidamente. Se la tua toolchain lo supporta, preferisci zstd: la compressione è 3-5 volte più veloce, con rapporti di compressione comparabili.

Lavora con i file JSONL online

Visualizza, valida e converti file JSONL fino a 1GB direttamente nel browser. Non devi caricare alcun file: la privacy è garantita al 100%.

Domande frequenti

Riferimenti