Microservices en C++ : architecture, pratique et exemples de code

Introduction aux microservices en C++

L'architecture microservices (MSA) est l'une des approches dominantes pour la construction de systèmes distribués modernes. Bien que le C++ soit moins souvent associé aux microservices que Go, Java ou Python, il reste indispensable pour les scénarios où les performances, la faible latence et l'utilisation efficace de la mémoire sont critiques. Dans cet article, nous verrons comment construire des microservices en C++, quels frameworks et bibliothèques utiliser, et nous examinerons des exemples pratiques de code.

Pourquoi le C++ pour les microservices ?

Les principaux avantages du C++ dans le développement de microservices :

• Performances maximales — le C++ permet d'atteindre un temps de réponse (latence) minimal et un débit (throughput) élevé.
• Contrôle des ressources — gestion manuelle de la mémoire et optimisation au niveau matériel.
• Bibliothèques matures — Boost, Poco, cpp-httplib, gRPC, Crow.
• Intégration avec les systèmes legacy — le C++ est souvent utilisé dans les cœurs des systèmes à forte charge (finance, télécom, jeux).

Architecture d'un microservice en C++

Composants principaux

Un microservice typique en C++ comprend :

• Serveur HTTP/REST — pour recevoir les requêtes (par exemple, en utilisant cpp-httplib ou Crow).
• Logique métier — modules de traitement des données.
• Client pour la communication inter-services — gRPC ou client HTTP.
• Gestion du stockage — connexion à PostgreSQL, Redis ou Kafka via des bibliothèques (libpqxx, redis-plus-plus, librdkafka).

Communication entre services

Deux protocoles principaux :

• gRPC — protocole binaire basé sur Protobuf, offrant un typage strict et une vitesse élevée.
• REST (JSON) — pratique pour les API externes, mais plus lent en raison de la sérialisation.

Pratique : création d'un microservice en C++

1. API REST simple avec cpp-httplib

Considérons un service minimal qui reçoit une requête GET et renvoie du JSON. La bibliothèque cpp-httplib est header-only, facile à intégrer.

// main.cpp#include <httplib.h>#include <nlohmann/json.hpp>

using json = nlohmann::json;

int main() {    httplib::Server svr;

    // GET /hello — renvoie du JSON    svr.Get("/hello", [](const httplib::Request& req, httplib::Response& res) {        json response;        response["message"] = "Hello from C++ microservice!";        response["status"] = "ok";        res.set_content(response.dump(), "application/json");    });

    // POST /data — reçoit du JSON et le traite    svr.Post("/data", [](const httplib::Request& req, httplib::Response& res) {        try {            auto input = json::parse(req.body);            int value = input["value"];            json result;            result["squared"] = value * value;            res.set_content(result.dump(), "application/json");        } catch (const std::exception& e) {            res.status = 400;            res.set_content("{\\"error\\":\\"Invalid JSON\\"}", "application/json");        }    });

    std::cout << "Server started on port 8080";    svr.listen("0.0.0.0", 8080);    return 0;}

Compilation (nécessite nlohmann/json installé) :

g++ -std=c++17 main.cpp -o microservice -lpthread./microservice

2. Microservice avec gRPC

gRPC nécessite la définition du service dans un fichier .proto. Exemple :

// calculator.protosyntax = "proto3";

service Calculator {    rpc Add (AddRequest) returns (AddResponse);}

message AddRequest {    int32 a = 1;    int32 b = 2;}