Das API-Gateway-Muster in Microservices verstehen: Eine einfache Anleitung

Der Übergang von einer einzelnen, monolithischen Anwendung zu einer Microservices-Architektur löst viele Probleme. Es ermöglicht Teams, unabhängig zu arbeiten, Dienste separat bereitzustellen und Teile des Systems nach Bedarf zu skalieren. Es bringt jedoch auch eine neue Herausforderung mit sich: Wie interagieren Kunden mit all diesen unabhängigen Diensten?

Wenn Sie zehn, fünfzig oder Hunderte winziger Microservices haben, sollte eine mobile App oder Webseite eine direkte Verbindung zu jedem einzelnen von ihnen herstellen?

Hier kommt das API-Gateway-Muster ins Spiel. In diesem Leitfaden erklären wir anhand einfacher Wörter und realer Analogien, was ein API-Gateway ist, warum Sie es benötigen und wie es Ihr Microservices-System vereinfacht.

Die Analogie zur realen Welt: Die Hotelrezeptionistin

Stellen Sie sich vor, Sie checken in ein großes Luxusresorthotel ein. Das Resort verfügt über viele verschiedene Abteilungen:

• Housekeeping (für saubere Bettwäsche)
• Zimmerservice (für Essen)
• Concierge (für die Buchung von Touren)
• Abrechnung (zum Bezahlen der Rechnung)

Wenn Sie ein sauberes Handtuch möchten, müssen Sie nicht durch das Resort laufen und versuchen, das Reinigungsgebäude zu finden. Wenn Sie zu Abend essen möchten, klopfen Sie nicht an die Küchentür. Stattdessen rufen Sie die Rezeptionistin an.

Die Rezeptionistin nimmt Ihr Anliegen entgegen, ermittelt, welche Abteilung es lösen kann, stellt den Kontakt zu Ihnen her oder kümmert sich für Sie darum.

In diesem Szenario:

• Sie sind der Kunde (mobile App oder Browser).
• Der Rezeptionist ist das API-Gateway.
• Die Abteilungen (Housekeeping, Zimmerservice, Abrechnung) sind die Microservices.

Das Problem: Direkte Client-zu-Service-Kommunikation

Bevor wir uns die Funktionsweise des Gateways ansehen, wollen wir sehen, was passiert, wenn wir kein verwenden.

Angenommen, Ihre E-Commerce-Anwendung verfügt über drei separate Microservices:

1. Benutzerdienst (verwaltet Profile)
2. Produktservice (verwaltet Katalog)
3. Bestellservice (verwaltet den Checkout)

Ohne API-Gateway muss die Client-App separate Anfragen direkt an die individuelle Adresse (IP oder URL) jedes Dienstes senden:

Dieser direkte Verbindungsansatz verursacht mehrere große Kopfschmerzen:

• Zu viele Endpunkte: Die Client-App muss sich drei separate URLs merken. Wenn Sie einen Dienst aufteilen oder seine Adresse ändern, müssen Sie die Clientanwendung aktualisieren.
• Sicherheits-Albtraum: Jeder Mikrodienst muss Authentifizierung (Überprüfung von Anmeldetokens), SSL-Zertifikate und Firewall-Regeln separat implementieren.
• Netzwerk-Overhead: Der Client muss möglicherweise drei separate Netzwerkanfragen über langsame Mobilfunknetze stellen, nur um eine einzelne Seite zu laden (z. B. Profil abrufen, Produktdetails abrufen und Bestellverlauf abrufen).
• Protokollunterschiede: Ihre Client-App bevorzugt möglicherweise die Verwendung von Standard-Webprotokollen wie HTTP/JSON, aber Ihre internen Dienste kommunizieren möglicherweise schneller über spezielle Protokolle wie gRPC oder AMQP.

Die Lösung: Das API-Gateway-Muster

Ein API-Gateway ist ein Hilfsserver, der zwischen den Clientanwendungen und den internen Mikrodiensten sitzt. Es fungiert als zentraler Einstiegspunkt für alle eingehenden Anfragen.

Anstatt drei verschiedene Dienste aufzurufen, ruft der Client nur einmal das API Gateway auf. Das Gateway leitet die Anfrage dann an den richtigen internen Dienst weiter, sammelt die Ergebnisse und sendet sie an den Client zurück.

Hauptaufgaben eines API-Gateways

Ein API-Gateway leistet viel mehr als nur die direkte Weiterleitung des Datenverkehrs. Es kümmert sich um „übergreifende Anliegen“ – Aufgaben, für die sonst jeder Microservice Code schreiben müsste:

1. Routing: Das Gateway nimmt eine eingehende URL (wie /api/v1/orders) und ordnet sie der richtigen internen Dienstadresse zu.
2. Authentifizierung und Autorisierung: Das Gateway validiert Sicherheitstoken (wie JWTs) an der Eingangstür. Wenn die Anfrage ungültig ist, wird sie sofort abgelehnt, sodass Ihre Microservices keine CPU-Zyklen für nicht authentifizierte Anfragen verschwenden.
3. Ratenbegrenzung: Es verhindert, dass bösartige Bots oder fehlerhafte Clients Ihr System spammen, indem es begrenzt, wie viele Anfragen ein Benutzer pro Minute stellen kann.
4. Lastausgleich: Das Gateway kann eingehenden Datenverkehr gleichmäßig auf mehrere Instanzen eines Mikrodienstes verteilen, um zu verhindern, dass ein einzelner Server überlastet wird.
5. Protokollübersetzung: Es kann benutzerseitige JSON-Anfragen in leistungsstarke interne gRPC-Nachrichten übersetzen, sodass Dienste in ihren bevorzugten Sprachen miteinander kommunizieren können.

Eine einfache Implementierung: Codebeispiel

Um zu sehen, wie einfach das Routing wird, schauen wir uns zwei gängige Methoden zum Einrichten eines API-Gateways an.

1. Deklaratives Routing (Spring Cloud Gateway YAML)

In Java-Unternehmenssystemen konfigurieren Sie das Routing häufig mithilfe einer einfachen Konfigurationsdatei. Das Gateway leitet Anfragen automatisch auf Grundlage dieser Regeln weiter:

spring:
  cloud:
    gateway:
      routes:
        - id: user_service_route
          uri: http://internal-user-service:8081
          predicates:
            - Path=/api/users/**
        - id: product_service_route
          uri: http://internal-product-service:8082
          predicates:
            - Path=/api/products/**

2. Programmatisches Routing (Node.js Gateway Mockup)

Wenn Sie mit Express ein leichtes API-Gateway in Javascript erstellen möchten, sieht es so aus:

const express = require('express');
const { createProxyMiddleware } = require('http-proxy-middleware');
const app = express();
const PORT = 3000;

// 1. Simple Security/Authentication Check at the door
const authenticate = (req, res, next) => {
    const token = req.headers['authorization'];
    if (token === 'secret-handshake-token') {
        next(); // Token is valid, proceed
    } else {
        res.status(401).json({ error: 'Unauthorized Access!' });
    }
};

// Apply auth check to all incoming gateway requests
app.use(authenticate);

// 2. Route requests to correct internal microservices
app.use('/api/users', createProxyMiddleware({ target: 'http://localhost:8081', changeOrigin: true }));
app.use('/api/products', createProxyMiddleware({ target: 'http://localhost:8082', changeOrigin: true }));
app.use('/api/orders', createProxyMiddleware({ target: 'http://localhost:8083', changeOrigin: true }));

app.listen(PORT, () => {
    console.log(`API Gateway running smoothly on port ${PORT}`);
});

Vor- und Nachteile des API-Gateway-Musters

Wie bei jeder Architekturentscheidung gibt es bei der Verwendung eines API-Gateways Kompromisse:

Abschluss

Das API Gateway Pattern ist ein Eckpfeiler der modernen Microservices-Architektur. Indem es als einzelner, intelligenter Einstiegspunkt fungiert, schützt es Clientanwendungen vor der Komplexität interner Service-Setups. Es vereinfacht den clientseitigen Code, zentralisiert die Sicherheit und verwaltet das Verkehrsmanagement effizient.

Obwohl es einen kleinen Netzwerk-Hop mit sich bringt und in der Produktion mit hoher Verfügbarkeit eingerichtet werden muss, ist es aufgrund der Vorteile saubererer, sichererer und verwaltbarer Codebasen ein sehr empfehlenswertes Muster für jedes wachsende verteilte System.

Weitere Einblicke in Softwareentwicklung und Backend-Engineering finden Sie im Ghaznix-Blog →