Buffers de protocolo

Protocol Buffers ( Protobuf ) es un formato de datos multiplataforma, gratuito y de código abierto, utilizado para serializar datos estructurados. Resulta útil para desarrollar programas que se comunican entre sí a través de una red o para almacenar datos. El método consiste en un lenguaje de descripción de interfaz que describe la estructura de los datos y un programa que genera código fuente a partir de dicha descripción para generar o analizar una secuencia de bytes que representa los datos estructurados.

Google desarrolló Protocol Buffers para uso interno y proporcionó un generador de código para varios lenguajes bajo una licencia de código abierto .

Los objetivos de diseño de Protocol Buffers enfatizaron la simplicidad y el rendimiento. En particular, se diseñó para ser más pequeño y rápido que XML . ^{[ 3 ]}

Protocol Buffers se utiliza ampliamente en Google para almacenar e intercambiar todo tipo de información estructurada. Este método sirve de base para un sistema personalizado de llamadas a procedimientos remotos (RPC) que se utiliza para casi toda la comunicación entre máquinas en Google. ^{[ 4 ]}

Protocol Buffers es similar a los protocolos Apache Thrift , Amazon Ion y Microsoft Bond, y ofrece una pila de protocolos RPC concreta para usar con servicios definidos llamada gRPC . ^{[ 5 ]}

Los esquemas de estructuras de datos (llamados mensajes ) y los servicios se describen en un archivo de definición proto ( .proto) y se compilan con protoc. Esta compilación genera código que puede ser invocado por un remitente o receptor de estas estructuras de datos. Por ejemplo, example.pb.ccy example.pb.hse generan a partir de example.proto. Definen clases C++ para cada mensaje y servicio en example.proto.

Canónicamente, los mensajes se serializan en un formato binario compacto, compatible hacia adelante y hacia atrás , pero no autodescriptivo (es decir, no hay forma de conocer los nombres, el significado o los tipos de datos completos de los campos sin una especificación externa). No existe una forma definida de incluir o hacer referencia a dicha especificación externa ( esquema ) dentro de un archivo de Protocol Buffers. La implementación oficialmente compatible incluye un formato de serialización ASCII , ^{[ 6 ]} pero este formato, aunque autodescriptivo, pierde la compatibilidad hacia adelante y hacia atrás, por lo que no es una buena opción para aplicaciones distintas a la edición y depuración manual. ^{[ 7 ]}

Si bien el objetivo principal de Protocol Buffers es facilitar la comunicación en red, su simplicidad y velocidad lo convierten en una alternativa a las clases y estructuras de C++ centradas en datos, especialmente cuando se requiere interoperabilidad con otros lenguajes o sistemas en el futuro.

Los protobufs no tienen una especificación única. ^{[ 8 ]} El formato es más adecuado para pequeños fragmentos de datos que no superan unos pocos megabytes y que se pueden cargar/enviar a la memoria de inmediato y, por lo tanto, no es un formato de transmisión continua. ^{[ 9 ]} La biblioteca no proporciona compresión de forma predeterminada. El formato tampoco es compatible con lenguajes no orientados a objetos (por ejemplo, Fortran ). ^{[ 10 ]}

Un esquema para un uso específico de los búferes de protocolo asocia los tipos de datos con los nombres de los campos, utilizando números enteros para identificar cada campo. (Los datos del búfer de protocolo contienen solo los números, no los nombres de los campos, lo que proporciona cierto ahorro de ancho de banda y almacenamiento en comparación con los sistemas que incluyen los nombres de los campos en los datos).

// polyline.proto syntax = "proto2" ;Mensaje Punto { requerido int32 x = 1 ; requerido int32 y = 2 ; opcional cadena etiqueta = 3 ; }Mensaje Línea { Punto requerido inicio = 1 ; Punto requerido fin = 2 ; Etiqueta de cadena opcional = 3 ; }mensaje Polilínea { repetido Punto punto = 1 ; opcional cadena etiqueta = 2 ; }

El Pointmensaje define dos elementos de datos obligatorios, xy y. El elemento de datos labeles opcional. Cada elemento de datos tiene una etiqueta. La etiqueta se define después del signo igual. Por ejemplo, xtiene la etiqueta 1.

Los mensajes y , que ambos utilizan Line, demuestran cómo funciona la composición en Protocol Buffers. tiene un campo y, por lo tanto, se comporta como un conjunto de puntos (de número no especificado).PolylinePointPolylinerepeatedPolyline

Este esquema puede compilarse posteriormente para su uso con uno o más lenguajes de programación. Google proporciona un compilador protocque puede generar código para C++, Java o Python. Existen otros compiladores de esquemas disponibles en otras fuentes para generar código dependiente del lenguaje para más de 20 lenguajes adicionales. ^{[ 11 ]}

Por ejemplo, después de generar una versión en C++ del esquema de búfer de protocolo anterior, un archivo de código fuente en C++, polyline.cpp , puede utilizar los objetos de mensaje de la siguiente manera:

// polyline.cpp #include "polyline.pb.h" // generado al llamar a "protoc polyline.proto"importar std ;usando std :: string ; usando std :: shared_ptrshared_ptr < Line > createNewLine ( const string & name ) { // crea una línea desde (10, 20) hasta (30, 40) shared_ptr < Line > line = std :: make_shared < Line > (); line -> mutable_start () -> set_x ( 10 ); line -> mutable_start () -> set_y ( 20 ); line -> mutable_end () -> set_x ( 30 ); line -> mutable_end () -> set_y ( 40 ); line -> set_label ( name ); return line ; }shared_ptr < Polyline > createNewPolyline () { // crea una polilínea con puntos en (10,10) y (20,20) shared_ptr < Polyline > polyline = std :: make_shared < Polyline > (); shared_ptr < Point > point1 = std :: make_shared < Point > ( polyline -> add_point ()); point1 -> set_x ( 10 ); point1 -> set_y ( 10 ); shared_ptr < Point > point2 = std :: make_shared < Point > ( polyline -> add_point ()); point2 -> set_x ( 20 ); point2 -> set_y ( 20 ); return polyline ; }

Protobuf 2.0 proporciona un generador de código para C++ , Java , C# , ^{[ 12 ]} y Python . ^{[ 13 ]}

Protobuf 3.0 proporciona un generador de código para C++ , Java (incluido JavaNano, un dialecto destinado a entornos con pocos recursos ), Kotlin , Python , Go , Ruby , Objective-C , C# , PHP y Dart . ^{[ 14 ]} También admite JavaScript desde la versión 3.0.0-beta-2. ^{[ 15 ]}

También hay implementaciones de terceros disponibles para Ada , ^{[ 16 ]} Ballerina , ^{[ 17 ]} C , ^{[ 18 ] [ 19 ]} C++ , ^{[ 20 ]} Dart , Elixir , ^{[ 21 ] [ 22 ]} Erlang , ^{[ 23 ]} Haskell , ^{[ 24 ]} JavaScript , ^{[ 25 ]} Julia , ^{[ 26 ]} Nim , ^{[ 27 ]} Perl , PHP , Prolog , ^{[ 28 ] [ 29 ]} R , ^{[ 30 ]} Rust , ^{[ 31 ] [ 32 ] [ 33 ]} Scala , ^{[ 34 ]} y Swift . ^{[ 35 ]}

• gRPC
• Comparación de formatos de serialización de datos binarios
• Búferes planos
• ASN.1

• Documentación oficial en developers.google.com
• protobuf en GitHub