JSONL vs Parquet: cómo elegir el formato de datos adecuado
Una comparativa completa de JSONL (JSON Lines) y Apache Parquet. Conoce las ventajas y limitaciones de cada formato en cuanto a compresión, rendimiento de las consultas, validación de esquemas y compatibilidad con otras herramientas para elegir el que mejor se adapte a tus cargas de trabajo con datos.
¿Qué es JSONL?
JSONL (JSON Lines) es un formato de datos de texto en el que cada línea contiene un único objeto JSON independiente, separado del siguiente por un salto de línea. Es una extensión natural del omnipresente formato JSON, diseñada específicamente para streaming y datos de tipo log. Como cada línea es un documento JSON independiente, puedes añadir datos al final del archivo sin reescribir los que ya contiene y procesarlo línea a línea con un consumo adicional de memoria mínimo.
JSONL se ha convertido en el formato estándar de intercambio para datos de entrenamiento de machine learning (fine-tuning de OpenAI, datasets de Hugging Face), logs de aplicaciones, flujos de eventos y cualquier caso en el que los datos lleguen de forma incremental. Al ser legible directamente, resulta fácil inspeccionarlo con cualquier editor de texto o con herramientas de línea de comandos como grep, head y jq.
{"id": 1, "name": "Alice", "role": "engineer", "salary": 95000}
{"id": 2, "name": "Bob", "role": "designer", "salary": 88000}
{"id": 3, "name": "Charlie", "role": "manager", "salary": 105000}¿Qué es Parquet?
Apache Parquet es un formato binario de almacenamiento por columnas diseñado para ejecutar consultas analíticas de forma eficiente sobre grandes conjuntos de datos. En lugar de almacenar los datos fila a fila, como JSONL, Parquet organiza los valores por columnas. Esto permite leer un campo de millones de filas recorriendo únicamente la columna correspondiente, sin tener que leer cada registro completo. Esta organización permite comprimir mucho los datos, ya que los valores de una misma columna suelen tener tipos y distribuciones similares.
Parquet nació en el ecosistema de Apache Hadoop y hoy es el formato de almacenamiento de facto para data lakes en AWS S3, Google Cloud Storage y Azure Blob Storage. Se integra estrechamente con Apache Spark, Apache Hive, Presto, DuckDB, Snowflake, BigQuery y prácticamente todos los motores de análisis modernos. Los archivos Parquet incluyen un esquema estricto en sus metadatos, de modo que las aplicaciones que los leen siempre conocen los tipos exactos y la estructura de los datos sin necesidad de documentación externa.
import pyarrow.parquet as pq
import pandas as pd
# Write a DataFrame to Parquet
df = pd.DataFrame({
'id': [1, 2, 3],
'name': ['Alice', 'Bob', 'Charlie'],
'role': ['engineer', 'designer', 'manager'],
'salary': [95000, 88000, 105000]
})
df.to_parquet('employees.parquet')
# Read specific columns (columnar advantage)
df = pq.read_table('employees.parquet', columns=['name', 'salary']).to_pandas()JSONL vs Parquet: comparativa
La siguiente tabla resume las principales diferencias entre JSONL y Parquet en los aspectos más relevantes para elegir un formato de datos para tu proyecto.
| Característica | JSONL | Parquet |
|---|---|---|
| Organización de los datos | Por filas, en formato de texto. Cada línea contiene un objeto JSON completo. | Por columnas, en formato binario. Los valores se almacenan por columnas, dentro de grupos de filas. |
| Codificación | Texto plano UTF-8. Se puede leer directamente y editar con cualquier editor de texto. | Formato binario con codificación por diccionario, RLE y empaquetado de bits. No se puede leer directamente. |
| Compresión | Compresión externa opcional (gzip, zstd). Los nombres de los campos se repiten en cada fila. | Compresión por columnas integrada (Snappy, Zstd, Gzip). Archivos 2-10x más pequeños. |
| Rendimiento de las consultas | Cualquier consulta requiere recorrer el archivo completo. No permite descartar columnas ni aplicar predicate pushdown. | Permite descartar columnas y aplicar predicate pushdown para omitir datos irrelevantes. Las consultas analíticas son varios órdenes de magnitud más rápidas. |
| Esquema | Sin esquema obligatorio. Cada línea puede tener campos y tipos distintos. Flexible, pero propenso a errores. | Esquema estricto con tipos definidos, incluido en los metadatos del archivo. Se valida tanto al leer como al escribir. |
| Streaming / Escritura al final del archivo | Excelente. Basta con añadir una línea al final del archivo. Ideal para la ingesta en tiempo real. | Limitado. Para añadir datos hay que reescribir el archivo o crear nuevas particiones de archivos. |
| Lectura directa | Sí. Puedes inspeccionarlo con cat, head, grep, jq o cualquier editor de texto. | No. Para inspeccionarlo necesitas herramientas especializadas (parquet-tools, PyArrow, DuckDB). |
| Ecosistema | Universal. Compatible con cualquier lenguaje de programación que disponga de un parser JSON. | Orientado al análisis de datos. Integración estrecha con Spark, Hive, Presto, DuckDB, Snowflake y BigQuery. |
Pruebas de rendimiento
La diferencia de rendimiento entre JSONL y Parquet se acentúa enormemente al trabajar a gran escala. Estas son unas mediciones representativas para un conjunto de datos de 10 millones de filas y 20 columnas, con una mezcla de cadenas de texto, enteros, números de coma flotante y marcas de tiempo.
Tamaño del archivo (compresión)
Lectura completa de la tabla
Velocidad de escritura
Consulta de una sola columna
Pruebas realizadas con Python (pandas + PyArrow) en un MacBook Pro M2 con 16 GB de RAM. Los resultados reales varían según el hardware, la distribución de los datos y el códec de compresión.
Cuándo usar JSONL y cuándo usar Parquet
- Ingesta de logs en tiempo real y streaming de eventos
- Datos de entrenamiento de ML para OpenAI, Anthropic y Hugging Face
- Intercambio de datos entre microservicios y APIs
- Datos semiestructurados cuyo esquema varía de un registro a otro
- Creación rápida de prototipos y depuración cuando importa poder leer los datos directamente
- Datos que llegan de forma continua y cuyos registros solo se añaden al final
- Conjuntos de datos pequeños o medianos (menos de 1 GB) que no requieren consultas analíticas
- Almacenamiento en data lakes en S3, GCS o Azure Blob
- Consultas analíticas con Spark, Presto, DuckDB o Snowflake
- Agregaciones por columnas (SUM, AVG, COUNT) sobre miles de millones de filas
- Requisitos de validación estricta de esquemas y de gobierno del dato
- Archivado a largo plazo cuando el coste de almacenamiento es relevante (archivos 2-10x más pequeños)
- Feature stores y pipelines de características de ML que leen columnas concretas
- Conjuntos de datos de más de 1 GB en los que el rendimiento de las consultas es crítico
Arquitectura híbrida: ingesta en JSONL y almacenamiento en Parquet
En las plataformas de datos en producción, JSONL y Parquet pueden complementarse. Un patrón habitual y eficaz consiste en usar JSONL para la ingesta de datos y Parquet para el almacenamiento a largo plazo y el análisis. Este enfoque híbrido combina las ventajas de ambos formatos: la sencillez de JSONL para capturar datos en tiempo real y la eficiencia de Parquet para las consultas posteriores.
El pipeline consta de tres etapas. Primero, los eventos o registros sin procesar se añaden a archivos JSONL a medida que llegan, ya que JSONL permite escribir al final del archivo de forma rápida y sin bloqueos. Después, una tarea por lotes periódica (cada hora, a diario o cuando se alcanza un tamaño de archivo determinado) lee los archivos JSONL acumulados, valida y transforma los datos y los convierte a Parquet. Por último, los archivos Parquet resultantes se almacenan en un data lake particionado por fecha, región u otras dimensiones para facilitar consultas eficientes.
1. Ingesta en JSONL
Recopila eventos sin procesar, logs y respuestas de APIs en archivos JSONL. Puedes añadir datos rápidamente, sin necesidad de un esquema, y depurar fácilmente en tiempo real.
2. Transformación y validación
Lee periódicamente lotes de archivos JSONL, valida el esquema, limpia y normaliza los datos y gestiona los registros mal formados.
3. Almacenamiento en Parquet
Escribe los datos validados en archivos Parquet particionados en tu data lake. Consúltalos con Spark, DuckDB o cualquier motor de análisis.
import json
import pandas as pd
import pyarrow as pa
import pyarrow.parquet as pq
from pathlib import Path
from datetime import datetime
def jsonl_to_parquet(jsonl_dir: str, parquet_dir: str):
"""Convert accumulated JSONL files to partitioned Parquet."""
records = []
for jsonl_file in Path(jsonl_dir).glob('*.jsonl'):
with open(jsonl_file, 'r') as f:
for line in f:
line = line.strip()
if line:
records.append(json.loads(line))
if not records:
return
df = pd.DataFrame(records)
# Add partition column
df['date'] = datetime.now().strftime('%Y-%m-%d')
table = pa.Table.from_pandas(df)
pq.write_to_dataset(
table,
root_path=parquet_dir,
partition_cols=['date'],
compression='zstd'
)
print(f'Converted {len(records)} records to Parquet')
jsonl_to_parquet('raw_events/', 'data_lake/')Prueba nuestras herramientas gratuitas para JSONL
¿Trabajas con archivos JSONL? Usa nuestras herramientas gratuitas para visualizar, validar y convertir datos JSONL al instante desde el navegador. No necesitas instalar nada ni subir archivos.
Estrategias para procesar gigabytes de datos JSONL: lectura en streaming, gestión de memoria, división de archivos, compresión y herramientas online.
Compara gzip, zstd y Brotli para comprimir archivos JSONL. Incluye pruebas de rendimiento, ejemplos de código en Python y Node.js, estrategias de almacenamiento en la nube y buenas prácticas.
Aprende a usar JSONL como formato de intercambio en pipelines ETL. Incluye streaming con Apache Kafka, DAGs de Airflow, carga de datos en Snowflake y BigQuery y diseño de pipelines tolerantes a fallos.
Exporta datos JSONL a hojas de cálculo CSV para analizarlos en Excel o Google Sheets.
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.