Autor: Jerry Fan

Kompresja JSONL: gzip, zstd i Brotli — porównanie

Praktyczny przewodnik po kompresji plików JSONL. Porównaj stopień kompresji i wyniki testów szybkości. Dowiedz się, kiedy wybrać gzip, zstd lub Brotli do przetwarzania danych, przechowywania ich w chmurze i udostępniania przez sieć.

Dlaczego warto kompresować pliki JSONL?

Pliki JSONL szybko rosną. Logi aplikacji z jednego dnia mogą zajmować gigabajty w formacie JSON z osobnym rekordem w każdym wierszu, a zbiory danych do uczenia maszynowego często osiągają dziesiątki gigabajtów. Bez kompresji płacisz więcej za przechowywanie, przesyłanie trwa dłużej, a operacje wejścia/wyjścia stają się wąskim gardłem w przetwarzaniu danych. Przy dużej skali kompresja jest koniecznością — to podstawa wydajnej pracy z danymi JSONL.

Na szczęście JSONL bardzo dobrze się kompresuje. JSON to tekst, w którym powtarzają się klucze, separatory i schematy struktury. Algorytmy kompresji wykorzystują tę powtarzalność, by zmniejszyć rozmiar danych od 5x do 15x. Trzeba jednak dobrać algorytm do zastosowania: gzip zapewnia powszechną kompatybilność, zstd oferuje najlepszy kompromis między szybkością a stopniem kompresji, a Brotli najmocniej kompresuje zasoby statyczne. W tym przewodniku porównujemy wszystkie trzy na podstawie rzeczywistych benchmarków, działających przykładów kodu i konkretnych zaleceń.

Przegląd algorytmów kompresji

Do kompresji JSONL najczęściej używa się trzech algorytmów. Każdy działa inaczej i jest zoptymalizowany pod kątem innych zastosowań. Znajomość ich zalet i ograniczeń ułatwi Ci wybór odpowiedniego rozwiązania do przetwarzanych danych.

gzip (DEFLATE)

Uniwersalny

Uniwersalny standard. gzip istnieje od 1992 roku i jest obsługiwany wszędzie: w każdym języku programowania, systemie operacyjnym, u każdego dostawcy chmury i w każdej przeglądarce. Korzysta z algorytmu DEFLATE, który łączy LZ77 z kodowaniem Huffmana. Choć ustępuje innym pod względem szybkości i stopnia kompresji, jego powszechna obsługa sprawia, że jest bezpiecznym wyborem domyślnym, gdy najważniejsza jest kompatybilność.

Zstandard (zstd)

Zalecany

zstd, opracowany przez Facebooka w 2016 roku, to nowoczesny algorytm szeroko stosowany do kompresji danych. Kompresuje i dekompresuje znacznie szybciej niż gzip, a przy tym osiąga podobny lub lepszy stopień kompresji. Obsługuje też kompresję słownikową, która szczególnie dobrze sprawdza się w plikach JSONL, gdy każdy wiersz ma tę samą strukturę kluczy. To najlepszy wybór do potoków danych i przetwarzania w czasie rzeczywistym.

Brotli

Najwyższy stopień kompresji

Brotli, opracowany przez Google, osiąga najwyższy stopień kompresji spośród tych trzech algorytmów, szczególnie przy maksymalnych ustawieniach. Łączy LZ77, kodowanie Huffmana i wbudowany statyczny słownik typowych treści internetowych. Świetnie sprawdza się przy kompresji JSONL do udostępniania przez HTTP i przechowywania jako pliki statyczne. Przy wysokich poziomach kompresji działa jednak znacznie wolniej niż gzip czy zstd.

Porównanie algorytmów

Poniższa tabela zestawia najważniejsze różnice między gzip, zstd i Brotli pod kątem kompresji plików JSONL. Przedstawia ogólne właściwości przy ustawieniach domyślnych. Rzeczywista wydajność zależy od danych i poziomu kompresji.

ParametrgzipzstdBrotli
Stopień kompresjiDobry (5-8x)Bardzo dobry (6-10x)Doskonały (7-12x)
Szybkość kompresjiUmiarkowanaWysokaNiska do umiarkowanej
Szybkość dekompresjiUmiarkowanaBardzo wysokaWysoka
Obciążenie CPUUmiarkowaneNiskie do umiarkowanegoWysokie (przy maksymalnym poziomie)
Obsługa w przeglądarkachWszystkie przeglądarkiChrome 123+, Firefox 126+Wszystkie nowoczesne przeglądarki
Obsługa przetwarzania strumieniowegoTak (natywnie)Tak (natywnie)Ograniczona

Wyniki benchmarków: plik JSONL o rozmiarze 100 MB

Oto konkretne wyniki testów kompresji pliku JSONL o rozmiarze 100 MB, zawierającego logi aplikacji. Każdy rekord ma 12 pól, w tym znaczniki czasu, poziomy logowania, treść komunikatów i zagnieżdżone obiekty z metadanymi. Testy przeprowadzono na komputerze z procesorem AMD Ryzen 7, 32 GB RAM i dyskiem NVMe.

Algorytm i poziom kompresjiRozmiar po kompresjiStopień kompresjiCzas kompresjiCzas dekompresji
gzip (poziom 6)14,2 MB7,0x2,8s0,9s
gzip (poziom 9)13,1 MB7,6x8,4s0,9s
zstd (poziom 3)12,8 MB7,8x0,6s0,3s
zstd (poziom 1)15,1 MB6,6x0,3s0,3s
Brotli (poziom 6)11,5 MB8,7x3,2s0,5s
Brotli (poziom 11)9,8 MB10,2x42,1s0,4s

Wyniki są reprezentatywne dla typowych logów w formacie JSONL. Zależą od liczby różnych wartości w polach, entropii wartości i struktury rekordów. Pliki z często powtarzającymi się kluczami i wartościami o niskiej entropii (np. poziomami logowania lub kodami statusu) kompresują się lepiej niż pliki z unikalnymi ciągami znaków o wysokiej entropii.

Przykłady kompresji w kodzie

Poniżej znajdziesz praktyczne przykłady kompresji i dekompresji plików JSONL w Pythonie, Node.js i z wiersza poleceń. Każdy przykład pokazuje pracę ze wszystkimi trzema algorytmami.

Python ma wbudowaną obsługę gzip. Aby korzystać z zstd i Brotli, zainstaluj pakiety pyzstd i brotli. We wszystkich trzech przypadkach schemat pracy jest taki sam: otwórz skompresowany plik, a następnie za pomocą jego uchwytu odczytuj lub zapisuj wiersze JSONL.

Python: gzip, zstd i Brotli
import gzip
import json


# === gzip (wbudowany) ===
# Zapis skompresowanego 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')


# Odczyt skompresowanego 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


# Zapis skompresowanego 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')


# Odczyt skompresowanego 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


# Kompresja calego pliku JSONL
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)


# Dekompresja
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 ma wbudowaną obsługę gzip i Brotli w module zlib. Do zstd użyj pakietu npm @aspect-build/zstd lub fzstd. Strumieniowe API idealnie nadaje się do przetwarzania dużych plików JSONL bez wczytywania ich w całości do pamięci.

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


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


// === dekompresja gzip i parsowanie ===
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);
    // przetwarzaj rekord
  }
}


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


// === dekompresja Brotli i parsowanie ===
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);
  }
}

Narzędzia wiersza poleceń to najszybszy sposób na skompresowanie plików JSONL. gzip jest preinstalowany we wszystkich systemach Unix. Aby korzystać z pozostałych dwóch algorytmów, zainstaluj zstd i brotli za pomocą menedżera pakietów.

Wiersz poleceń: gzip, zstd i Brotli
# === gzip ===
# Kompresja (domyslnie zachowuje oryginal z -k)
gzip -k data.jsonl                # -> data.jsonl.gz
gzip -9 -k data.jsonl              # maksymalna kompresja


# Dekompresja
gzip -d data.jsonl.gz
# lub: gunzip data.jsonl.gz


# === zstd ===
# Instalacja: brew install zstd / apt install zstd
zstd data.jsonl                    # -> data.jsonl.zst
zstd -3 data.jsonl                 # poziom 3 (domyslny)
zstd --fast data.jsonl             # najszybsza kompresja


# Dekompresja
zstd -d data.jsonl.zst
# lub: unzstd data.jsonl.zst


# === Brotli ===
# Instalacja: brew install brotli / apt install brotli
brotli data.jsonl                  # -> data.jsonl.br
brotli -q 6 data.jsonl             # jakosc 6
brotli -q 11 data.jsonl            # maksymalna kompresja


# Dekompresja
brotli -d data.jsonl.br


# === Potokowanie z jq ===
# Kompresja przefiltrowanego JSONL
cat data.jsonl | jq -c 'select(.level == "error")' | gzip > errors.jsonl.gz


# Dekompresja i liczenie linii
zstd -dc data.jsonl.zst | wc -l

Kompresja danych przechowywanych w chmurze

Kompresja plików JSONL przechowywanych w chmurowym magazynie obiektowym zmniejsza koszty przechowywania i skraca czas przesyłania. Większość dostawców chmury obsługuje automatyczną dekompresję gzip i Brotli w warstwie CDN, ale sposoby przesyłania i przechowywania danych różnią się między usługami.

Przesyłaj skompresowane pliki JSONL do S3 z prawidłowym nagłówkiem Content-Encoding. S3 przechowuje skompresowane bajty, a CloudFront może je udostępniać z automatyczną dekompresją. Przy pracy z data lake narzędzia takie jak AWS Athena i Spark natywnie odczytują pliki JSONL skompresowane za pomocą gzip i zstd.

Kompresja w AWS S3
import boto3
import gzip
import json


s3 = boto3.client('s3')


# Przeslij skompresowany JSONL gzip do S3
def upload_compressed_jsonl(records, bucket, key):
    # Kompresja w pamieci
    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'Przeslano {len(compressed)} bajtow (skompresowane)')


# Pobierz i dekompresuj
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 obsługuje transkodowanie gzip. Gdy prześlesz obiekt skompresowany za pomocą gzip z nagłówkiem Content-Encoding: gzip, GCS może automatycznie udostępniać jego zdekompresowaną wersję klientom wysyłającym Accept-Encoding: gzip. Do importu do BigQuery użyj bezpośrednio plików JSONL skompresowanych za pomocą gzip.

Kompresja w Google Cloud Storage
from google.cloud import storage
import gzip
import json


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


# Przeslij skompresowany JSONL 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: laduj skompresowany JSONL bezposrednio
# bq load --source_format=NEWLINE_DELIMITED_JSON \
#   my_dataset.my_table gs://bucket/data.jsonl.gz schema.json

Dobre praktyki: który algorytm wybrać i kiedy?

Nie ma jednego najlepszego algorytmu kompresji. Wybór zależy od tego, czy najważniejszy jest dla Ciebie rozmiar plików, szybkość przetwarzania, kompatybilność czy kompromis między tymi trzema cechami. Oto konkretne zalecenia dla typowych zastosowań JSONL.

Archiwizacja i przechowywanie rzadko używanych danych

Wybierz Brotli (jakość 9-11) lub zstd (poziom 19+), aby uzyskać maksymalną kompresję.

Przy archiwizacji czas kompresji ma mniejsze znaczenie: kompresujesz dane raz, a dekompresujesz rzadko. Brotli przy jakości 11 może osiągnąć stopień kompresji 10x+ dla danych JSONL, co znacznie obniża koszty długoterminowego przechowywania.

Potoki danych działające w czasie rzeczywistym

Wybierz zstd (poziom 1-3), aby uzyskać najlepszy kompromis między szybkością a stopniem kompresji.

W potokach przetwarzania strumieniowego (Kafka, Kinesis, Flink) szybkość kompresji i dekompresji bezpośrednio wpływa na przepustowość i opóźnienia. zstd na poziomie 1 kompresuje szybciej niż gzip, a przy tym osiąga lepszy stopień kompresji. Tryb słownikowy idealnie sprawdza się w JSONL o stałym schemacie.

Udostępnianie przez sieć i API

Do plików statycznych używaj Brotli, a gzip stosuj jako wariant zapasowy, aby zapewnić maksymalną kompatybilność.

Wszystkie nowoczesne przeglądarki obsługują Brotli przez nagłówek Accept-Encoding: br. Sieci CDN, takie jak Cloudflare i CloudFront, mogą automatycznie kompresować dane za pomocą Brotli. Dla starszych klientów stosuj gzip jako wariant zapasowy. Obsługa zstd w przeglądarkach jest coraz szersza, ale jeszcze nie powszechna.

ETL i przetwarzanie wsadowe

Wybierz gzip, jeśli zależy Ci na maksymalnej kompatybilności, lub zstd, jeśli ważniejsza jest wydajność.

Większość narzędzi do przetwarzania danych (Spark, Athena, BigQuery, pandas) natywnie obsługuje gzip. Obsługa zstd szybko się rozwija. Jeśli Twoje narzędzia obsługują zstd, wybierz go: zapewnia 3-5x szybszą kompresję przy porównywalnym stopniu kompresji.

Pracuj z plikami JSONL online

Przeglądaj, sprawdzaj poprawność i konwertuj pliki JSONL o rozmiarze do 1GB bezpośrednio w przeglądarce. Bez przesyłania plików na serwer, z zachowaniem 100% prywatności.

Najczęściej zadawane pytania

Źródła