Protobuf — qu’est-ce que c’est, format de données binaire et principe de fonctionnement

Que sont les Protocol Buffers?

Protocol Buffers est un mécanisme de sérialisation de données structurées développé par Google, similaire à JSON et XML, mais avec une différence fondamentale : les données sont encodées au format binaire. Cela signifie qu’un message Protobuf ne peut pas être lu à l’œil nu, mais il occupe beaucoup moins d’espace et est traité plus rapidement que ses homologues textuels.

Protobuf a été créé en interne chez Google pour résoudre les problèmes de performance lors de l’échange de données entre services. En 2008, la technologie est devenue un projet open source avec la prise en charge de nombreux langages : C++, Java, Python, Go, JavaScript, Kotlin, Swift, Dart et autres. La version proto3, sortie en 2016, a simplifié la syntaxe et ajouté la prise en charge de davantage de langages.

La principale différence entre Protobuf et JSON est la nécessité de définir un schéma avant de commencer l’échange de données. Le fichier de schéma (.proto) décrit la structure du message : les champs, les types et les numéros uniques de champ. À partir de ce schéma, le compilateur protoc génère des classes dans le langage cible pour la sérialisation et la désérialisation.

Écosystème Protobuf

• gRPC — framework RPC haute performance qui utilise Protobuf par défaut
• protoc — compilateur de schémas .proto en code pour différents langages de programmation
• Google API — la plupart des API publiques de Google utilisent Protobuf
• Envoy Proxy — utilise Protobuf pour la configuration et l’échange de données

Architecture de Protobuf

L’architecture de Protobuf comprend trois composants clés : le langage de définition de schéma (.proto), le compilateur protoc et les bibliothèques d’exécution pour des langages spécifiques. Le développeur décrit la structure des données dans un fichier .proto, exécute la compilation et reçoit des classes prêtes à l’emploi pour travailler avec ces données.

Chaque champ dans un message Protobuf possède un numéro unique (field number) — ce n’est pas un numéro séquentiel, mais une balise utilisée dans le format binaire pour identifier le champ. Les numéros 1 à 15 sont encodés sur un octet, les numéros 16 à 2047 sur deux octets. Par conséquent, les champs importants avec une fréquence d’utilisation élevée doivent être numérotés de 1 à 15 pour optimiser la taille.

Types de données Protobuf

Protobuf prend en charge une large gamme de types : scalaires (int32, int64, float, double, bool, string, bytes), énumérations (enum), composites (message) et types spéciaux (oneof, map). Chaque type a une représentation binaire spécifique optimisée pour le cas d’utilisation correspondant.

Avantages du format binaire

Protobuf offre trois avantages clés par rapport aux formats textuels : la taille du message, la vitesse de sérialisation et le typage fort. Dans les systèmes à forte charge et les applications mobiles avec un trafic limité, ces avantages deviennent critiques.

La représentation binaire de Protobuf utilise un encodage de longueur variable (Varint) pour les nombres : les petits nombres occupent 1 octet, les grands jusqu’à 10 octets. Cela permet d’encoder efficacement les identifiants, les drapeaux et les compteurs qui occuperaient des dizaines d’octets sous forme de chaînes de texte en JSON ou XML. Par exemple, le nombre 150 dans Protobuf occupe 2 octets, dans JSON — 3 octets (sous forme de texte «150»), dans XML — 3 octets + balises.

Un avantage supplémentaire est la rétrocompatibilité. L’ajout d’un nouveau champ au schéma ne casse pas les anciens clients : ils ignorent simplement les champs inconnus. La suppression d’un champ nécessite simplement de réserver son numéro pour éviter les collisions futures.

Définition du schéma .proto

Le schéma .proto décrit la structure des données dans un langage spécial. Le fichier commence par la spécification de la syntaxe (proto3), du paquet et des dépendances d’importation. Chaque message est défini avec le mot-clé message avec des champs, où chaque champ a un type, un nom et un numéro unique.

Bonnes pratiques de schéma : numéros de champ de 1 à 15 pour les champs fréquemment utilisés, des noms significatifs, le regroupement des champs connexes dans un message séparé, l’utilisation de oneof pour les champs qui ne peuvent être qu’une de plusieurs options.

syntax = "proto3";

package mobileapp;

message User {
  string user_id = 1;
  string name = 2;
  string email = 3;
  int32 age = 4;
  UserRole role = 5;
  repeated string tags = 6;
  map<string, string> metadata = 7;
}

enum UserRole {
  USER_ROLE_UNSPECIFIED = 0;
  USER_ROLE_USER = 1;
  USER_ROLE_ADMIN = 2;
  USER_ROLE_MODERATOR = 3;
}

Messages imbriqués

Les messages peuvent être imbriqués : un champ profile de type Profile contiendra les données utilisateur en interne. La prise en charge de l’imbrication permet de décrire des structures hiérarchiques complexes sans dupliquer les définitions.

syntax = "proto3";

package mobileapp;

message Order {
  string order_id = 1;
  repeated OrderItem items = 2;
  double total_price = 3;
  PaymentInfo payment = 4;
}

message OrderItem {
  string product_id = 1;
  string title = 2;
  int32 quantity = 3;
  double price = 4;
}

message PaymentInfo {
  string method = 1;
  string transaction_id = 2;
  double amount = 3;
}

Génération de code à partir de .proto

Le compilateur protoc convertit les fichiers .proto en code source dans le langage cible. Pour Kotlin/Java, le paramètre --java_out est utilisé, pour Swift --swift_out (via le plugin Apple Swift Protobuf), pour Dart --dart_out. Les classes générées contiennent des méthodes builder pour construire des messages et des méthodes de sérialisation/désérialisation.

Sur Android, pour travailler avec Protobuf, on utilise le plugin com.google.protobuf version 0.9+ dans Gradle. Après avoir ajouté le plugin et spécifié les fichiers .proto, la compilation génère automatiquement des classes Kotlin prêtes à être utilisées dans l’application.

import com.google.protobuf.kotlin.toByteString
import com.example.mobileapp.UserOuterClass.User

fun createUser(): User {
    return User.newBuilder()
        .setUserId("usr_001")
        .setName("IT Sectr")
        .setEmail("team@itsectr.com")
        .setAge(5)
        .setRole(UserOuterClass.UserRole.USER_ROLE_ADMIN)
        .addTags("mobile")
        .addTags("backend")
        .build()
}

fun serializeAndDeserialize(user: User): User {
    // Sérialisation au format binaire
    val bytes = user.toByteArray()

    // Désérialisation du format binaire
    return User.parseFrom(bytes)
}

Exemples d’utilisation de Protobuf

Protobuf est particulièrement efficace dans l’architecture de microservices et les applications mobiles. Considérons un scénario typique : une application mobile reçoit une liste de produits du serveur via gRPC. Le message Protobuf contient les informations du produit, y compris l’identifiant, le nom, le prix et la catégorie. Le format binaire réduit la taille de la réponse de 5 à 8 fois par rapport à JSON.

Service gRPC en Kotlin

Exemple d’un service gRPC avec Protobuf côté serveur. Le service déclare la méthode RPC GetProducts, qui accepte une requête avec des paramètres de pagination et retourne une liste de produits. L’implémentation en Kotlin utilise des classes générées pour travailler avec les requêtes et les réponses.

import com.example.mobileapp.ProductServiceGrpcKt
import com.example.mobileapp.ProductOuterClass.Product
import com.example.mobileapp.ProductOuterClass.GetProductsRequest
import com.example.mobileapp.ProductOuterClass.GetProductsResponse

class ProductService : ProductServiceGrpcKt.ProductServiceCoroutineImplBase() {

    override suspend fun getProducts(
        request: GetProductsRequest
    ): GetProductsResponse {
        val products = fetchProductsFromDb(
            page = request.page,
            limit = request.limit
        )

        return GetProductsResponse.newBuilder()
            .addAllProducts(products)
            .setTotalCount(products.size)
            .build()
    }
}

Configuration de Protobuf dans un projet Android

La configuration de Protobuf dans un projet Android se fait via le plugin Gradle com.google.protobuf. Le plugin exécute automatiquement le compilateur protoc lors de la compilation et génère des classes Kotlin à partir des fichiers .proto. Pour fonctionner, vous devez ajouter le plugin au build.gradle au niveau du projet et l’appliquer dans le module d’application.

Après avoir configuré Gradle, les fichiers .proto sont placés dans le répertoire src/main/proto. Le compilateur protoc les traite à chaque compilation, générant des classes Kotlin qui peuvent être utilisées dans le code de l’application. Il est important de spécifier correctement les versions de protobuf et protoc pour éviter les conflits de dépendances avec d’autres bibliothèques du projet.

Pour les projets iOS, Protobuf est connecté via CocoaPods ou Swift Package Manager. Le plugin Swift Protobuf génère automatiquement des structures Swift conformes au protocole Codable. Dans les projets Dart pour Flutter, le paquet protobuf est utilisé et la compilation se fait via dart run protoc_plugin.