Avro : La Solution Idéale pour une Sérialisation de Données Efficace

Avro pour la sérialisation des données

Apache Avro est un format de sérialisation de données compact, fondé sur des schémas, très utilisé dans les systèmes de traitement de données comme Apache Kafka et Apache Spark. Sa force : la structure des données est décrite par un schéma écrit en JSON, ce qui rend la sérialisation et la désérialisation efficaces et facilite l’intégration avec les outils de data engineering.

Avro gère des types simples (int, long, string, boolean, bytes…) et des types complexes (record, array, map, enum, union, fixed). Cas d’usage typiques :

écrire des données structurées dans un fichier Avro (le schéma est embarqué dans le fichier) ;
utiliser un schéma pour s’assurer que les données sont lues et interprétées correctement ;
échanger des messages entre services via Apache Kafka, avec un schéma partagé.

Décryptage d’Avro : une introduction à la sérialisation

Avec Avro, les objets sont transformés en un format binaire compact. Comme le schéma décrit déjà les champs et leurs types, les données ne répètent pas les noms de champs : c’est ce qui les rend nettement plus petites qu’un JSON équivalent. Dans un fichier Avro (conteneur), le schéma est stocké dans l’en-tête et les données peuvent être compressées par blocs (deflate, snappy, zstandard…). Dans un flux de messages, on n’envoie en général que les données et on référence le schéma séparément.

Un autre atout est l’évolution de schéma : on peut lire d’anciennes données avec un schéma plus récent (et inversement), à condition de respecter les règles de compatibilité, par exemple en donnant une valeur par défaut aux champs ajoutés.

Un exemple en Python avec fastavro

Voici un exemple complet avec la bibliothèque fastavro (testé avec fastavro 1.13 et Python 3.14) : écriture d’un fichier, relecture, puis lecture avec un schéma qui ajoute un champ optionnel.

import io
from fastavro import writer, reader, parse_schema

schema = parse_schema({
    "type": "record",
    "name": "Utilisateur",
    "fields": [
        {"name": "nom", "type": "string"},
        {"name": "age", "type": "int"},
    ],
})

utilisateurs = [{"nom": "Alice", "age": 30}, {"nom": "Bob", "age": 25}]

tampon = io.BytesIO()  # ou open("utilisateurs.avro", "wb")
writer(tampon, schema, utilisateurs, codec="deflate")

tampon.seek(0)
print(list(reader(tampon)))

# Évolution de schéma : nouveau champ optionnel avec valeur par défaut
schema_v2 = parse_schema({
    "type": "record",
    "name": "Utilisateur",
    "fields": [
        {"name": "nom", "type": "string"},
        {"name": "age", "type": "int"},
        {"name": "email", "type": ["null", "string"], "default": None},
    ],
})

tampon.seek(0)
print(list(reader(tampon, reader_schema=schema_v2)))

Les anciens enregistrements sont relus sans erreur, avec email à None. La bibliothèque officielle avro (Apache Avro pour Python) fait la même chose avec DataFileWriter et DataFileReader, mais fastavro est généralement plus rapide.

Comparaison des formats de sérialisation

Format	Avantages	Inconvénients
Avro	Compact, schéma embarqué dans les fichiers, évolution de schéma, très bien intégré à Kafka	Illisible à l’œil nu, gestion des schémas à organiser
JSON	Lisible, universel, aucun schéma requis	Plus volumineux et plus lent à analyser, pas de typage strict
Protocol Buffers	Compact et rapide, nombreux langages, idéal pour les API gRPC	Schéma `.proto` et génération de code, schéma non embarqué dans les données
Parquet	Format en colonnes, très efficace pour l’analytique et la compression	Orienté lecture analytique, peu adapté à l’écriture enregistrement par enregistrement ou au streaming

En pratique : Avro (orienté lignes) convient bien aux flux d’événements et aux échanges de messages ; Parquet (orienté colonnes) convient mieux aux requêtes analytiques sur de gros volumes. Les deux se combinent souvent dans une même architecture.

L’écosystème Avro : outils et intégrations

L’écosystème Avro est riche. Parmi les principaux composants :

Apache Kafka : pour le traitement de messages en temps réel, avec des schémas Avro ;
Schema Registry (Confluent) : pour stocker les schémas, les versionner et vérifier leur compatibilité avant la publication des messages ; il prend aussi en charge Protobuf et JSON Schema ;
Apache Spark (module spark-avro) et Hadoop : pour lire et écrire des données Avro dans un data lake.

Les fichiers Avro existent en format binaire (le plus courant) et il existe aussi un encodage JSON, pratique pour le débogage.

Pratiques avancées avec Avro

Pour travailler sérieusement avec Avro :

définissez le schéma d’abord, versionnez-le avec votre code ;
donnez une valeur par défaut aux nouveaux champs pour préserver la compatibilité, et choisissez explicitement un mode de compatibilité (arrière, avant ou complète) dans votre Schema Registry ;
utilisez les union avec null pour les champs optionnels ;
testez la lecture d’anciens fichiers avec les nouveaux schémas avant tout déploiement.

Bien utilisé, Avro permet de construire des pipelines de données robustes, où chaque champ a un type défini et où les schémas peuvent évoluer sans casser les consommateurs existants.

Aller plus loin

Pour monter en compétence sur Python et ses usages en traitement de données, découvrez ma formation Python à distance.