Avro vs. Parquet : Une comparaison complète pour le stockage des Big Data

Différences entre Avro et Parquet

Avro et Parquet sont des formats de stockage de données largement utilisés dans les écosystèmes de big data, mais ils ont des objectifs différents et excellent dans des scénarios différents. Vous trouverez ci-dessous une comparaison détaillée de leurs différences.

Structure des données

• Avro : Utilise un format de stockage basé sur les lignes, ce qui signifie que les enregistrements entiers sont stockés de manière séquentielle. Avro est donc efficace pour les charges de travail à forte intensité d'écriture où les données doivent être ajoutées rapidement.
• Parquet : Utilise un format de stockage en colonnes, où les données sont stockées par colonnes plutôt que par lignes. Cette structure est utile pour les requêtes analytiques qui nécessitent de lire uniquement des colonnes spécifiques plutôt que des lignes entières.

Visualisation du stockage en ligne ou en colonne

Pour mieux comprendre la différence entre le stockage basé sur les lignes (Avro) et le stockage basé sur les colonnes (Parquet), examinez cet ensemble de données :

La façon dont Avro stocke les données (par ligne) :

• [101, Alice, 25, New York]
• [102, Bob, 30, Chicago]
• [103, Carol, 28, Seattle]

Chaque enregistrement est stocké de manière séquentielle, ce qui le rend efficace pour les opérations d'écriture mais plus lent pour l'interrogation de champs spécifiques.

Comment Parquet stocke les données (en colonnes) :

• ID : [101, 102, 103]
• Nom : [Alice, Bob, Carol]
• Âge : [25, 30, 28]
• Ville : [New York, Chicago, Seattle]

Chaque colonne est stockée séparément, ce qui permet d'extraire plus rapidement les colonnes nécessaires (par exemple, la colonne "Âge").

Évolution du schéma

• Avro : Conçu pour l'évolution des schémas, il permet d'ajouter ou de modifier de nouveaux champs sans compromettre la compatibilité avec les données plus anciennes. Le schéma est stocké avec les données, ce qui le rend auto-descriptif.
• Parquet : Prend en charge l'évolution des schémas, mais est moins flexible qu'Avro. Les modifications de schéma peuvent être plus complexes, notamment lorsqu'il s'agit d'ajouter ou de modifier des structures de colonnes.

Efficacité de la compression et du stockage

• Avro : Utilise un encodage binaire compact, mais n'exploite pas les techniques de compression en colonnes, ce qui entraîne des tailles de fichiers plus importantes par rapport à Parquet.
• Parquet : Il utilise des techniques de compression en colonnes telles que l'encodage de dictionnaires, l'encodage de longueurs d'exécution et l'empilement de bits, ce qui le rend plus efficace en termes d'espace, en particulier pour les grands ensembles de données.

Performances des requêtes

• Avro : Il n'est pas optimisé pour les requêtes analytiques car il stocke les données par ligne. L'analyse de grands ensembles de données nécessite la lecture d'enregistrements entiers, ce qui ralentit les performances des requêtes dans les charges de travail analytiques.
• Parquet : Optimisé pour les requêtes rapides, en particulier lorsque seul un sous-ensemble de colonnes est nécessaire. Sa structure en colonnes permet un balayage sélectif, ce qui améliore les performances en matière d'analyse de données massives.

Efficacité en écriture et en lecture

• Avro : Il offre des vitesses d'écriture rapides puisqu'il stocke les données ligne par ligne. Toutefois, les opérations de lecture peuvent être plus lentes pour les analyses, car des lignes entières doivent être lues.
• Parquet : Optimisé pour les performances de lecture, mais peut avoir des vitesses d'écriture plus lentes en raison de la surcharge du stockage en colonnes et des techniques de compression.

Avro vs. Tableau comparatif des parquets

Quand utiliser Avro ou Parquet

Le choix entre Avro et Parquet dépend de votre cas d'utilisation spécifique, des caractéristiques de votre charge de travail et de vos exigences en matière de traitement des données. Vous trouverez ci-dessous des lignes directrices pratiques qui vous aideront à déterminer quand utiliser chaque format.

Quand utiliser Avro

Avro est le mieux adapté aux scénarios qui nécessitent une sérialisation efficace, une évolution des schémas et un stockage basé sur les lignes. Pensez à utiliser Avro dans les situations suivantes :

• Pipelines de données en continu et pilotés par les événements : Avro est largement utilisé dans les plateformes de flux de données en temps réel comme Apache Kafka en raison de son format binaire compact et de sa sérialisation efficace.
• L'évolution des schémas est fréquente : Avro est le choix préféré lorsqu'il s'agit de traiter des schémas de données évolutifs, car il incorpore le schéma dans le fichier, ce qui permet des modifications en douceur sans compromettre la compatibilité.
• Échange et intégration de données entre systèmes : Avro est couramment utilisé pour transmettre des données structurées entre différentes applications en raison de son schéma auto-descriptif et de la prise en charge de plusieurs langages de programmation.
• Charges de travail à forte intensité d'écriture : Si votre flux de travail implique des écritures ou des ajouts fréquents, Avro est plus performant que Parquet. Il stocke les données dans des rangées séquentielles sans les frais généraux de l'indexation en colonnes.
• Stockage de journaux et collecte de données brutes : Avro est souvent utilisé dans les systèmes d'enregistrement ou pour stocker des données brutes non traitées, en raison de l'efficacité de son stockage par ligne et de sa capacité à capturer des enregistrements détaillés.

Quand utiliser le parquet ?

Parquet est idéal pour les charges de travail analytiques, le traitement des données volumineuses et l'efficacité du stockage. Utilisez le parquet lorsque :

• Requêtes analytiques et entreposage de données : Si votre objectif principal est d'effectuer des requêtes rapides dans des lacs de données, des entrepôts de donnéesou dessystèmes OLAP (Online AnalyticalProcessing), la structure en colonnes de Parquet est très efficace.
• Charges de travail lourdes en lecture : Parquet est optimisé pour les scénarios dans lesquels les données sont lues fréquemment mais écrites moins souvent, tels que les tableaux de bord BI, les rapports et les analyses par lots.
• Big data et traitement distribué : Parquet est le format préféré des frameworks big data comme Apache Spark, Hive, Presto et Snowflake, où le stockage en colonnes réduit les coûts d'E/S et améliore les performances.
• Compression et optimisation du stockage : Si l'efficacité du stockage est une priorité, les techniques de compression avancées de Parquet (par exemple, l'encodage de dictionnaire, l'encodage de longueur d'exécution) réduisent de manière significative la taille des fichiers par rapport aux formats basés sur les lignes.
• Lecture sélective des colonnes et projection du schéma : Lorsque vous travaillez avec de grands ensembles de données mais que vous n'interrogez que quelques colonnes, Parquet permet un balayage sélectif des colonnes, ce qui accélère considérablement les requêtes et les rend plus rentables.

Lequel choisir ?

Comment Avro et Parquet fonctionnent avec les outils Big Data

Avro et Parquet sont largement utilisésdans les cadres de traitement des big data, les formes de cloud platet les environnements informatiques distribués. Vous trouverez ci-dessous un aperçu de la manière dont Avro et Parquet s'intègrent aux outils de big data les plus courants.

Apache Spark

Apache Spark est un cadre informatique distribué largement utilisé pour le traitement de grands ensembles de données. Il supporte à la fois Avro et Parquet, mais chaque format présente des avantages distincts en fonction du cas d'utilisation.

Utiliser Avro dans Apache Spark

• Avro est idéal pour l'ingestion de données et les pipelines ETL en raison de sa structure basée sur les lignes.
• Il permet l'évolution des schémas, ce qui en fait un choix privilégié pour les pipelines de streaming Kafka.
• Généralement utilisé comme format intermédiaire avant de convertir les données dans des formats adaptés à l'analyse comme Parquet.

Exemple :

from pyspark.sql import SparkSession

spark = SparkSession.builder.appName("AvroExample").getOrCreate()

# Read Avro file
df = spark.read.format("avro").load("data.avro")
df.show()

# Write DataFrame to Avro
df.write.format("avro").save("output.avro")

Utiliser Parquet dans Apache Spark

• Parquet est optimisé pour l'analytique et le traitement par lots dans Spark.
• Étant donné que les requêtes Spark impliquent souvent l'analyse de colonnes spécifiques, le stockage en colonnes de Spark réduit les E/S et accélère les requêtes.
• Il s'agit du format de stockage par défaut dans de nombreux lacs de données et environnements analytiques.

Exemple :

# Read Parquet file
df = spark.read.parquet("data.parquet")
df.show()

# Write DataFrame to Parquet
df.write.mode("overwrite").parquet("output.parquet")

Apache Hive et Presto

Apache Hive et Presto sont des moteurs de requête basés sur SQL et conçus pour les données volumineuses. Les deux moteurs prennent en charge Avro et Parquet, mais se comportent différemment :

Avro dans Hive et Presto

• Utilisé dans les flux de travail d'ingestion des données avant leur transformation dans un format optimisé.
• Il offre une certaine souplesse pour l'évolution du schéma, mais les requêtes peuvent être plus lentes en raison du balayage basé sur les lignes.

Exemple :

CREATE EXTERNAL TABLE avro_table
STORED AS AVRO
LOCATION 's3://my-data-bucket/avro/';

Parquet dans Hive et Presto

• Format préféré pour les analyses en raison de l'élagage des colonnes et de la compression efficace.
• Les requêtes sont nettement plus rapides car seules les colonnes nécessaires sont lues.

Exemple :

CREATE EXTERNAL TABLE parquet_table
STORED AS PARQUET
LOCATION 's3://my-data-bucket/parquet/';

Apache Kafka

Kafka est une plateforme de flux de données en temps réel, et Avro est la norme de facto pour la sérialisation des messages.

Pourquoi Avro est préféré dans Kafka

• Le format binaire compact réduit la taille des messages, ce qui diminue la largeur de bande et les coûts de stockage.
• La prise en charge de l'évolution des schémas garantit la compatibilité entre les producteurs et les consommateurs.
• Fonctionne de manière transparente avec Confluent Schema Registry, ce qui permet de contrôler la version des schémas.

Exemple :

from confluent_kafka import avro
from confluent_kafka.avro import AvroProducer

schema_registry_url = "http://localhost:8081"
avro_producer = AvroProducer({'bootstrap.servers': 'localhost:9092',
                              'schema.registry.url': schema_registry_url},
                             default_value_schema=avro.loads(value_schema_str))

avro_producer.produce(topic='avro_topic', value={"id": 1, "name": "Alice"})
avro_producer.flush()

Plateformes de données dans le cloud (AWS, GCP, Azure)

Avro et Parquet sont tous deux pris en charge par les principales plateformes cloud, mais sont utilisés différemment.

AWS (Amazon S3, Glue, Redshift, Athena)

• Avro: Utilisé pour le stockage de données en continu et l'évolution du schémadans les travaux ETL d'AWS Glue.
• Parquet: De préférence dans AWS Athena, RedshiftSpectrum, et les lacs de données pour une analyse plus rapide.

SELECT * FROM my_parquet_table WHERE year = 2023;

Google Cloud Platform (BigQuery, Dataflow, GCS)

• Avro: Utilisé pour ingérer des données brutes dans Google Dataflow.
• Parquet: Optimisé pour Google BigQuery, permettant une extraction par colonne.

LOAD DATA INTO my_dataset.my_table
FROM 'gs://my-bucket/data.parquet'
FORMAT PARQUET;

Azure (Azure Data Lake, Synapse Analytics, Databricks)

• Avro: Utilisé pour l'échange de données et les ingestion dans Azure Data Factory.
• Parquet: Préférezd à Azure Synapse Analytics et AzureDatabricks pour optimiser le stockage et l'analyse.

Pipelines ETL et entreposage de données

Les deux formats jouent des rôles différents dans les pipelines ETL :

Conclusion

Avro et Parquet sont des formats de stockage de données essentiels dans les écosystèmes de big data, chacun servant des objectifs différents. Ce billet explore leur architecture technique, les cas d'utilisation, l'intégration avec les outils big data et le rôle dans les pipelines ETL.

Les principaux enseignements à en tirer sont les suivants :

• Le format Avro, basé sur des lignes, est efficace pour la diffusion en continu, l'évolution des schémas et la sérialisation des données.
• Le format en colonnes de Parquet optimise les requêtes analytiques, la compression et l'efficacité du stockage.
• Les outils de big data tels que Apache Spark, Hive et Kafka s'intègrent à ces formats de différentes manières.
• Les pipelines ETL utilisent souvent les deux, Avro gérant l'ingestion des données brutes et Parquet permettant des analyses efficaces.

Pour renforcer les bases de l'entreposage de données et du traitement des big data, découvrez les concepts de l'entreposage de données. Pour en savoir plus sur le traitement des données en temps réel ou par lots, consultez le site Batch vs. Traitement des flux. Pour acquérir une expérience pratique des outils de big data, le cours Big Data Fundamentals with PySpark est un excellent point de départ.

La compréhension de ces formats de stockage et de leurs applications est essentielle pour concevoir des architectures de données évolutives et efficaces.