Compresión de JSONL: gzip vs zstd vs Brotli
Una guía práctica para comprimir archivos JSONL. Compara ratios de compresión y pruebas de velocidad, y aprende cuándo usar gzip, zstd o Brotli en tus pipelines de datos, en el almacenamiento en la nube y al servir contenido web.
¿Por qué comprimir archivos JSONL?
Los archivos JSONL crecen rápido. Los logs de una aplicación pueden generar gigabytes de JSON delimitado por líneas en un solo día, y los datasets de aprendizaje automático suelen alcanzar decenas de gigabytes. Sin compresión, pagas más por el almacenamiento, las transferencias tardan más y la E/S se convierte en el cuello de botella de tu pipeline de datos. Cuando trabajas a gran escala, la compresión es imprescindible para procesar datos JSONL de forma eficiente.
La buena noticia es que JSONL se comprime excepcionalmente bien. JSON es texto con claves, delimitadores y patrones estructurales que se repiten, por lo que los algoritmos de compresión pueden aprovechar esa redundancia para reducir el tamaño entre 5x y 15x. Lo difícil es elegir el algoritmo adecuado para tu caso de uso: gzip ofrece compatibilidad universal, zstd consigue el mejor equilibrio entre velocidad y ratio de compresión, y Brotli alcanza la máxima compresión para recursos estáticos. Esta guía compara los tres con pruebas de rendimiento reales, ejemplos de código funcionales y recomendaciones claras.
Los principales algoritmos de compresión
Tres algoritmos dominan la compresión de JSONL. Cada uno emplea estrategias distintas y está optimizado para escenarios diferentes. Conocer sus ventajas y limitaciones te ayudará a elegir el más adecuado para tu carga de trabajo.
gzip (DEFLATE)
UniversalEl estándar universal. gzip existe desde 1992 y está disponible en todos los lenguajes de programación, sistemas operativos, proveedores de nube y navegadores web. Utiliza el algoritmo DEFLATE, que combina LZ77 y la codificación Huffman. Aunque no es el más rápido ni el más eficiente, su amplia disponibilidad lo convierte en una opción segura por defecto cuando prima la compatibilidad.
Zstandard (zstd)
RecomendadoDesarrollado por Facebook en 2016, zstd es una solución moderna y versátil para comprimir datos. Comprime y descomprime mucho más rápido que gzip, con ratios similares o mejores. También admite compresión con diccionarios, especialmente eficaz en archivos JSONL cuyas líneas comparten la misma estructura de claves. Es la mejor opción para pipelines de datos y procesamiento en tiempo real.
Brotli
Mejor ratio de compresiónCreado por Google, Brotli consigue los ratios de compresión más altos de los tres, sobre todo en los niveles máximos de compresión. Combina LZ77, codificación Huffman y un diccionario estático integrado con contenido web habitual. Destaca al comprimir JSONL para servirlo por HTTP y almacenarlo como contenido estático, aunque en los niveles altos comprime bastante más despacio que gzip o zstd.
Comparativa directa
La siguiente tabla resume las principales diferencias entre gzip, zstd y Brotli según las métricas más relevantes al comprimir archivos JSONL. Son características generales con la configuración predeterminada; el rendimiento real depende de los datos y del nivel de compresión.
| Métrica | gzip | zstd | Brotli |
|---|---|---|---|
| Ratio de compresión | Bueno (5-8x) | Muy bueno (6-10x) | Excelente (7-12x) |
| Velocidad de compresión | Moderada | Rápida | De lenta a moderada |
| Velocidad de descompresión | Moderada | Muy rápida | Rápida |
| Uso de CPU | Moderado | De bajo a moderado | Alto (en el nivel máximo) |
| Compatibilidad con navegadores | Todos los navegadores | Chrome 123+, Firefox 126+ | Todos los navegadores modernos |
| Compatibilidad con streaming | Sí (nativo) | Sí (nativo) | Limitado |
Pruebas de rendimiento: archivo JSONL de 100 MB
Para poner cifras concretas, estos son los resultados de comprimir un archivo JSONL de 100 MB con logs de una aplicación. Cada registro tiene 12 campos, entre ellos marcas de tiempo, niveles de log, cadenas de texto con mensajes y objetos de metadatos anidados. Las pruebas se realizaron en un AMD Ryzen 7 con 32 GB de RAM y almacenamiento NVMe.
| Algoritmo y nivel | Tamaño comprimido | Ratio | Tiempo de compresión | Tiempo de descompresión |
|---|---|---|---|---|
| gzip (nivel 6) | 14.2 MB | 7.0x | 2.8s | 0.9s |
| gzip (nivel 9) | 13.1 MB | 7.6x | 8.4s | 0.9s |
| zstd (nivel 3) | 12.8 MB | 7.8x | 0.6s | 0.3s |
| zstd (nivel 1) | 15.1 MB | 6.6x | 0.3s | 0.3s |
| Brotli (nivel 6) | 11.5 MB | 8.7x | 3.2s | 0.5s |
| Brotli (nivel 11) | 9.8 MB | 10.2x | 42.1s | 0.4s |
Estas pruebas son representativas de los datos habituales de logs en JSONL. Los resultados varían según la cardinalidad de los campos, la entropía de los valores y la estructura de los registros. Los archivos con claves que se repiten mucho y valores de baja entropía (como niveles de log o códigos de estado) se comprimen mejor que los que contienen cadenas únicas de alta entropía.
Ejemplos de código para comprimir JSONL
Aquí tienes ejemplos prácticos para comprimir y descomprimir archivos JSONL en Python, Node.js y desde la línea de comandos. En cada caso se muestra cómo trabajar con los tres algoritmos.
Python incluye soporte para gzip. Para usar zstd y Brotli, instala los paquetes pyzstd y brotli. Los tres siguen el mismo patrón: abre el archivo comprimido y utiliza el objeto de archivo resultante para leer o escribir líneas JSONL.
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 incluye soporte para gzip y Brotli a través del módulo zlib. Para zstd, usa el paquete npm @aspect-build/zstd o fzstd. La API basada en streams es ideal para procesar archivos JSONL grandes sin cargarlos por completo en memoria.
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);
}
}Las herramientas de línea de comandos son la forma más rápida de comprimir archivos JSONL. gzip viene preinstalado en todos los sistemas Unix. Para usar los otros dos algoritmos, instala zstd y brotli con tu gestor de paquetes.
# === 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 -lEstrategias de compresión para el almacenamiento en la nube
Al guardar archivos JSONL en servicios de almacenamiento de objetos en la nube, la compresión reduce tanto el coste de almacenamiento como el tiempo de transferencia. La mayoría de los proveedores de nube permiten descomprimir gzip y Brotli de forma transparente a través de sus CDN, aunque las estrategias de subida y almacenamiento varían.
Sube los archivos JSONL comprimidos a S3 con la cabecera Content-Encoding adecuada. S3 almacena los bytes comprimidos y CloudFront puede servirlos con descompresión automática. Para cargas de trabajo de data lake, herramientas como AWS Athena y Spark leen de forma nativa archivos JSONL comprimidos con gzip y zstd.
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 admite la transcodificación gzip. Si subes un objeto comprimido con gzip con la cabecera Content-Encoding: gzip, GCS puede servir automáticamente la versión descomprimida cuando los clientes envían Accept-Encoding: gzip. Para importar datos a BigQuery, usa directamente archivos JSONL comprimidos con gzip.
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.jsonBuenas prácticas: qué algoritmo usar en cada caso
No hay un algoritmo de compresión que sea el mejor para todo. La elección depende de si priorizas el espacio de almacenamiento, la velocidad de procesamiento, la compatibilidad o un equilibrio entre los tres. Estas son nuestras recomendaciones para los casos de uso más habituales de JSONL.
Archivado y almacenamiento en frío
Usa Brotli (calidad 9-11) o zstd (nivel 19+) para obtener la máxima compresión.
En el archivado, el tiempo de compresión tiene menos importancia: comprimes una vez y rara vez necesitas descomprimir. Con calidad 11, Brotli puede alcanzar una compresión de 10x+ en datos JSONL, lo que reduce considerablemente el coste de almacenamiento a largo plazo.
Pipelines de datos en tiempo real
Usa zstd (nivel 1-3) para conseguir el mejor equilibrio entre velocidad y ratio de compresión.
En los pipelines de streaming (Kafka, Kinesis, Flink), la velocidad de compresión y descompresión afecta directamente al volumen de datos procesados por unidad de tiempo y a la latencia. En el nivel 1, zstd comprime más rápido que gzip y consigue mejores ratios. Su modo de compresión con diccionario es ideal para JSONL con esquemas fijos.
Distribución de contenido web y APIs
Usa Brotli para los archivos estáticos y gzip como alternativa para garantizar la máxima compatibilidad.
Todos los navegadores modernos admiten Brotli mediante Accept-Encoding: br. Las CDN como Cloudflare y CloudFront pueden comprimir automáticamente con Brotli. Usa gzip como alternativa para los clientes antiguos. La compatibilidad de los navegadores con zstd está aumentando, pero todavía no es universal.
ETL y procesamiento por lotes
Usa gzip para obtener la máxima compatibilidad o zstd para mejorar el rendimiento.
La mayoría de las herramientas de datos (Spark, Athena, BigQuery, pandas) admiten gzip de forma nativa. La compatibilidad con zstd está mejorando rápidamente. Si tus herramientas admiten zstd, elígelo para comprimir 3-5x más rápido con ratios comparables.
Prueba nuestras herramientas gratuitas para JSONL
Comprime tus archivos JSONL antes de subirlos o valídalos y conviértelos con nuestras herramientas gratuitas en línea. No necesitas instalar nada.
Estrategias para procesar gigabytes de datos JSONL: lectura en streaming, gestión de memoria, división de archivos, compresión y herramientas online.
Domina las buenas prácticas de JSONL: formato, coherencia del esquema, gestión de errores, optimización del rendimiento y organización de archivos. Evita los errores habituales con ejemplos prácticos.
Divide archivos JSONL grandes en fragmentos más pequeños y manejables por número de líneas.
Combina múltiples archivos JSONL en uno solo con deduplicación.
Compara JSONL y Parquet. Aprende cuándo usar cada formato en pipelines de datos, analítica, entrenamiento de modelos de ML y almacenamiento, con pruebas de rendimiento y una guía de arquitectura híbrida.