Por Jerry Fan

Compressão de JSONL: gzip vs zstd vs Brotli

Um guia prático para comprimir arquivos JSONL. Compare taxas de compressão e benchmarks de velocidade e saiba quando usar gzip, zstd ou Brotli nos seus pipelines de dados, no armazenamento em nuvem e na distribuição de conteúdo pela web.

Por que comprimir arquivos JSONL?

Arquivos JSONL crescem rápido. Um único dia de logs de uma aplicação pode gerar gigabytes de JSON delimitado por linhas, e datasets de machine learning chegam facilmente a dezenas de gigabytes. Sem compressão, você gasta mais com armazenamento, as transferências demoram mais e as operações de I/O se tornam o gargalo do seu pipeline de dados. Em grande escala, a compressão é indispensável para trabalhar com dados JSONL de forma eficiente.

A boa notícia é que arquivos JSONL permitem uma excelente compressão. O formato JSON contém texto com muitas repetições de chaves, delimitadores e padrões de estrutura. Os algoritmos de compressão aproveitam essa redundância para reduzir o tamanho dos arquivos de 5x a 15x. O desafio é escolher o algoritmo certo para o seu caso de uso: gzip oferece compatibilidade universal, zstd traz o melhor equilíbrio entre velocidade e taxa de compressão, e Brotli oferece a maior compressão para recursos estáticos. Este guia compara os três com benchmarks reais, exemplos de código funcionais e recomendações claras.

Visão geral dos algoritmos de compressão

Três algoritmos predominam na compressão de JSONL. Cada um usa estratégias diferentes e é otimizado para cenários específicos. Entender as vantagens e limitações de cada um ajuda você a escolher o mais adequado para a sua carga de trabalho.

gzip (DEFLATE)

Universal

O padrão universal. O gzip existe desde 1992 e tem suporte em todo lugar: em todas as linguagens de programação, sistemas operacionais, provedores de nuvem e navegadores web. Ele usa o algoritmo DEFLATE, que combina LZ77 e codificação de Huffman. Embora não seja o mais rápido nem o mais eficiente, seu amplo suporte faz dele uma escolha padrão segura quando a compatibilidade é a prioridade.

Zstandard (zstd)

Recomendado

Desenvolvido pelo Facebook em 2016, o zstd é uma solução moderna e versátil para compressão de dados. Ele comprime e descomprime muito mais rápido que o gzip, com taxas de compressão semelhantes ou melhores. O zstd também oferece compressão com dicionário, um recurso especialmente eficaz para arquivos JSONL em que todas as linhas têm a mesma estrutura de chaves. É a melhor escolha para pipelines de dados e processamento em tempo real.

Brotli

Melhor taxa de compressão

Criado pelo Google, o Brotli oferece as maiores taxas de compressão entre os três algoritmos, especialmente nos níveis máximos de compressão. Ele combina LZ77, codificação de Huffman e um dicionário estático integrado com conteúdo comum da web. O Brotli se destaca na compressão de JSONL para distribuição via HTTP e armazenamento estático, mas, nos níveis mais altos, comprime bem mais devagar que gzip ou zstd.

Comparação direta

A tabela a seguir resume as principais diferenças entre gzip, zstd e Brotli nas métricas mais relevantes para a compressão de arquivos JSONL. São características gerais com as configurações padrão; o desempenho real depende dos dados e do nível de compressão.

MétricagzipzstdBrotli
Taxa de compressãoBoa (5-8x)Muito boa (6-10x)Excelente (7-12x)
Velocidade de compressãoModeradaRápidaDe lenta a moderada
Velocidade de descompressãoModeradaMuito rápidaRápida
Uso de CPUModeradoDe baixo a moderadoAlto (no nível máximo)
Suporte nos navegadoresTodos os navegadoresChrome 123+, Firefox 126+Todos os navegadores modernos
Suporte a streamingSim (nativo)Sim (nativo)Limitado

Resultados dos benchmarks: arquivo JSONL de 100 MB

Para apresentar números concretos, reunimos os resultados de benchmarks de compressão de um arquivo JSONL de 100 MB com registros de log de uma aplicação. Cada registro tem 12 campos, incluindo timestamps, níveis de log, mensagens em formato de string e objetos de metadados aninhados. Os testes foram executados em um AMD Ryzen 7 com 32 GB de RAM e armazenamento NVMe.

Algoritmo e nívelTamanho comprimidoTaxaTempo de compressãoTempo de descompressão
gzip (nível 6)14,2 MB7,0x2,8s0,9s
gzip (nível 9)13,1 MB7,6x8,4s0,9s
zstd (nível 3)12,8 MB7,8x0,6s0,3s
zstd (nível 1)15,1 MB6,6x0,3s0,3s
Brotli (nível 6)11,5 MB8,7x3,2s0,5s
Brotli (nível 11)9,8 MB10,2x42,1s0,4s

Estes benchmarks representam dados típicos de logs em JSONL. Os resultados variam conforme a cardinalidade dos campos, a entropia dos valores e a estrutura dos registros. Arquivos com muitas repetições de chaves e valores de baixa entropia (como níveis de log ou códigos de status) permitem uma compressão maior do que arquivos com strings únicas de alta entropia.

Exemplos de código para compressão

Veja exemplos práticos de como comprimir e descomprimir arquivos JSONL em Python, Node.js e na linha de comando. Os exemplos mostram como trabalhar com os três algoritmos.

O Python tem suporte nativo a gzip. Para usar zstd e Brotli, instale os pacotes pyzstd e brotli. Os três seguem o mesmo padrão: abra um arquivo comprimido e use o objeto de arquivo retornado para ler ou escrever linhas JSONL.

Python: gzip, zstd e Brotli
import gzip
import json


# === gzip (integrado) ===
# Escreve JSONL comprimido
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')


# Lê JSONL comprimido
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


# Escreve JSONL comprimido
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')


# Lê JSONL comprimido
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


# Comprime um arquivo JSONL inteiro
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)


# Descomprime
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)

O Node.js tem suporte nativo a gzip e Brotli pelo módulo zlib. Para usar zstd, instale o pacote npm @aspect-build/zstd ou fzstd. A API baseada em streams é ideal para processar arquivos JSONL grandes sem carregá-los por inteiro na memória.

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


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


// === descomprimir gzip e parsear ===
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);
    // processa registro
  }
}


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


// === descomprimir Brotli e parsear ===
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);
  }
}

As ferramentas de linha de comando são a maneira mais rápida de comprimir arquivos JSONL. O gzip já vem instalado em todos os sistemas Unix. Para usar os outros dois algoritmos, instale zstd e brotli pelo seu gerenciador de pacotes.

Linha de comando: gzip, zstd e Brotli
# === gzip ===
# Comprimir (mantém original por padrão com -k)
gzip -k data.jsonl                # -> data.jsonl.gz
gzip -9 -k data.jsonl              # compressão máxima


# Descomprimir
gzip -d data.jsonl.gz
# ou: gunzip data.jsonl.gz


# === zstd ===
# Instalar: brew install zstd / apt install zstd
zstd data.jsonl                    # -> data.jsonl.zst
zstd -3 data.jsonl                 # nível 3 (padrão)
zstd --fast data.jsonl             # compressão mais rápida


# Descomprimir
zstd -d data.jsonl.zst
# ou: unzstd data.jsonl.zst


# === Brotli ===
# Instalar: brew install brotli / apt install brotli
brotli data.jsonl                  # -> data.jsonl.br
brotli -q 6 data.jsonl             # qualidade 6
brotli -q 11 data.jsonl            # compressão máxima


# Descomprimir
brotli -d data.jsonl.br


# === Piping com jq ===
# Comprimir JSONL filtrado
cat data.jsonl | jq -c 'select(.level == "error")' | gzip > errors.jsonl.gz


# Descomprimir e contar linhas
zstd -dc data.jsonl.zst | wc -l

Estratégias de compressão para armazenamento em nuvem

Comprimir arquivos JSONL antes de armazená-los em serviços de armazenamento de objetos na nuvem reduz tanto os custos de armazenamento quanto o tempo de transferência. A maioria dos provedores de nuvem oferece descompressão transparente de gzip e Brotli por meio de suas camadas de CDN, mas as estratégias de upload e armazenamento variam.

Faça upload dos arquivos JSONL comprimidos para o S3 com o cabeçalho Content-Encoding correto. O S3 armazena os bytes comprimidos, e o CloudFront pode disponibilizá-los com descompressão automática. Em cargas de trabalho de data lake, ferramentas como AWS Athena e Spark leem nativamente arquivos JSONL comprimidos com gzip e zstd.

AWS S3 com compressão
import boto3
import gzip
import json


s3 = boto3.client('s3')


# Faz upload de JSONL comprimido com gzip para S3
def upload_compressed_jsonl(records, bucket, key):
    # Comprime na memória
    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'Enviados {len(compressed)} bytes (comprimido)')


# Baixa e descomprime
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()
    ]

O Google Cloud Storage oferece transcodificação gzip. Ao fazer upload de um objeto comprimido com gzip e definir o cabeçalho Content-Encoding: gzip, o GCS pode disponibilizar a versão descomprimida automaticamente quando os clientes enviam Accept-Encoding: gzip. Para importar dados no BigQuery, use diretamente os arquivos JSONL comprimidos com gzip.

Google Cloud Storage com compressão
from google.cloud import storage
import gzip
import json


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


# Faz upload de JSONL comprimido com 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: carrega JSONL comprimido diretamente
# bq load --source_format=NEWLINE_DELIMITED_JSON \
#   my_dataset.my_table gs://bucket/data.jsonl.gz schema.json

Boas práticas: quando usar cada algoritmo

Nenhum algoritmo de compressão é o melhor em todas as situações. A escolha depende do que você prioriza: espaço de armazenamento, velocidade de processamento, compatibilidade ou um equilíbrio entre os três. Veja recomendações para os casos de uso mais comuns de JSONL.

Arquivamento e armazenamento frio

Use Brotli (qualidade 9-11) ou zstd (nível 19+) para obter a compressão máxima.

No arquivamento, o tempo de compressão tem menos importância: você comprime uma vez e raramente descomprime. O Brotli na qualidade 11 pode atingir uma compressão de 10x+ em dados JSONL, reduzindo bastante os custos de armazenamento a longo prazo.

Pipelines de dados em tempo real

Use zstd (nível 1-3) para obter o melhor equilíbrio entre velocidade e taxa de compressão.

Em pipelines de streaming (Kafka, Kinesis, Flink), a velocidade de compressão e descompressão afeta diretamente o throughput e a latência. No nível 1, o zstd comprime mais rápido que o gzip e ainda oferece melhores taxas de compressão. Seu modo com dicionário é ideal para JSONL com schemas fixos.

Distribuição de conteúdo pela web e APIs

Use Brotli para arquivos estáticos e gzip como fallback para garantir a máxima compatibilidade.

Todos os navegadores modernos aceitam Brotli por meio de Accept-Encoding: br. CDNs como Cloudflare e CloudFront podem comprimir o conteúdo automaticamente com Brotli. Use gzip como fallback para clientes mais antigos. O suporte a zstd nos navegadores está crescendo, mas ainda não é universal.

ETL e processamento em lote

Use gzip para garantir a máxima compatibilidade ou zstd para obter melhor desempenho.

A maioria das ferramentas de dados (Spark, Athena, BigQuery, pandas) tem suporte nativo a gzip. O suporte a zstd está evoluindo rapidamente. Se as ferramentas que você usa aceitam zstd, prefira esse algoritmo para obter compressão 3-5x mais rápida, com taxas de compressão comparáveis.

Trabalhe com arquivos JSONL online

Visualize, valide e converta arquivos JSONL de até 1GB diretamente no navegador. Sem precisar fazer upload, com 100% de privacidade.

Perguntas frequentes

Referências