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)
UniversalO 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)
RecomendadoDesenvolvido 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ãoCriado 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étrica | gzip | zstd | Brotli |
|---|---|---|---|
| Taxa de compressão | Boa (5-8x) | Muito boa (6-10x) | Excelente (7-12x) |
| Velocidade de compressão | Moderada | Rápida | De lenta a moderada |
| Velocidade de descompressão | Moderada | Muito rápida | Rápida |
| Uso de CPU | Moderado | De baixo a moderado | Alto (no nível máximo) |
| Suporte nos navegadores | Todos os navegadores | Chrome 123+, Firefox 126+ | Todos os navegadores modernos |
| Suporte a streaming | Sim (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ível | Tamanho comprimido | Taxa | Tempo de compressão | Tempo de descompressão |
|---|---|---|---|---|
| gzip (nível 6) | 14,2 MB | 7,0x | 2,8s | 0,9s |
| gzip (nível 9) | 13,1 MB | 7,6x | 8,4s | 0,9s |
| zstd (nível 3) | 12,8 MB | 7,8x | 0,6s | 0,3s |
| zstd (nível 1) | 15,1 MB | 6,6x | 0,3s | 0,3s |
| Brotli (nível 6) | 11,5 MB | 8,7x | 3,2s | 0,5s |
| Brotli (nível 11) | 9,8 MB | 10,2x | 42,1s | 0,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.
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.
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.
# === 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 -lEstraté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.
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.
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.jsonBoas 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.
Experimente nossas ferramentas gratuitas para JSONL
Comprima seus arquivos JSONL antes de fazer upload ou use nossas ferramentas online gratuitas para validá-los e convertê-los. Não é preciso instalar nada.
Estratégias para processar gigabytes de dados JSONL: leitura por streaming, gerenciamento de memória, divisão de arquivos, compressão e ferramentas online.
Domine as boas práticas de JSONL para formatação, consistência de schema, tratamento de erros, otimização de desempenho e organização de arquivos. Evite problemas comuns com exemplos práticos.
Divida arquivos JSONL grandes em partes menores e gerenciáveis por número de linhas.
Combine vários arquivos JSONL em um único arquivo com deduplicação.
Compare JSONL e Parquet lado a lado. Saiba quando usar cada formato em pipelines de dados, análises, treinamento de ML e armazenamento, com benchmarks de desempenho e um guia de arquitetura híbrida.