Door Jerry Fan

JSONL-compressie: gzip, zstd en Brotli vergeleken

Een praktische gids voor het comprimeren van JSONL-bestanden. Vergelijk compressieverhoudingen en snelheidsbenchmarks en ontdek wanneer je gzip, zstd of Brotli gebruikt voor je datapipelines, cloudopslag en het aanbieden van bestanden via het web.

Waarom JSONL-bestanden comprimeren?

JSONL-bestanden groeien snel. Eén dag aan applicatielogs kan al gigabytes aan JSON met één record per regel opleveren, en datasets voor machine learning beslaan al gauw tientallen gigabytes. Zonder compressie betaal je meer voor opslag, duurt de gegevensoverdracht langer en wordt I/O de bottleneck in je datapipeline. Bij grote hoeveelheden data is compressie onmisbaar om efficiënt met JSONL te werken.

Gelukkig laat JSONL zich bijzonder goed comprimeren. JSON bevat veel herhaling: dezelfde keys, scheidingstekens en structuurpatronen komen steeds terug. Compressiealgoritmen benutten die herhaling om bestanden 5x tot 15x kleiner te maken. Het gaat erom het juiste algoritme voor je toepassing te kiezen: gzip biedt universele compatibiliteit, zstd biedt de beste balans tussen snelheid en compressieverhouding en Brotli comprimeert statische bestanden het sterkst. In deze gids vergelijken we alle drie aan de hand van echte benchmarks, werkende codevoorbeelden en duidelijke aanbevelingen.

Overzicht van compressiealgoritmen

Voor JSONL-compressie worden vooral drie algoritmen gebruikt. Elk algoritme pakt compressie anders aan en is geoptimaliseerd voor andere situaties. Als je hun voor- en nadelen kent, kun je de juiste keuze maken voor je workload.

gzip (DEFLATE)

Universeel

De universele standaard. gzip bestaat sinds 1992 en wordt overal ondersteund: in elke programmeertaal, op elk besturingssysteem, bij elke cloudprovider en in elke webbrowser. Het gebruikt het DEFLATE-algoritme, dat LZ77 en Huffman-codering combineert. gzip is niet het snelste of efficiëntste algoritme, maar dankzij die brede ondersteuning is het een veilige standaardkeuze als compatibiliteit vooropstaat.

Zstandard (zstd)

Aanbevolen

zstd werd in 2016 ontwikkeld door Facebook en is inmiddels een veelgebruikt, modern algoritme voor datacompressie. Het comprimeert en decomprimeert aanzienlijk sneller dan gzip, met vergelijkbare of betere compressieverhoudingen. Zstd ondersteunt ook dictionarycompressie. Dat werkt vooral goed bij JSONL-bestanden waarin elke regel dezelfde structuur van keys heeft. Het is de beste keuze voor datapipelines en realtimeverwerking.

Brotli

Hoogste compressieverhouding

Brotli is ontwikkeld door Google en haalt van deze drie algoritmen de hoogste compressieverhoudingen, vooral op de hoogste compressieniveaus. Het combineert LZ77 en Huffman-codering met een ingebouwde statische dictionary met veelvoorkomende webcontent. Brotli is bijzonder geschikt om JSONL te comprimeren voor HTTP-overdracht en statische opslag, maar op hoge compressieniveaus is het duidelijk langzamer dan gzip of zstd.

De algoritmen vergeleken

De volgende tabel toont de belangrijkste verschillen tussen gzip, zstd en Brotli op de punten die het meest tellen bij JSONL-compressie. Dit zijn algemene kenmerken bij de standaardinstellingen. De werkelijke prestaties hangen af van de data en het compressieniveau.

EigenschapgzipzstdBrotli
CompressieverhoudingGoed (5-8x)Zeer goed (6-10x)Uitstekend (7-12x)
CompressiesnelheidGemiddeldSnelLangzaam tot gemiddeld
DecompressiesnelheidGemiddeldZeer snelSnel
CPU-gebruikGemiddeldLaag tot gemiddeldHoog (op het hoogste niveau)
BrowserondersteuningAlle browsersChrome 123+, Firefox 126+Alle moderne browsers
Ondersteuning voor streamingJa (native)Ja (native)Beperkt

Benchmarkresultaten: een JSONL-bestand van 100 MB

Hieronder zie je concrete benchmarkresultaten voor het comprimeren van een JSONL-bestand van 100 MB met applicatielogs. Elk record bevat 12 velden, waaronder tijdstempels, logniveaus, berichten als strings en geneste metadata-objecten. De tests zijn uitgevoerd op een AMD Ryzen 7 met 32 GB RAM en NVMe-opslag.

Algoritme en niveauBestandsgrootte na compressieCompressieverhoudingCompressietijdDecompressietijd
gzip (niveau 6)14,2 MB7,0x2,8s0,9s
gzip (niveau 9)13,1 MB7,6x8,4s0,9s
zstd (niveau 3)12,8 MB7,8x0,6s0,3s
zstd (niveau 1)15,1 MB6,6x0,3s0,3s
Brotli (niveau 6)11,5 MB8,7x3,2s0,5s
Brotli (niveau 11)9,8 MB10,2x42,1s0,4s

Deze benchmarks zijn representatief voor gangbare JSONL-logdata. De resultaten hangen af van de cardinaliteit van de velden, de entropie van de waarden en de recordstructuur. Bestanden waarin dezelfde keys vaak terugkomen en de waarden weinig entropie hebben, zoals logniveaus of statuscodes, laten zich beter comprimeren dan bestanden met unieke strings met een hoge entropie.

Codevoorbeelden voor compressie

Hieronder vind je praktische voorbeelden om JSONL-bestanden te comprimeren en te decomprimeren in Python, Node.js en via de commandoregel. Elk voorbeeld laat zien hoe je met alle drie de algoritmen werkt.

Python heeft ingebouwde ondersteuning voor gzip. Voor zstd en Brotli installeer je de pakketten pyzstd en brotli. Bij alle drie volg je hetzelfde patroon: je opent een bestandshandle voor een gecomprimeerd bestand en gebruikt die om JSONL-regels te lezen of te schrijven.

Python: gzip, zstd & Brotli
import gzip
import json


# === gzip (ingebouwd) ===
# Schrijf gecomprimeerde 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')


# Lees gecomprimeerde 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


# Schrijf gecomprimeerde 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')


# Lees gecomprimeerde 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


# Comprimeer een heel JSONL-bestand
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)


# Decomprimeer
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 heeft via de module zlib ingebouwde ondersteuning voor zowel gzip als Brotli. Voor zstd gebruik je het npm-pakket @aspect-build/zstd of fzstd. De API werkt met streams en is daardoor ideaal om grote JSONL-bestanden te verwerken zonder ze volledig in het geheugen te laden.

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


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


// === gzip decomprimeren & parseren ===
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);
    // verwerk record
  }
}


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


// === Brotli decomprimeren & parseren ===
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);
  }
}

Met commandoregeltools comprimeer je JSONL-bestanden het snelst. gzip is op alle Unix-systemen vooraf geïnstalleerd. Voor de andere twee algoritmen installeer je zstd en brotli via je pakketbeheerder.

Commandoregel: gzip, zstd & Brotli
# === gzip ===
# Comprimeren (behoudt origineel standaard met -k)
gzip -k data.jsonl                # -> data.jsonl.gz
gzip -9 -k data.jsonl              # maximale compressie


# Decomprimeren
gzip -d data.jsonl.gz
# of: gunzip data.jsonl.gz


# === zstd ===
# Installeren: brew install zstd / apt install zstd
zstd data.jsonl                    # -> data.jsonl.zst
zstd -3 data.jsonl                 # niveau 3 (standaard)
zstd --fast data.jsonl             # snelste compressie


# Decomprimeren
zstd -d data.jsonl.zst
# of: unzstd data.jsonl.zst


# === Brotli ===
# Installeren: brew install brotli / apt install brotli
brotli data.jsonl                  # -> data.jsonl.br
brotli -q 6 data.jsonl             # kwaliteit 6
brotli -q 11 data.jsonl            # maximale compressie


# Decomprimeren
brotli -d data.jsonl.br


# === Piping met jq ===
# Comprimeer gefilterde JSONL
cat data.jsonl | jq -c 'select(.level == "error")' | gzip > errors.jsonl.gz


# Decomprimeer en tel regels
zstd -dc data.jsonl.zst | wc -l

Compressiestrategieën voor cloudopslag

Als je JSONL-bestanden in objectopslag in de cloud bewaart, bespaar je met compressie op opslagkosten en overdrachtstijd. De meeste cloudproviders ondersteunen transparante decompressie van gzip en Brotli via hun CDN-laag, maar de aanpak voor uploaden en opslaan verschilt.

Upload gecomprimeerde JSONL naar S3 met de juiste Content-Encoding-header. S3 slaat de gecomprimeerde bytes op en CloudFront kan de bestanden met automatische decompressie aanbieden. Voor datalakes kunnen tools als AWS Athena en Spark JSONL met gzip- of zstd-compressie direct lezen.

AWS S3 met compressie
import boto3
import gzip
import json


s3 = boto3.client('s3')


# Upload gzip-gecomprimeerde JSONL naar S3
def upload_compressed_jsonl(records, bucket, key):
    # Comprimeer in geheugen
    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'{len(compressed)} bytes geüpload (gecomprimeerd)')


# Download en decomprimeer
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 ondersteunt gzip-transcodering. Als je een met gzip gecomprimeerd object uploadt met de header Content-Encoding: gzip, kan GCS automatisch de gedecomprimeerde versie aanbieden wanneer clients Accept-Encoding: gzip meesturen. Voor imports in BigQuery kun je JSONL met gzip-compressie direct gebruiken.

Google Cloud Storage met compressie
from google.cloud import storage
import gzip
import json


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


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

Best practices: welk algoritme gebruik je wanneer?

Geen enkel compressiealgoritme is in alle situaties het beste. De juiste keuze hangt af van wat voor jou het zwaarst weegt: bestandsgrootte, verwerkingssnelheid, compatibiliteit of een balans tussen die drie. Hieronder vind je concrete aanbevelingen voor veelvoorkomende toepassingen van JSONL.

Archivering en cold storage

Gebruik Brotli (kwaliteit 9-11) of zstd (niveau 19+) voor maximale compressie.

Bij archivering is de compressietijd minder belangrijk. Je comprimeert eenmalig en decomprimeert zelden. Met Brotli op kwaliteitsniveau 11 kun je JSONL-data 10x+ kleiner maken, wat de opslagkosten op lange termijn aanzienlijk verlaagt.

Realtime datapipelines

Gebruik zstd (niveau 1-3) voor de beste balans tussen snelheid en compressieverhouding.

In streamingpipelines (Kafka, Kinesis, Flink) hebben de compressie- en decompressiesnelheid direct invloed op de doorvoersnelheid en latentie. Op niveau 1 comprimeert zstd sneller dan gzip en haalt het ook betere compressieverhoudingen. De dictionarymodus is ideaal voor JSONL met vaste schema's.

Bestanden aanbieden via het web en API's

Gebruik Brotli voor statische bestanden, met gzip als fallback voor maximale compatibiliteit.

Alle moderne browsers ondersteunen Brotli via Accept-Encoding: br. CDN's als Cloudflare en CloudFront kunnen bestanden automatisch met Brotli comprimeren. Gebruik gzip als fallback voor oudere clients. Steeds meer browsers ondersteunen zstd, maar die ondersteuning is nog niet universeel.

ETL en batchverwerking

Gebruik gzip voor maximale compatibiliteit, of zstd voor betere prestaties.

De meeste datatools (Spark, Athena, BigQuery, pandas) hebben ingebouwde ondersteuning voor gzip. De ondersteuning voor zstd verbetert snel. Ondersteunt je toolchain zstd, kies daar dan voor: de compressie is 3-5x sneller bij vergelijkbare compressieverhoudingen.

Werk online met JSONL-bestanden

Bekijk, valideer en converteer JSONL-bestanden tot 1GB rechtstreeks in je browser. Je hoeft niets te uploaden en alles blijft 100% privé.

Veelgestelde vragen

Bronnen