Apache Avro

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[5]: 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é.

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"]}
   ] 
 }

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.

import avro.schema
from avro.datafile import DataFileReader, DataFileWriter
from avro.io import DatumReader, DatumWriter
schema = avro.schema.parse(open("user.avsc").read())  # nécessite la connaissance du schéma pour pouvoir ecrire
writer = DataFileWriter(open("users.avro", "w"), DatumWriter(), schema)
writer.append({"name": "Alyssa", "favorite_number": 256})
writer.append({"name": "Ben", "favorite_number": 7, "favorite_color": "red"})
writer.close()

$ od -c users.avro
0000000    O   b   j 001 004 026   a   v   r   o   .   s   c   h   e   m
0000020    a 272 003   {   "   t   y   p   e   "   :       "   r   e   c
0000040    o   r   d   "   ,       "   n   a   m   e   s   p   a   c   e
0000060    "   :       "   e   x   a   m   p   l   e   .   a   v   r   o
0000100    "   ,       "   n   a   m   e   "   :       "   U   s   e   r
0000120    "   ,       "   f   i   e   l   d   s   "   :       [   {   "
0000140    t   y   p   e   "   :       "   s   t   r   i   n   g   "   ,
0000160        "   n   a   m   e   "   :       "   n   a   m   e   "   }
0000200    ,       {   "   t   y   p   e   "   :       [   "   i   n   t
0000220    "   ,       "   n   u   l   l   "   ]   ,       "   n   a   m
0000240    e   "   :       "   f   a   v   o   r   i   t   e   _   n   u
0000260    m   b   e   r   "   }   ,       {   "   t   y   p   e   "   :
0000300        [   "   s   t   r   i   n   g   "   ,       "   n   u   l
0000320    l   "   ]   ,       "   n   a   m   e   "   :       "   f   a
0000340    v   o   r   i   t   e   _   c   o   l   o   r   "   }   ]   }
0000360  024   a   v   r   o   .   c   o   d   e   c  \b   n   u   l   l
0000400   \0 211 266   / 030 334   ˪  **   P 314 341 267 234 310   5 213
0000420    6 004   ,  \f   A   l   y   s   s   a  \0 200 004 002 006   B
0000440    e   n  \0 016  \0 006   r   e   d 211 266   / 030 334   ˪  **
0000460    P 314 341 267 234 310   5 213   6
0000471

reader = DataFileReader(open("users.avro", "r"), DatumReader())  # le schéma est intégré dans le fichier avro
for user in reader:
    print user
reader.close()

{u'favorite_color': None, u'favorite_number': 256, u'name': u'Alyssa'}
{u'favorite_color': u'red', u'favorite_number': 7, u'name': u'Ben'}

Bien qu'en principe, il soit possible d'utiliser tout type de langage avec Avro, les langages suivants disposent d'une Api[9] - [10] :

• C
• C++
• C#[11] - [12] - [13]
• GO
• Haskell[14]
• Java
• Perl
• PHP
• Python
• Ruby
• Scala

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.

• Apache Thrift
• Protocol Buffers
• Etch (protocole)
• MessagePack
• Apache Parquet
• Apache Kafka
• Apache Druid
• Apache ORC

• Tom White, Hadoop: The Definitive Guide, novembre 2010 (ISBN 978-1-4493-8973-4)