Protobuf

Prévia do material em texto

UNIVERSIDADE FEDERAL DE ITAJUBÁ
INSTITUTO DE MATEMÁTICA E COMPUTAÇÃO
COM242 - Sistemas Distribúıdos
Prof. Rafael Frinhani
Tutotrial
Protocol Buffer
Grupo:
Fabian Ferreira Samohod - 2018003740
Isabela Corsi - 2018016354
Ricardo Dalarme de Oliveira Filho - 2018002475
31 de Maio, 2019
Sumário
1 Introdução 1
1.1 Definição . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2 Caracteristicas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.3 Vantagens para com outros Métodos/Formatos . . . . . . . . . . . . . . . . . . . 2
2 Desenvolvimento 2
2.1 Instalação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
2.2 O arquivo .proto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.3 Compilação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.4 Escrevendo uma message . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.5 Lendo uma message . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
3 Conclusão 10
Referências 10
1 Introdução
Neste Tutorial vamos explorar um método binário para serialização de dados entre diferentes sis-
temas, chamado Protocol Buffers (Protobuf). Primeiramente daremos uma breve apresentação,
mostrando a finalidade do Protobuf, suas caracteŕısticas e comparando-o a outros metodos/for-
matos de serialização para troca de dados entre sistemas. Então fazemos um passo a passo de
como instalar, codar e executar o Protobuf, usando um arquivo .proto que manipula dados de
uma lista telefônica como exemplo e as linguagens Python e C para execução.
1.1 Definição
Protocol Buffers, ou simplesmente Protobuf, é um protocolo binário criado pela Google com o
objetivo de elaborar um formato de serialização/deserialização de dados estruturados. Pensado
para tentar garantir melhor comunicação entre diferentes sistemas, que tivesse um desempenho
superior ao já popularizado XML. [Krebs, 2017]
1.2 Caracteristicas
O Protobuf possui diversas caracteristicas próprias devido a sua implementação, citamos abaixo
algumas das principais que tornam seu uso atrativo:
• Devido ao método estruturado de dados definido pelo Protobuf, os Schemas (escritos em
arquivo .proto com sintaxe proto2 ou proto3), é garantida a integridade de Dados durante
o transporte entre diferentes sistemas.
• Como nos Schemas os campos são definidos enumeradamente, é dispensada a necessidade
de se fazer a verificação de compatibilidade entre versões.
• Com um único arquivo .proto podemos estanciar classes stub em qualquer linguagem
suportada pelo método. Isto permite que trabalhemos apenas com o código do arquivo
.proto que foi instanciado, sem precisar utilizar bibliotecas de terceiros e assim evitando
problemas como duplicação de código ou exposição de regras de negócio.
1
• O Schema e suas palavras chave (Required, Optional, Repeated) geram flexibilização no
projeto. Caso precise alterar a estrutura de dados é só modificar o arquivo .proto e
instanciar uma nova classe com ele.
[Souza, 2018]
1.3 Vantagens para com outros Métodos/Formatos
Conhecendo os conceitos por trás do Protobuf, chegou a hora de compara-lo a outros métodos
e formatos que tem o mesmo objetivo. Como foi mostrado anteriormente, o protobuf foi imple-
mentado visando superar os atributos e execução do formato XML. Desta forma o protobuf se
apresenta um formato mais simples, menor e mais rápido, comparado a XML.
Em relação ao formato JSON, quase sempre o Protobuf se mostrou como a melhor escolha.
Rodando testes de desempenho no quesito tamanho e velocidade, os dados serializados por meio
do Protobuf se mostraram menores do que os dados armazenados em JSON. E a velocidade em
que um dado era serializado - enviado - recebido - deserializado, se mostou maior em Protobuf
do que em JSON.
Mesmo obtendo melhores resultados com Protocol Buffers, existem determinadas situações
na qual o formato JSON se sobressai (situações para as quais JSON foi desenvolvido). São elas:
• Quando o código necessita de legibilidade Humana;
• Aplicações Server escritas em JavaScript;
• Modelos de Dados Dinâmicos (protobuf trabalha bem com Dados estruturados estáticos);
• Dados que serão diretamente consumidos em web browser.
2 Desenvolvimento
2.1 Instalação
Para realizar a instalação do protobuf, no Windows, primeiramente é necessário acessar este
link: Protobuf Download Link. Na seção ’Other’, deve-se localizar o arquivo nomeado como:
protoc-3.17.0-win32.zip ou protoc-3.17.0-win64.zip. E clicar neste arquivo para inciar o
download, sendo o primeiro arquivo para Windows 32 bits, e o segundo para 64 bits.
Após o arquivo estiver feito o download completo, é necessário ir até a pasta onde ele está
localizado, e extrair todos os arquivos. Em seguida, o arquivo .exe do protoc estará localizado
dentro da pasta chamada ’bin’.
Com os passos acima já realizados, agora será necessário realizar os seguintes passos:
1. Ir até o Painel de Controle;
2. Acessar Sistema e Segurança;
3. Acessar Sistema;
4. E clicar em: Configurações avançadas do sistema.
Após o passo 4, uma nova janela de Variáveis de Ambiente será aberta, e nela será necessário:
1. Na lista de ‘Variáveis do Sistema’ localizar a variável Path e selecioná-la;
2. Clicar em Editar;
3. Clicar em novo;
4. E colocar o diretório onde o arquivo protoc está localizado..
2
https://www.github.com/protocolbuffers/protobuf/releases
Para testar se o protoc foi instalado com sucesso na máquina, é necessário abrir o Prompt
de Comando e digitar o comando ’protoc’, e a seguinte tela da figura 1 deve aparecer.
Figura 1: Protoc no Prompt de Comando
Dessa formo, o Protocol Buffer, já está instalado.
2.2 O arquivo .proto
O arquivo .proto, é onde os dados serão estruturados da maneira desejada.
Mostra um exemplo de um arquivo de extensão .proto, chamado ’addressbook’.
1 syntax = "proto2 ";
2
3 package tutorial;
4
5 message Person {
6 optional string name = 1;
7 optional int32 id = 2;
8 optional string email = 3;
9
10 enum PhoneType {
11 MOBILE = 0;
12 HOME = 1;
13 WORK = 2;
14 }
15
16 message PhoneNumber {
17 optional string number = 1;
18 optional PhoneType type = 2 [default = HOME];
19 }
20
21 repeated PhoneNumber phones = 4;
22 }
23
24 message AddressBook {
25 repeated Person people = 1;
26 }
Esta estrutura é definida primeiramente em determinar qual versão de sintaxe, podendo
ser ela ”proto2”ou ”proto3”, que no caos, foi definida na Linha 1.
Já na Linha 3, temos o package, ou seja, uma declaração de pacote, na qual serve para
evitar conflitos ente nomenclaturas de projetos distintos, e este é opcional.
3
E, em seguida, são definidas as mensagens, a message, nela contém um ou mais campos e
estes campos podem ser do tipo bool, int32, float, double e string. Pode-se também adicionar
mais estrutura às mensagens usando outros tipos de mensagens como tipos de campo.No exem-
plo, a mensagem Person contém mensagens PhoneNumber, enquanto a mensagem AddressBook
contém mensagens Person.
Além disso, também é posśıvel definir tipos de mensagem aninhados dentro de outras men-
sagens, como por exemplo, o tipo PhoneNumber é definido dentro de Person. E o tipo enum, é
usado quando se deseja que um dos campos tenha um de uma lista pré-definida de valores, no
caso, deseja-se especificar que um número de telefone pode ser MOBILE, HOME ou WORK.
É notável também que cada campo deve ser enumerado, uma ”tag”exclusiva que o campo
usa na codificação binária. E estes não podem ser modificados uma vez que uma mensagem já
foi utilizada.
Por fim, cada campo possui uma keywords, e são elas:
• Optional : este campo é opcional, e ele não pode ser repetido;
• Repeated: este campo de ser repetido quantas vezes desejar;
• Required: este campo é obrigatório, caso contrário, a mensagemnão será inicializada.
2.3 Compilação
Com o arquivo .proto feito, é necessário gerar classes para que seja posśıvel escrever e ler men-
sagens. E para isto, deve-se realizar a compilação do arquivo na linguagem desejada, podendo
ser elas C++, C#, JavaScrpit, PHP, Ruby, Python, Java, entre outras. Para este tutorial, será
usado as linguagem Python e C#.
Para a compilação em Python, é preciso utilizar o seguinte comando no terminal:
protoc -I=$SRC DIR –python out=$DST DIR $SRC DIR/addressbook.proto
E para a compilação em C#, é preciso utilizar o seguinte comando:
protoc -I=$SRC DIR –csharp out=$DST DIR $SRC DIR/addressbook.proto
Sendo SCR DIR, o local de origem e DST DIR o local de destino. O argumento ”I”, é o local
onde o arquivo .proto está localizado, ou seja, seu diretório. E os argumentos ”-python out”e
”-csharp out”deve conter a pasta na qual a classe será gerada. E cada linguagem possui um
argumento ”out”diferente. Para saber estes basta executar o comando ”protoc –help”.
Caso a pasta de origem e destino sejam a mesma, os seguintes comando podem ser utilizados:
protoc -I=. –python out=. addressbook.proto
protoc -I=. –csharp out=. addressbook.proto
Após os comandos serem executados, será gerado dois arquivos, em Python, o address-
book pb2.py, e o outro arquivo em C# addressbook.cs.
2.4 Escrevendo uma message
Com os arquivos de classes feitos, agora é posśıvel escrever uma mensagem com base nos campos
definidos anteriormente. O código em Python a seguir permite fazer isto.
4
1 import addressbook_pb2
2 import sys
3
4 def PromptForAddress(person):
5 person.id = int(input("Coloque o numero ID (3 digitos): "))
6 person.name = input("Insira o nome: ")
7
8 email = input("Insira o email (caso nao tenha , deixe em branco)
: ")
9 if email != "":
10 person.email = email
11
12 while True:
13 number = input("Insira o numero de telefone (DDD 1234 -56789) ,
caso nao tenha , deixe em branco: ")
14 if number == "":
15 break
16
17 phone_number = person.phones.add()
18 phone_number.number = number
19
20 type = input("E o numero do seu celular , da sua casa ou do
seu trabalho? ")
21 if type == "celular":
22 phone_number.type = addressbook_pb2.Person.PhoneType.MOBILE
23 break
24 elif type == "casa":
25 phone_number.type = addressbook_pb2.Person.PhoneType.HOME
26 break
27 elif type == "trabalho":
28 phone_number.type = addressbook_pb2.Person.PhoneType.WORK
29 break
30 else:
31 print ("Tipo de telefone incorreto!")
32
33
34 #adiciona uma pessoa com base na entrada do usuario e em seguida
escreve de volta para o mesmo arquivo
35 if len(sys.argv) != 2:
36 print ("Usage:", sys.argv[0], "ADDRESS_BOOK_FILE")
37
38
39 address_book = addressbook_pb2.AddressBook ()
40
41
42 try:
43 f = open(sys.argv[1], "rb")
44 address_book.ParseFromString(f.read())
45 f.close ()
46 except IOError:
5
47 print (sys.argv [1] + ": Could not open file. Creating a new
one.")
48
49 # Add
50 PromptForAddress(address_book.people.add())
51
52 # Escreve
53 f = open(sys.argv[1], "wb")
54 f.write(address_book.SerializeToString ())
55 f.close ()
E a seguir, tem-se o código escrito na linguagem C#, que também possui a funcionalidade
de inserir dados nos campos da mensagem.
1 using System;
2 using System.IO;
3 using Google.Protobuf;
4 using Google.Protobuf.Examples.AddressBook;
5
6 namespace Protobuf
7 {
8 static class WriteProto
9 {
10 static string FilePath = "C:\\ Users \\ Ricardo \\ Desktop \\proto \\faa";
11
12 private static Person PromptForAddress(TextReader input , TextWriter
output)
13 {
14 Person person = new Person ();
15
16 output.Write (" oloque o numero ID (3 digitos): : ");
17 person.Id = int.Parse(input.ReadLine ());
18
19 output.Write ("Enter name: ");
20 person.Name = input.ReadLine ();
21
22 output.Write ("nsira o email (caso nao tenha , deixe em branco):
");
23 string email = input.ReadLine ();
24 if (email.Length > 0)
25 {
26 person.Email = email;
27 }
28
29 while (true){
30 output.Write ("nsira o numero de telefone (DDD 1234 -56789) ,
caso nao tenha , deixe em branco: ");
31 string number = input.ReadLine ();
32 if (number.Length == 0)
33 {
34 break;
35 }
36
37 Person.Types.PhoneNumber phoneNumber = new Person.Types.
PhoneNumber { Number = number };
38
39 output.Write (" o numero do seu celular , da sua casa ou doseu
trabalho? "");
40 String type = input.ReadLine ();
41 switch (type)
42 {
43 case "celular ":
6
44 phoneNumber.Type = Person.Types.PhoneType.Mobile;
45 break;
46 case "casa":
47 phoneNumber.Type = Person.Types.PhoneType.Home;
48 break;
49 case "trabalho ":
50 phoneNumber.Type = Person.Types.PhoneType.Work;
51 break;
52 default:
53 output.Write("Tipo de telefone incorreto !");
54 break;
55 }
56
57 person.Phones.Add(phoneNumber);
58 }
59 return person;
60 }
61
62
63 public static int Write ()
64 {
65 AddressBook addressBook;
66
67 if (File.Exists(FilePath))
68 {
69 using (Stream file = File.OpenRead(FilePath))
70 {
71 addressBook = AddressBook.Parser.ParseFrom(file);
72 }
73 }
74 else
75 {
76 Console.WriteLine ("{0}: File not found. Creating a new file.",
FilePath);
77 addressBook = new AddressBook ();
78 }
79
80 // Add an address.
81 addressBook.People.Add(PromptForAddress(Console.In, Console.Out));
82
83 // Write the new address book back to disk.
84 using (Stream output = File.OpenWrite(FilePath))
85 {
86 addressBook.WriteTo(output);
87 }
88 return 0;
89 }
90 }
91 }
Após os códigos serem compilados com sucesso, será posśıvel começar a inserir os dados do
número de ID, o nome, o e-mail, o número de telefone e o tipo de telefone (casa, celular ou
trabalho), e assim, uma nova Person será adicionada. Como mostra de exemplo na figura 2, 3
e 4
Figura 2: Exemplo de preenchimento dos campos da mensagem 1
7
Figura 3: Exemplo de preenchimento dos campos da mensagem 2
Figura 4: Exemplo de preenchimento dos campos da mensagem 3
2.5 Lendo uma message
Com os campos da mensagem preenchidos, agora é posśıvel visualizar elas, com o seguinte código
em linguagem Python.
1 import addressbook_pb2
2 import sys
3
4 # Interacao para mostrar todos os registros feitos em "AddPerson"
5 def ListPeople(address_book):
6 for person in address_book.people:
7 print ("ID:", person.id)
8 print (" Nome:", person.name)
9 if person.HasField(’email’):
10 print (" E-mail:", person.email)
11
12 for phone_number in person.phones:
13 if phone_number.type == addressbook_pb2.Person.PhoneType.
MOBILE:
14 print (" Numero de celular: " + (phone_number.number)),
15 elif phone_number.type == addressbook_pb2.Person.PhoneType.
HOME:
16 print (" Numero da casa: " + (phone_number.number)),
17 elif phone_number.type == addressbook_pb2.Person.PhoneType.
WORK:
18 print (" Numero do trabalho : " + (phone_number.number))
,
19
20 if len(sys.argv) != 2:
21 print ("Usage:", sys.argv[0], "ADDRESS_BOOK_FILE")
22
23 address_book = addressbook_pb2.AddressBook ()
24
25 f = open(sys.argv[1], "rb")
26 address_book.ParseFromString(f.read())
27 f.close ()
28
8
29 ListPeople(address_book)
E a seguir o código na linguagem C#, também para a visualização da mensagem.
1 using System;
2 using System.IO;
3 using Google.Protobuf;
4 using Google.Protobuf.Examples.AddressBook;
5
6 namespace Protobuf
7 {
8 static class ReadProto
9 {
10 private static void Print(AddressBook addressBook)
11 {
12 foreach (Person person in addressBook.People)
13 {
14 Console.WriteLine ("ID: {0}", person.Id);
15 Console.WriteLine (" Nome: {0}", person.Name);
16 if (person.Email != "")
17 {
18 Console.WriteLine (" E-mail: {0}", person.Email);
19 }
20
21 foreach (Person.Types.PhoneNumber phoneNumber in person.Phones)
22 {
23 switch (phoneNumber.Type)
24 {
25 case Person.Types.PhoneType.Mobile:
26 Console.Write(" Numero de celular #: ");
27 break;
28 case Person.Types.PhoneType.Home:
29 Console.Write(" Numero da casa #: ");
30 break;31 case Person.Types.PhoneType.Work:
32 Console.Write(" Numero do trabalho #: ");
33 break;
34 }
35 Console.WriteLine(phoneNumber.Number);
36 }
37 }
38 }
39
40 public static void Read()
41 {
42 Person john;
43 using (var input = File.OpenRead ("C:\\ Users\\ Ricardo \\ Desktop \\ proto
\\faa"))
44 {
45 AddressBook addressBook = AddressBook.Parser.ParseFrom(input);
46 Print(addressBook);
47 }
48 }
49 }
50 }
Após o código compilado, os campos serão mostrados como exemplificado na figura 5
9
Figura 5: Exemplo da visualização da mensagem
3 Conclusão
Ao longo deste tutorial apresentamos os principais conceitos que envolvem o protocolo desen-
volvido pela Google para serializar/deserializar e enviar dados, o Protocol Buffers. Abrangemos
o método completo, desde a escrita de um arquivo .proto (onde se encontram os Schems de
estruturação dos tipos de dados) até a execução de uma classe stub compilada nas linguagens
preferidas, para serializar dados estruturados de uma máquina para outra.
Comentamos as principais caracteŕısticas que tornam o Protobuf ideal para sua função:
Schems que garantem integridade de dados, enumeração de campos que retira a necessidade
de verificação de versões, geração de classe stub com biblioteca própria garantindo seguranbça
e estabilidade, arquivo .proto que pode ser instanciado e garante uso de multiplas linguagens.
Observamos também que o desempenho de Protocol Buffers é melhor que seus concorrentes
XML e JSON (quando não se trata de JavScript e Browsers).
Demonstramos aqui um passo a passo de como instalar os arquivos do protobuf, como utilizar
a sintaxe no arquivo .proto e como copila-lo no terminal para gerar a instancia da classe stub
(aqui utilizando Python e CSharp). Com nosso exemplo de adressbook estruturamos nossos
dados em um arquivo .proto e fizemos 2 instanciações onde utilizamos 3 entradas diferentes de
dados e obtivemos os mesmos dados na sáıda, provando assim a execução, utilidade e veracidade
do Protobuf.
Referências
[Krebs, 2017] Krebs, B. (2017). Beating json performance with protobuf.
[Souza, 2018] Souza, E. F. (2018). Protobuf — uma alternativa ao json e xml.
10
	Introdução
	Definição
	Caracteristicas
	Vantagens para com outros Métodos/Formatos
	Desenvolvimento
	Instalação
	O arquivo .proto
	Compilação
	Escrevendo uma message
	Lendo uma message
	Conclusão
	Referências