Apache Avro

Apache Avro
Deweloperzy Fundacja oprogramowania Apache
Pierwsze wydanie 2 listopada 2009 ; 13 lat temu ( 2009-11-02 )
Wersja stabilna
1.11.1 / 31 lipca 2022 r. ; 7 miesięcy temu ( 2022-07-31 )
Magazyn Repozytorium Avro
Napisane w Java , C , C++ , C# , Perl , Python , PHP , Ruby
Typ Struktura zdalnego wywoływania procedur
Licencja Licencja Apache 2.0
Strona internetowa avro .apache .org

Avro to zorientowana na wiersze struktura zdalnego wywoływania procedur i serializacji danych , opracowana w ramach projektu Hadoop firmy Apache . Używa formatu JSON do definiowania typów danych i protokołów oraz serializuje dane w zwartym formacie binarnym. Jego głównym zastosowaniem jest Apache Hadoop , gdzie może zapewnić zarówno format serializacji dla trwałych danych , jak i format przewodowy do komunikacji między węzłami Hadoop oraz z programów klienckich do usług Hadoop . Avro używa schematu do strukturyzowania danych, które są kodowane. Ma dwa różne typy języków schematów; jeden do edycji przez człowieka (Avro IDL), a drugi, który jest bardziej czytelny dla maszyny w oparciu o JSON.

Jest podobny do Thrift i Protocol Buffers , ale nie wymaga uruchamiania programu generującego kod, gdy zmienia się schemat (chyba że jest to pożądane w przypadku języków o typie statycznym ).

Apache Spark SQL może uzyskiwać dostęp do Avro jako źródła danych.

Plik kontenera obiektów Avro

Plik kontenera obiektów Avro składa się z:

Nagłówek pliku składa się z:

  • Cztery bajty, ASCII „O”, „b”, „j”, po których następuje numer wersji Avro, czyli 1 (0x01) (wartości binarne 0x4F 0x62 0x6A 0x01).
  • Metadane pliku, w tym definicja schematu.
  • 16-bajtowy, losowo generowany znacznik synchronizacji dla tego pliku.

Dla bloków danych Avro określa dwa kodowania serializacji: binarne i JSON. Większość aplikacji użyje kodowania binarnego, ponieważ jest ono mniejsze i szybsze. W przypadku debugowania i aplikacji internetowych czasami odpowiednie może być kodowanie JSON.

Definicja schematu

Schematy Avro są definiowane przy użyciu formatu JSON. Schematy składają się z typów pierwotnych (null, boolean, int, long, float, double, bytes i string) oraz typów złożonych (record, enum, array, map, union i fixed).

Prosty przykład schematu:

 
    
    
    
    
         
           
          
    
  {  "przestrzeń nazw"  :  "przykład.avro"  ,  "typ"  :  "rekord"  ,  "nazwa"  :  "Użytkownik"  ,  "pola"  :  [  {  "nazwa"  :  "nazwa"  ,  "typ"  :  "ciąg"  },  {  "nazwa"  :  "numer_ulubionych"  ,  "typ"  :  [  "null"  ,  "int"  ]},  {  "nazwa"  :  "kolor_ulubionych"  ,  "typ"  :  [  "null"  ,  "string"  ]}  ]  }

Serializacja i deserializacja

Dane w Avro mogą być przechowywane z odpowiadającym im schematem, co oznacza, że ​​serializowany element można odczytać bez wcześniejszej znajomości schematu.

Przykładowy kod serializacji i deserializacji w Pythonie

Serializacja:

 
    
    


   

     
   
     
 import  avro.schema  z  avro.datafile  import  DataFileReader  ,  DataFileWriter  z  avro.io  import  DatumReader  ,  DatumWriter  # Trzeba znać schemat do pisania. Zgodnie z 1.8.2 Apache Avro   schema  =  avro  .  schemat  .  parse  (  open  (  "user.avsc"  ,  "rb"  )  .  read  ())  writer  =  DataFileWriter  (  open  (  "users.avro"  ,  "wb"  ),  DatumWriter  (),  schema  )  pisarz  .  append  ({  "imię"  :  "Alyssa"  ,  "numer_ulubionych"  :  256  })  pisarz  .  append  ({  "imię"  :  " Ben "  ,  " numer_ulubionych "  :  8  ,  " kolor_ulubionych "  :  " czerwony "  } )  pisarz  .  zamknij  ()

Plik „users.avro” będzie zawierał schemat w formacie JSON oraz kompaktową binarną reprezentację danych:

      
                  
                  
                  
                  
                  
                  
                  
   $  od  -v  -t  x1z  users.avro  0000000  4f  62  6a  01  04  14  61  76  72  6f  2e  63  6f  64  65  63  >  Obiekt... avro.codec  <  0000020  08  6e  75  6c  6c  16  61  76  72  6f  2e  73  63  68  65  6d  >  .null.avro.schem  <  0000040  61  ba  03  7b  22  74  79  70  65  22  3a  20  22  72  65  63  >  a..{"type": "rec  <  0000060  6f  72  64  22  2c  20  22  6e  6 1  6d  65  22  3a  20  22  55  >  ord", "name": "U  <  0000100  73  65  72  22  2c  20  22  6e  61  6d  65  73  70  61  63  65  >  ser", "przestrzeń nazw  <  0000120  22  3a  20  22  65  78  6 1  6d  70  6c  65  2e  61  76  72  6f  >  ": "przyklad.avro  <  0000140  22  2c  20  22  66  69  65  6c  64  73  22  3a  20  5b  7b  22  >  ", "pola": [{"  <  0000160  74 79  7  70 65 22 3a 20 22 73 74 72 69 6e 67 22 2c  >type": "string",<
0000200 20 22 6e 61 6d 65 22 3a 20 22 6e 61 6d 65 22 7d  > "name": "name"}<
0000220 2c 20 7b 22 74 79 70 65 22 3a 20 5b 22 69 6e 74  >, {"type": ["int<
0000240 22 2c 20 22 6e 75 6c 6c 22 5d 2c 20 22 6e 61 6d  >", "null"], "nam<
0000260 65 22 3a 20 22 66 61 76 6f 72 69 74 65 5f 6e 75  >e": "favorite_nu<
0000300 6d 62 65 72 22 7d 2c 20 7b 22 74 79 70 65 22 3a  >mber"}, {"type":<
0000320 20 5b 22 73 74 72 69 6e 67 22 2c 20 22 6e 75 6c  > ["string", "nul<
0000340 6c 22 5d 2c 20 22 6e 61 6d 65 22 3a 20 22 66 61  >l"], "name": "fa<
0000360 76 6f 72 69 74 65 5f 63 6f 6c 6f 72 22 7d 5d 7d  >vorite_color"}]}<
0000400 00 05 f9 a3 80 98 47 54 62 bf 68 95 a2 ab 42 ef  >......GTb.h...B.<
0000420 24 04 2c 0c 41 6c 79 73 73 61 00 80 04 02 06 42  >$.,.Alyssa.....B<
0000440 65 6e 00 10 00 06 72 65 64 05 f9 a3 80 98 47 54  >en....red.....GT<
0000460 62 bf 68 95 a2 ab 42 ef 24                       >b.h...B.$<
0000471

Deserializacja:


    
   
    
 # Schemat jest osadzony w pliku danychreader  =  DataFileReader  (  open  (  "  users.avro"  ,  "rb"  ),  DatumReader  ())  dla  użytkownika  w  czytniku  :  print  (  user  )  reader  .  zamknij  ()

To wyprowadza:

     
      {  u  „ulubiony_kolor”  :  brak  ,  u  „numer_ulubionego”  :  256  ,  u  „imię”  :  u  „Alyssa”  }  {  u  „ulubiony_kolor”  :  u  „czerwony”  ,  u  „numer_ulubionego”  :  8  ,  u  „imię”  :  u  „ Ben'  }

Języki z interfejsami API

Chociaż teoretycznie każdy język mógłby używać Avro, następujące języki mają napisane dla nich interfejsy API:

Avro IDL

Oprócz obsługi JSON dla definicji typów i protokołów, Avro zawiera eksperymentalną obsługę alternatywnej składni języka opisu interfejsu (IDL), znanej jako Avro IDL. Wcześniej znany jako GenAvro, ten format został zaprojektowany w celu ułatwienia przyjęcia przez użytkowników zaznajomionych z bardziej tradycyjnymi językami IDL i językami programowania, ze składnią podobną do C/C++, buforów protokołów i innych.

Logo Apache Avro pochodzi od nieistniejącego brytyjskiego producenta samolotów Avro (pierwotnie AV Roe and Company). Drużyna piłkarska Avro FC używa tego samego logo.

Zobacz też

Dalsza lektura

Pobrano z „ https://en.wikipedia.org/w/index.php?title=Apache_Avro&oldid=1140772811 ”