Par Jerry Fan

JSONL vs Parquet : choisir le bon format de données

Une comparaison détaillée de JSONL (JSON Lines) et d’Apache Parquet. Compression, performances des requêtes, respect du schéma, prise en charge par les outils : découvrez les compromis à connaître pour choisir le format adapté à vos traitements de données.

Qu’est-ce que JSONL ?

JSONL (JSON Lines) est un format texte dans lequel chaque ligne contient un objet JSON autonome, les lignes étant séparées par des caractères de saut de ligne. Il prolonge naturellement le format JSON, omniprésent, et a été conçu pour le streaming et les données de type logs. Chaque ligne constituant un document JSON indépendant, vous pouvez ajouter des données à un fichier sans réécrire son contenu et le traiter ligne par ligne avec une consommation mémoire minimale.

JSONL s’est imposé comme format d’échange standard pour les données d’entraînement en machine learning (fine-tuning OpenAI, jeux de données Hugging Face), les logs applicatifs, les flux d’événements et, plus généralement, les données qui arrivent progressivement. Comme il est directement lisible, vous pouvez facilement examiner son contenu dans n’importe quel éditeur de texte ou avec des outils en ligne de commande comme grep, head et jq.

employees.jsonl
{"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’est-ce que Parquet ?

Apache Parquet est un format de stockage binaire en colonnes, conçu pour exécuter efficacement des requêtes analytiques sur de grands jeux de données. Alors que JSONL stocke les données ligne par ligne, Parquet regroupe les valeurs par colonne. Pour lire un seul champ sur des millions de lignes, il suffit donc de parcourir la colonne concernée, sans lire chaque enregistrement dans son intégralité. Cette organisation permet une compression très poussée, car les valeurs d’une même colonne ont généralement des types et des distributions similaires.

Né dans l’écosystème Apache Hadoop, Parquet est aujourd’hui le format de stockage de référence des data lakes sur AWS S3, Google Cloud Storage et Azure Blob Storage. Il bénéficie d’une intégration étroite avec Apache Spark, Apache Hive, Presto, DuckDB, Snowflake, BigQuery et pratiquement tous les moteurs d’analyse modernes. Les fichiers Parquet intègrent un schéma strict dans leurs métadonnées : les applications qui les lisent connaissent ainsi les types et la structure exacte des données, sans documentation externe.

Lire et écrire des fichiers Parquet avec Python
import pyarrow.parquet as pq
import pandas as pd


# Ecrire un DataFrame en 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')


# Lire des colonnes specifiques (avantage du format en colonnes)
df = pq.read_table('employees.parquet', columns=['name', 'salary']).to_pandas()

JSONL vs Parquet : les différences en un coup d’œil

Le tableau suivant résume les principales différences entre JSONL et Parquet selon les critères les plus utiles pour choisir le format de données de votre projet.

CaractéristiqueJSONLParquet
Organisation des donnéesFormat texte organisé par lignes. Chaque ligne contient un objet JSON complet.Format binaire organisé par colonnes. Les valeurs sont stockées par colonne au sein de groupes de lignes.
EncodageTexte brut UTF-8. Directement lisible et modifiable dans n’importe quel éditeur de texte.Format binaire avec encodage par dictionnaire, RLE et bit-packing. Illisible tel quel.
CompressionCompression externe facultative (gzip, zstd). Les noms des champs sont répétés à chaque ligne.Compression en colonnes intégrée (Snappy, Zstd, Gzip). Fichiers 2 à 10 fois plus petits.
Performances des requêtesToute requête nécessite de parcourir le fichier entier. Aucun column pruning ni predicate pushdown.Le column pruning et le predicate pushdown permettent d’ignorer les données inutiles. Les requêtes analytiques sont plus rapides de plusieurs ordres de grandeur.
SchemaAucun schéma imposé. Les champs et leurs types peuvent varier d’une ligne à l’autre. Souple, mais propice aux erreurs.Schéma strict et typé, intégré aux métadonnées du fichier. Contrôlé à la lecture comme à l’écriture.
Streaming / Ajout de donnéesExcellent. Il suffit d’ajouter une ligne à la fin du fichier. Idéal pour l’ingestion en temps réel.Peu adapté. L’ajout de données nécessite une réécriture ou la création de nouvelles partitions de fichiers.
Lisibilité directeOui. Vous pouvez examiner le contenu avec cat, head, grep, jq ou n’importe quel éditeur de texte.Non. Des outils spécialisés sont nécessaires pour examiner le contenu (parquet-tools, PyArrow, DuckDB).
ÉcosystèmeUniversel. Pris en charge par tout langage de programmation disposant d’un parseur JSON.Axé sur l’analyse de données. Intégration étroite avec Spark, Hive, Presto, DuckDB, Snowflake, BigQuery.

Benchmarks de performances

À grande échelle, l’écart de performances entre JSONL et Parquet devient considérable. Voici des benchmarks représentatifs pour un jeu de données de 10 millions de lignes et 20 colonnes, mêlant chaînes de caractères, entiers, nombres flottants et horodatages.

Taille du fichier (compression)

JSONL~4,2 Go sans compression, ~1,1 Go avec gzip
Parquet~0,5 Go avec Snappy, ~0,4 Go avec Zstd

Lecture complète de la table

JSONL~45 secondes (parsing de chaque ligne JSON)
Parquet~8 secondes (décodage binaire, lectures vectorisées)

Vitesse d’écriture

JSONL~30 secondes (sérialisation + écriture du texte)
Parquet~22 secondes (encodage + compression des colonnes)

Requête sur une seule colonne

JSONL~45 secondes (lecture du fichier entier toujours nécessaire)
Parquet~1,5 seconde (lecture de la seule colonne ciblée)

Benchmarks réalisés avec Python (pandas + PyArrow) sur un MacBook Pro M2 doté de 16 Go de RAM. Les résultats en conditions réelles varient selon le matériel, la distribution des données et le codec de compression.

Quand choisir JSONL ou Parquet ?

JSONLLes cas d’usage de JSONL
  • Ingestion de logs en temps réel et streaming d’événements
  • Données d’entraînement en machine learning pour OpenAI, Anthropic et Hugging Face
  • Échange de données entre microservices et API
  • Données semi-structurées dont le schéma varie d’un enregistrement à l’autre
  • Prototypage rapide et débogage lorsque la lisibilité des données est essentielle
  • Données alimentées uniquement par ajout, avec des enregistrements qui arrivent en continu
  • Jeux de données de petite ou moyenne taille (moins de 1 Go) ne nécessitant pas de requêtes analytiques
ParquetLes cas d’usage de Parquet
  • Stockage dans un data lake sur S3, GCS ou Azure Blob
  • Requêtes analytiques avec Spark, Presto, DuckDB ou Snowflake
  • Agrégations par colonne (SUM, AVG, COUNT) sur des milliards de lignes
  • Exigences de respect strict du schéma et de gouvernance des données
  • Archivage à long terme lorsque le coût du stockage est un enjeu (fichiers 2 à 10 fois plus petits)
  • Feature stores et pipelines de features en machine learning qui lisent des colonnes précises
  • Jeux de données de plus de 1 Go pour lesquels les performances des requêtes sont déterminantes

Architecture hybride : ingestion en JSONL, stockage en Parquet

Sur les plateformes de données en production, JSONL et Parquet peuvent tout à fait cohabiter. Une approche courante et efficace consiste à utiliser JSONL pour l’ingestion, puis Parquet pour le stockage à long terme et l’analyse. Cette architecture hybride associe les atouts des deux formats : la simplicité de JSONL pour collecter les données en temps réel et l’efficacité de Parquet pour les requêtes en aval.

Le pipeline comporte trois étapes. D’abord, les événements ou enregistrements bruts sont ajoutés aux fichiers JSONL au fil de leur arrivée, grâce aux ajouts rapides et sans verrouillage que permet ce format. Ensuite, un traitement par lots périodique, exécuté toutes les heures, chaque jour ou lorsque le fichier atteint une certaine taille, lit les fichiers JSONL accumulés, valide et transforme les données, puis les convertit en Parquet. Enfin, les fichiers Parquet obtenus sont stockés dans un data lake partitionné par date, par région ou selon d’autres dimensions afin d’exécuter efficacement les requêtes.

1. Ingérer en JSONL

Collectez les événements bruts, les logs et les réponses d’API dans des fichiers JSONL. Les ajouts sont rapides, aucun schéma n’est requis et le débogage en temps réel est simple.

2. Transformer et valider

Lisez régulièrement les lots de fichiers JSONL, validez les données par rapport au schéma, nettoyez-les, normalisez-les et traitez les enregistrements mal formés.

3. Stocker en Parquet

Écrivez les données validées dans votre data lake sous forme de fichiers Parquet partitionnés. Interrogez-les avec Spark, DuckDB ou tout autre moteur d’analyse.

Pipeline de conversion de JSONL vers Parquet
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):
    """Convertir les fichiers JSONL accumules en Parquet partitionne."""
    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)
    # Ajouter une colonne de partition
    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/')

Travaillez avec vos fichiers JSONL en ligne

Visualisez, validez et convertissez des fichiers JSONL jusqu’à 1 Go directement dans votre navigateur. Aucun fichier à envoyer, confidentialité garantie à 100%.

Questions fréquentes

Références