Avro est un framework de remote procedure call et de sérialisation de données élaboré au sein du projet Apache Hadoop. Il utilise JSON pour la définition des types de données et des protocoles, et sérialise les données dans un format binaire plus compact. La principale utilisation est dans Apache Hadoop, où il peut fournir à la fois un format de sérialisation pour les données persistantes, et un format "filaire" pour la communication entre les nœuds Hadoop, et de programmes client pour services Hadoop.
Il est similaire à Apache Thrift et Protocol Buffers, mais ne nécessite pas d'exécuter un programme de génération de code lors d'un changement de schéma (sauf si désiré pour les langages statiquement-typés).
Avro est reconnu et accepté par Apache Spark SQL comme source de données..
Fichier Avro Object Container Un fichier Avro Object Container se compose de: un en-tête, suivi par un ou plusieurs blocs de données. L'en-tête se compose de: quatre octets ASCII 'O', 'b', 'j', suivi par 1. les métadonnées du fichier, y compris la définition de schéma. Le marqueur de synchronisation pour ce fichier. Il est constitué de 16 octets générés de façon aléatoire. Pour les blocs de données Avro spécifie deux encodages de sérialisation: binaire et JSON. La plupart des applications utiliseront le codage binaire, car il est plus petit et plus rapide. Pour le débogage et les applications Web, l'encodage JSON peut parfois être approprié.
Définition d'un schéma Dans Avro, les schémas sont définis à l'aide de JSON. Ils sont composés de types primitifs (null, boolean, int, long, float, double, bytes, string) ou complexes (record, enum, array, map, union, fixed).
Exemple de schéma : { "namespace": "example.avro", "type": "record", "name": "User", "fields": [ {"name": "name", "type": "string"}, {"name": "favorite_number", "type": ["int", "null"]}, {"name": "favorite_color", "type": ["string", "null"]} ]
La sérialisation et la désérialisation
Les données en Avro peuvent être stockées avec le schéma correspondant, ce qui signifie qu'un élément sérialisé peut être lu sans connaître le schéma à l'avance.
Exemple de sérialisation et de désérialisation code en Python
La sérialisation :
import avro.schema from avro.datafile import DataFileWriter from avro.io import DatumWriter
schema = avro.schema.parse(open("user.avsc").read())
with DataFileWriter(open("users.avro", "wb"), DatumWriter(), schema) as writer: writer.append({"name": "Alyssa", "favorite_number": 256}) writer.append({"name": "Ben", "favorite_number": 7, "favorite_color": "red"})
Fichier "users.avro" va contenir le schéma JSON et une représentation compact binaire des données: $ od -c users.avro 0000000 O b j 001 004 024 a v r o . c o d e c 0000020 \b n u l l 026 a v r o . s c h e m 0000040 a 272 003 { " t y p e " : " r e c 0000060 o r d " , " n a m e " : " U 0000100 s e r " , " n a m e s p a c e 0000120 " : " e x a m p l e . a v r o 0000140 " , " f i e l d s " : [ { " 0000160 t y p e " : " s t r i n g " , 0000200 " n a m e " : " n a m e " } 0000220 , { " t y p e " : [ " i n t 0000240 " , " n u l l " ] , " n a m 0000260 e " : " f a v o r i t e _ n u 0000300 m b e r " } , { " t y p e " : 0000320 [ " s t r i n g " , " n u l 0000340 l " ] , " n a m e " : " f a 0000360 v o r i t e _ c o l o r " } ] } 0000400 \0 023 222 277 261 341 M 2 g W 254 224 1 373 q f 0000420 177 004 , \f A l y s s a \0 200 004 002 006 B 0000440 e n \0 016 \0 006 r e d 023 222 277 261 341 M 2 0000460 g W 254 224 1 373 q f 177 0000471
La désérialisation :
from avro.datafile import DataFileReader from avro.io import DatumReader
with DataFileReader(open("users.avro", "rb"), DatumReader()) as reader: for user in reader: print(user)
Sortie :
{'name': 'Alyssa', 'favorite_number': 256, 'favorite_color': None} {'name': 'Ben', 'favorite_number': 7, 'favorite_color': 'red'}
Langages avec les API Bien qu'en principe, il soit possible d'utiliser tout type de langage avec Avro, les langages suivants disposent d'une API : C C++ C# GO Haskell Java Perl PHP Python Ruby Scala
Avro IDL En plus de prendre en charge JSON pour les types et les définitions de protocole, Avro inclut un support expérimental pour une autre syntaxe de langage de description d'interface (IDL) connue sous le nom d'Avro IDL. Précédemment connu sous le nom GenAvro, ce format est conçu pour faciliter son adoption par les utilisateurs familiers avec des IDL et langages de programmation plus traditionnels, avec une syntaxe similaire à C / C ++, Protocol Buffers et autres.
Voir aussi Apache Iceberg Apache Thrift Protocol Buffers Etch (protocole) MessagePack Apache Parquet Apache Kafka Apache Druid Apache ORC
Références
Bibliographie
Catégorie:Protocole réseau sur la couche application Catégorie:Format de sérialisation de données Catégorie:Communication inter-processus Catégorie:Écosystème Hadoop