Mikroservices in C++: Architektur und Praxis von A bis Z

Mikroservices in C++: Architektur und Praxis von A bis Z

Die Mikroservice-Architektur ist längst zum Standard für den Aufbau skalierbarer und ausfallsicherer Systeme geworden. Die meisten Beispiele im Internet sind jedoch in Java, Go oder Python geschrieben. Was aber, wenn Sie maximale Leistung und Kontrolle über Ressourcen benötigen? Die Antwort — Mikroservices in C++. In diesem Artikel analysieren wir die Architektur, Schlüsseltechnologien und schreiben ein reales Beispiel eines Mikroservices in C++.

Warum C++ für Mikroservices?

C++ wird traditionell mit Systemprogrammierung, Spielen und Embedded-Entwicklung assoziiert. Seine Vorteile für Mikroservices sind jedoch offensichtlich:

• Maximale Leistung — minimaler Overhead bei Speicher und Prozessor.
• Feine Ressourcenkontrolle — manuelle Speicherverwaltung (oder moderne Smart Pointer).
• Niedrige Latenz — ideal für High-Frequency Trading, Game-Server und IoT.
• Reiche Auswahl an Bibliotheken — von Boost bis gRPC und Poco.

Nachteile gibt es auch: Entwicklungskomplexität, langsame Kompilierung und fehlende "schnelle" Prototypen. Aber mit einem durchdachten Ansatz wird C++ zu einem leistungsstarken Werkzeug für Mikroservices.

Architektur eines Mikroservices in C++

Ein typischer Mikroservice in C++ besteht aus folgenden Schichten:

• Transport layer — HTTP/REST (cpprestsdk), gRPC, WebSocket oder TCP/UDP.
• Business logic — reines C++17/20, Datenverarbeitung, Algorithmen.
• Data layer — Datenbankanbindung (PostgreSQL via libpqxx, Redis via hiredis).
• Communication — serviceübergreifende Kommunikation (gRPC, RabbitMQ, Kafka).

Es ist wichtig, diese Schichten zu trennen, damit jeder Mikroservice unabhängig und leicht testbar ist.

Praktisches Beispiel: REST API Mikroservice in C++

Wir schreiben einen einfachen Mikroservice zur Aufgabenverwaltung (Task Manager) unter Verwendung der Bibliothek cpprestsdk (Casablanca).

1. Abhängigkeiten installieren

Für Ubuntu/Debian:

sudo apt-get install libcpprest-dev libboost-all-dev libssl-dev

2. Code des Mikroservices

Erstellen wir die Datei task_service.cpp:

#include <cpprest/http_listener.h>#include <cpprest/json.h>#include <iostream>#include <map>#include <mutex>

using namespace web;using namespace web::http;using namespace web::http::experimental::listener;

class TaskService {private:    std::map<int, std::string> tasks;    std::mutex mtx;    int next_id = 1;

    void handle_get(http_request request) {        json::value response;        std::lock_guard<std::mutex> lock(mtx);        for (const auto& [id, desc] : tasks) {            response[std::to_string(id)] = json::value::string(desc);        }        request.reply(status_codes::OK, response);    }

    void handle_post(http_request request) {        request.extract_json().then([this, &request](json::value body) {            std::lock_guard<std::mutex> lock(mtx);            int id = next_id++;            tasks[id] = body.at("description").as_string();            json::value response;            response["id"] = id;            request.reply(status_codes::Created, response);        }).wait();    }

public:    TaskService() {        uri_builder uri("http://localhost:8080");        auto addr = uri.to_uri().to_string();        http_listener listener(addr);

        listener.support(methods::GET,             std::bind(&TaskService::handle_get, this, std::placeholders::_1));        listener.support(methods::POST,             std::bind(&TaskService::handle_post, this, std::placeholders::_1));

        listener.open().then([&addr]() {            std::c