Por Jerry Fan

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)

Universal

El 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)

Recomendado

Desarrollado 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ón

Creado 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étricagzipzstdBrotli
Ratio de compresiónBueno (5-8x)Muy bueno (6-10x)Excelente (7-12x)
Velocidad de compresiónModeradaRápidaDe lenta a moderada
Velocidad de descompresiónModeradaMuy rápidaRápida
Uso de CPUModeradoDe bajo a moderadoAlto (en el nivel máximo)
Compatibilidad con navegadoresTodos los navegadoresChrome 123+, Firefox 126+Todos los navegadores modernos
Compatibilidad con streamingSí (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 nivelTamaño comprimidoRatioTiempo de compresiónTiempo de descompresión
gzip (nivel 6)14.2 MB7.0x2.8s0.9s
gzip (nivel 9)13.1 MB7.6x8.4s0.9s
zstd (nivel 3)12.8 MB7.8x0.6s0.3s
zstd (nivel 1)15.1 MB6.6x0.3s0.3s
Brotli (nivel 6)11.5 MB8.7x3.2s0.5s
Brotli (nivel 11)9.8 MB10.2x42.1s0.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.

Python: gzip, zstd y Brotli
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.

Node.js: gzip y Brotli con zlib
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.

Línea de comandos: gzip, zstd y Brotli
# === 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 -l

Estrategias 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.

Compresión en AWS S3
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.

Compresión en Google Cloud Storage
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.json

Buenas 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.

Trabaja con archivos JSONL en línea

Visualiza, valida y convierte archivos JSONL de hasta 1GB directamente en tu navegador. Sin subir archivos y con un procesamiento 100% privado.

Preguntas frecuentes

Referencias