Prost pour Rust : guide complet avec exemples

Qu'est-ce que Prost et pourquoi l'utiliser ?

Prost est une bibliothèque puissante et performante pour le langage de programmation Rust, conçue pour travailler avec Protocol Buffers (protobuf). Protocol Buffers est un mécanisme de sérialisation de données structurées développé par Google, plus compact et plus rapide que JSON ou XML.

Prost résolve plusieurs problèmes clés :

• Génération de code : Crée automatiquement des structures Rust à partir de fichiers .proto, évitant au développeur un travail fastidieux.
• Sérialisation et désérialisation : Convertit les données du format binaire protobuf en structures Rust et vice versa.
• Haute performance : Utilise la copie zéro (zero-copy) et une gestion efficace de la mémoire, ce qui en fait l'une des solutions les plus rapides pour protobuf en Rust.
• Sécurité : Entièrement écrit en Rust, garantissant la sécurité de la mémoire et des threads.

Cette bibliothèque est particulièrement utile dans les architectures microservices, les systèmes d'échange de données entre services, le stockage de configurations et tout scénario nécessitant une sérialisation efficace.

Installation

Prost s'installe via le gestionnaire de paquets Cargo. Pour commencer, ajoutez les dépendances suivantes à votre Cargo.toml :

[dependencies]
prost = "0.12"
prost-build = "0.12"
tonic = "0.11"  # optionnel, pour gRPC
bytes = "1.5"   # pour travailler avec les tampons

[build-dependencies]
prost-build = "0.12"

Vous aurez également besoin d'installer le compilateur protobuf (protoc). Sur Ubuntu/Debian :

sudo apt install protobuf-compiler

Sur macOS :

brew install protobuf

Sur Windows, téléchargez le binaire depuis le dépôt officiel protobuf et ajoutez-le au PATH.

Démarrage rapide

Créez un fichier person.proto :

syntax = "proto3";

message Person {
    string name = 1;
    int32 age = 2;
    repeated string phone_numbers = 3;
}

Créez un fichier build.rs à la racine du projet :

fn main() -> Result<(), Box<dyn std::error::Error>> {
    prost_build::compile_protos(&["src/person.proto"], &["src/"])?;
    Ok(())
}

Maintenant, dans main.rs :

use prost::Message;

// Le code généré sera dans le module person
pub mod person {
    include!(concat!(env!("OUT_DIR"), "/person.rs"));
}

fn main() {
    // Création d'un objet
    let person = person::Person {
        name: "Alexandre".to_string(),
        age: 30,
        phone_numbers: vec!["+33-6-12-34-56-78".to_string()],
    };

    // Sérialisation en octets
    let mut buf = Vec::new();
    person.encode(&mut buf).unwrap();
    println!("Sérialisé {} octets", buf.len());

    // Désérialisation
    let decoded = person::Person::decode(&buf[..]).unwrap();
    println!("Nom : {}, Âge : {}", decoded.name, decoded.age);
}

Méthodes et fonctions principales

1. Message::encode

Fonction : Sérialise un message au format binaire protobuf et l'écrit dans un tampon.

Paramètres :

• &self — référence au message
• buf: &mut impl BufMut — tampon d'écriture (généralement Vec<u8>)

Exemple :

let mut buf = Vec::new();
my_message.encode(&mut buf).unwrap();

2. Message::decode

Fonction : Désérialise des octets en une structure Rust.

Paramètres :

• buf: impl Buf — source d'octets (slice, Vec, Bytes)

Exemple :

let decoded = MyMessage::decode(&buf[..]).unwrap();

3. Message::encod