Apache Avro

Un article de Wikipédia, l'encyclopédie libre.
Sauter à la navigation Sauter à la recherche
Apache Avro

Informations
Développé par Apache Software FoundationVoir et modifier les données sur Wikidata
Dernière version 1.9.1 ()[1]Voir et modifier les données sur Wikidata
Dépôt github.com/apache/avroVoir et modifier les données sur Wikidata
Écrit en JavaVoir et modifier les données sur Wikidata
Type Format de sérialisation de données (d)Voir et modifier les données sur Wikidata
Licence Licence Apache version 2.0Voir et modifier les données sur Wikidata
Site web avro.apache.orgVoir et modifier les données sur Wikidata

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[2].

Fichier Avro Object Container[3][modifier | modifier le code]

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:[4] 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[5][modifier | modifier le code]

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[modifier | modifier le code]

Les données en Avro peuvent être stockées avec le schéma correspondant, ce qui signifie que l'article 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[6][modifier | modifier le code]

La sérialisation:

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()

Fichier "users.avro" va contenir le schéma JSON et une  représentation compact binaire[7] des données:

$ 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

La désérialisation:


reader = DataFileReader(open("users.avro", "r"), DatumReader())  # nécessite la connaissance du schéma pour pouvoir lire
for user in reader:
    print user
reader.close()


Output:


{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'}

Langues avec les Api[modifier | modifier le code]

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

Avro IDL[modifier | modifier le code]

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[modifier | modifier le code]

Références[modifier | modifier le code]

  1. « Release 1.9.1 » (consulté le 2 septembre 2019)
  2. http://dataconomy.com/3-reasons-hadoop-analytics-big-deal/
  3. « Apache Avro™ Specification: Object Container Files », sur avro.apache.org (consulté le 27 septembre 2016)
  4. « Apache Avro™ 1.8.2 Specification », sur avro.apache.org (consulté le 19 octobre 2017)
  5. « Apache Avro™ Getting Started ==(Python) », sur avro.apache.org (consulté le 16 juin 2016)
  6. « Apache Avro™ Getting Started (Python) », sur avro.apache.org (consulté le 16 juin 2016)
  7. « Apache Avro™ Specification: Data Serialization », sur avro.apache.org (consulté le 16 juin 2016)
  8. phunt, « GitHub - phunt/avro-rpc-quickstart: Apache Avro RPC Quick Start. Avro is a subproject of Apache Hadoop. », GitHub, sur GitHub (consulté le 13 avril 2016)
  9. « Supported Languages - Apache Avro - Apache Software Foundation » (consulté le 21 avril 2016)
  10. « Avro: 1.5.1 - ASF JIRA » (consulté le 13 avril 2016)
  11. « [AVRO-533] .NET implementation of Avro - ASF JIRA » (consulté le 13 avril 2016)
  12. « Supported Languages » (consulté le 13 avril 2016)
  13. « Native Haskell implementation of Avro », Thomas M. DuBuisson, Galois, Inc. (consulté le 8 août 2016)

Bibliographie[modifier | modifier le code]