Welche Arten von Diensten gibt es und wie funktionieren sie auf niedriger Ebene?

Es gibt mehrere Haupttypen von Diensten im Kontext der Microservice-Architektur und verteilten Systeme:

• Monolithische Anwendungen: Eine einzige, unteilbare Codebasis, die die gesamte Funktionalität der Anwendung enthält.
• Microservices: Eine Reihe von kleinen, unabhängigen Diensten, von denen jeder eine bestimmte Geschäftslogik implementiert. Sie interagieren über APIs.
• Serverless (ohne Server): Ein Berechnungsmodell, bei dem der Cloud-Anbieter die Zuweisung und Skalierung von Ressourcen dynamisch verwaltet. Der Entwickler konzentriert sich nur auf den Funktionscode.

Auf niedriger Ebene funktioniert es wie folgt:

Monolithisch:

Wird als einzelner Prozess ausgeführt. Alle Komponenten werden gleichzeitig in den Speicher geladen. Die Interaktion zwischen Komponenten erfolgt durch Funktions- oder Methodenaurufe innerhalb eines gemeinsamen Adressraums. Fehlertoleranz wird durch Reservierung des gesamten Monolithen erreicht. Skalierung ist schwierig, es muss die gesamte Anwendungskopie skaliert werden. Ressourcen werden oft redundant genutzt.

Microservices:

Jeder Microservice ist ein separater Prozess oder eine Gruppe von Prozessen. Läuft in einer isolierten Umgebung (Container, virtuelle Maschine). Die Interaktion erfolgt über das Netzwerk, meist über HTTP/gRPC auf Basis synchroner oder asynchroner Protokolle (z.B. RabbitMQ, Kafka für Asynchronität). Jeder Dienst kann seinen eigenen Technologie-Stack und seine eigene Datenbank haben. Die Skalierung erfolgt unabhängig für jeden Dienst. Es wird hohe Fehlertoleranz gewährleistet (Ausfall eines Dienstes beeinflusst andere nicht) und eine bessere Ressourcennutzung. Das Management wird komplexer (erfordert Service Discovery, API Gateway, verteiltes Logging und Monitoring).

Beispiel für die Netzwerkinteraktion zwischen Microservices:

// Anfrage an Service A
GET /users/123 HTTP/1.1
Host: service-a.example.com

// Antwort von Service A
HTTP/1.1 200 OK
Content-Type: application/json

{
  "id": 123,
  "username": "testuser"
}

Serverless:

Der Funktionscode wird in einer Cloud-Umgebung bereitgestellt. Der Cloud-Anbieter führt den Code als Reaktion auf bestimmte Ereignisse aus (HTTP-Anfragen, Nachrichten in Warteschlangen, Änderungen in der Datenbank). Die Infrastruktur (Server, Betriebssystem) wird vom Anbieter verwaltet. Funktionen sind in der Regel kurzlebig und zustandslos (ohne Speicherung des Zustands zwischen Aufrufen). Das Skalieren erfolgt automatisch, basierend auf der Anzahl der Ereignisse. Die Abrechnung erfolgt nach Ressourcenverbrauch (Anzahl der Ausführungen, Laufzeit). Auf niedriger Ebene verwendet der Anbieter Container oder virtuelle Maschinen, um Funktionen zu isolieren und auszuführen, aber diese Ebene ist für den Nutzer abstrahiert.

Beispiel für eine Serverless-Funktion (AWS Lambda):

# Einfache Lambda-Funktion
import json

def lambda_handler(event, context):
    # Verarbeitung des eingehenden Ereignisses
    # Ausführung der Logik
    response_body = {
        "message": "Hallo von Lambda!",
        "input": event
    }

    return {
        "statusCode": 200,
        "body": json.dumps(response_body)
    }

Vergleichstabelle:

Merkmal	Monolithisch	Microservices	Serverless
Architektur	Einfache Codebasis	Unabhängige Dienste	Funktionen, die durch Ereignisse verwaltet werden
Bereitstellung	Einzelner Prozess	Unabhängig für jeden Dienst	Wird vom Anbieter verwaltet
Skalierung	Horizontal (Kopieren)	Unabhängig für jeden Dienst	Automatisch, durch Ereignisse
Fehlertoleranz	Niedrig	Hoch (isoliert)	Hoch (integriert)
Ressourcennutzung	Teilweise redundant	Effizienter	Bezahlung nach Nutzung
Management-Komplexität	Niedrig	Hoch	Niedrig (für Infrastruktur)
Kommunikation	Innerhalb des Prozesses	Über Netzwerk (API, Nachrichten)	Über Ereignisse des Anbieters