Envoy und Kong: Ihr API-Gateway auf das nächste Level bringen Envoy und Kong: Ihr API-Gateway auf das nächste Level bringen

Die Welt von Envoy und Kong: Erkundung fortgeschrittener Muster für Verkehrsmanagement, Sicherheit und Leistungsoptimierung. Erfahren Sie mehr über Multi-Tenant-Routing, benutzerdefinierte Plugins und wie Sie eine Zero-Trust-Architektur implementieren, die selbst den paranoidesten Sicherheitsexperten zufriedenstellt.

Verkehrsmanagement: Den wilden Westen der Anfragen zähmen

Beginnen wir mit dem Verkehrsmanagement. In der Welt der Microservices ist das Management von Verkehr wie das Hüten von Katzen – chaotisch, unvorhersehbar und gelegentlich urkomisch.

Lastverteilung: Nicht nur für Fitnessbegeisterte

Envoy und Kong bieten ausgeklügelte Lastverteilungsfunktionen, die über einfache Round-Robin-Strategien hinausgehen. Schauen wir uns einige fortgeschrittene Techniken an:

Wenigste Anfragen: Leitet Anfragen an die Instanz mit den wenigsten aktiven Anfragen weiter. Perfekt, wenn Sie Dienste haben, die so launisch sind wie ein Teenager.
Gewichtetes Round Robin: Ermöglicht es Ihnen, verschiedenen Instanzen unterschiedliche Gewichte zuzuweisen. Nützlich, wenn Sie einen leistungsstarken Server haben, der mehr Last bewältigen kann als seine schwächeren Geschwister.
Ring-Hash: Ordnet Anfragen konsistent derselben Instanz basierend auf einem Schlüssel zu. Ideal für Caching und wenn Sie möchten, dass Anfragen desselben Benutzers immer denselben Server erreichen.

Hier ist ein kurzes Beispiel, wie Sie gewichtete Lastverteilung in Envoy konfigurieren könnten:


clusters:
  - name: my_backend_service
    type: STRICT_DNS
    lb_policy: WEIGHTED_ROUND_ROBIN
    load_assignment:
      cluster_name: my_backend_service
      endpoints:
        - lb_endpoints:
          - endpoint:
              address:
                socket_address:
                  address: backend1.example.com
                  port_value: 8080
            load_balancing_weight: 75
          - endpoint:
              address:
                socket_address:
                  address: backend2.example.com
                  port_value: 8080
            load_balancing_weight: 25

Circuit Breaking: Manchmal muss man wissen, wann man aufhören sollte

Circuit Breaking ist wie ein Türsteher für Ihre Dienste. Es verhindert, dass ein fehlerhafter Dienst das gesamte System lahmlegt. Sowohl Envoy als auch Kong unterstützen Circuit Breaking, aber schauen wir uns die Implementierung von Envoy an:


clusters:
  - name: my_backend_service
    type: STRICT_DNS
    circuit_breakers:
      thresholds:
        - priority: DEFAULT
          max_connections: 1000
          max_pending_requests: 1000
          max_requests: 1000
          max_retries: 3

Diese Konfiguration legt Schwellenwerte für Circuit Breaking für Verbindungen, ausstehende Anfragen, aktive Anfragen und Wiederholungen fest. Wenn diese Schwellenwerte überschritten werden, beginnt Envoy, Anfragen abzulehnen, um das System zu schützen.

Multi-Tenant-Routing: Gut mit anderen auskommen

In einer Multi-Tenant-Umgebung müssen Sie sicherstellen, dass der Verkehr verschiedener Mandanten isoliert und korrekt weitergeleitet wird. Kong glänzt in diesem Bereich mit seinen leistungsstarken Routing-Funktionen.

Der Weg zum Glück

Hier ist ein Beispiel, wie Sie Multi-Tenant-Routing in Kong einrichten könnten:


# Erstellen Sie einen Dienst
curl -i -X POST http://localhost:8001/services \
  --data name=myservice \
  --data url='http://myservice.com'

# Erstellen Sie eine Route für Mandant A
curl -i -X POST http://localhost:8001/services/myservice/routes \
  --data 'hosts[]=tenanta.myapi.com' \
  --data 'paths[]=/v1/tenanta'

# Erstellen Sie eine Route für Mandant B
curl -i -X POST http://localhost:8001/services/myservice/routes \
  --data 'hosts[]=tenantb.myapi.com' \
  --data 'paths[]=/v1/tenantb'

Diese Einrichtung stellt sicher, dass Anfragen für Mandant A und Mandant B korrekt an ihre jeweiligen Endpunkte weitergeleitet werden, selbst wenn sie denselben zugrunde liegenden Dienst ansprechen.

Anfrage-Transformation: Ihre APIs umformen

Manchmal sprechen Ihre Backend-Dienste einen anderen Dialekt als Ihre Clients. Hier kommt die Anfrage-Transformation ins Spiel. Kongs request-transformer-Plugin ist wie ein Universalübersetzer für Ihre APIs.

Verloren in der Übersetzung? Nicht mehr!

So könnten Sie das request-transformer-Plugin verwenden, um Header und Abfrageparameter zu ändern:


curl -X POST http://localhost:8001/routes/{route_id}/plugins \
    --data "name=request-transformer" \
    --data "config.add.headers=x-tenant-id:$(tenant_id)" \
    --data "config.add.querystring=version:v2" \
    --data "config.rename.headers=x-old-header:x-new-header"

Diese Konfiguration fügt einen Mandanten-ID-Header hinzu, hängt einen Versionsabfrageparameter an und benennt einen vorhandenen Header um. Es ist, als würden Sie Ihren Anfragen ein Makeover geben, bevor sie Ihre Backend-Dienste erreichen.

Erweiterte Ratenbegrenzung: Die Party unter Kontrolle halten

Ratenbegrenzung ist entscheidend, um Ihre APIs vor Missbrauch zu schützen und eine faire Nutzung sicherzustellen. Aber grundlegende Ratenbegrenzung ist so was von gestern. Schauen wir uns einige fortgeschrittene Techniken zur Ratenbegrenzung mit Kong an.

Ratenbegrenzung auf Steroiden

Kongs Ratenbegrenzungs-Plugin bietet erweiterte Funktionen wie die Begrenzung nach Header-Wert oder Verbrauchergruppen. Hier ist eine Beispielkonfiguration:


curl -X POST http://localhost:8001/plugins \
    --data "name=rate-limiting" \
    --data "config.limit=5" \
    --data "config.window_size=30" \
    --data "config.limit_by=header" \
    --data "config.header_name=x-consumer-group"

Diese Einrichtung begrenzt Anfragen basierend auf einem Verbrauchergruppen-Header, sodass Sie eine gestufte Ratenbegrenzung für verschiedene Benutzertypen oder Mandanten implementieren können.

Entwicklung benutzerdefinierter Plugins: Manchmal muss man es selbst machen

Fertige Plugins sind großartig, aber manchmal brauchen Sie etwas Maßgeschneidertes. Sowohl Envoy als auch Kong ermöglichen es Ihnen, benutzerdefinierte Plugins zu entwickeln, um ihre Funktionalität zu erweitern.

Ihr eigenes Kong-Plugin entwickeln

Hier ist ein Vorgeschmack darauf, wie ein benutzerdefiniertes Kong-Plugin aussehen könnte:


local CustomPlugin = {
  PRIORITY = 1000,
  VERSION = "1.0.0",
}

function CustomPlugin:access(conf)
  -- Ihre benutzerdefinierte Logik hier
  kong.log.debug("Hallo vom CustomPlugin!")
  
  local headers = kong.request.get_headers()
  if not headers["x-api-key"] then
    return kong.response.exit(401, { message = "Fehlender API-Schlüssel" })
  end
end

return CustomPlugin

Dieses einfache Plugin überprüft das Vorhandensein eines API-Schlüssels und gibt eine 401 zurück, wenn er fehlt. Die Möglichkeiten sind endlos – Sie könnten benutzerdefinierte Authentifizierung, komplexe Transformationen oder sogar die Integration mit externen Diensten implementieren.

Sicherheits-Best-Practices: Paranoia als Dienstleistung

In der Welt der APIs ist Sicherheit nicht nur wichtig – sie ist entscheidend. Lassen Sie uns einige fortgeschrittene Sicherheitsmuster erkunden, die Sie mit Envoy und Kong implementieren können.

mTLS: Weil Vertrauensprobleme in der Technik gesund sind

Mutual TLS (mTLS) stellt sicher, dass sowohl der Client als auch der Server die Zertifikate des jeweils anderen überprüfen. So könnten Sie mTLS in Envoy konfigurieren:


listeners:
  - address:
      socket_address:
        address: 0.0.0.0
        port_value: 8443
    filter_chains:
    - filters:
      - name: envoy.filters.network.http_connection_manager
        typed_config:
          "@type": type.googleapis.com/envoy.extensions.filters.network.http_connection_manager.v3.HttpConnectionManager
          stat_prefix: ingress_http
          route_config:
            name: local_route
            virtual_hosts:
            - name: backend
              domains:
              - "*"
              routes:
              - match:
                  prefix: "/"
                route:
                  cluster: service_backend
      transport_socket:
        name: envoy.transport_sockets.tls
        typed_config:
          "@type": type.googleapis.com/envoy.extensions.transport_sockets.tls.v3.DownstreamTlsContext
          require_client_certificate: true
          common_tls_context:
            tls_certificates:
            - certificate_chain:
                filename: "/etc/envoy/certs/server.crt"
              private_key:
                filename: "/etc/envoy/certs/server.key"
            validation_context:
              trusted_ca:
                filename: "/etc/envoy/certs/ca.crt"

JWT-Verifizierung: Wer geht da?

JSON Web Tokens (JWTs) sind eine beliebte Methode für Authentifizierung und Autorisierung. Kongs jwt-Plugin macht es einfach, JWTs zu überprüfen:


curl -X POST http://localhost:8001/routes/{route_id}/plugins \
    --data "name=jwt" \
    --data "config.secret_is_base64=false" \
    --data "config.claims_to_verify=exp"

Diese Konfiguration aktiviert die JWT-Verifizierung auf einer bestimmten Route und überprüft den Ablaufanspruch des Tokens.

Zero-Trust-Architektur: Vertraue niemandem, nicht einmal dir selbst

Die Implementierung einer Zero-Trust-Architektur mit API-Gateways umfasst mehrere Komponenten:

Identitätsbasierter Zugriff: Verwenden Sie eine starke Authentifizierung für jede Anfrage.
Mikrosegmentierung: Implementieren Sie feingranulare Zugriffskontrollen auf Dienstebene.
Kontinuierliche Überwachung: Nutzen Sie die Protokollierungs- und Überwachungsfunktionen von Envoy und Kong, um Anomalien zu erkennen.

Hier ist ein Beispiel, wie Sie identitätsbasierten Zugriff mit Kongs key-auth-Plugin in Kombination mit ACL implementieren könnten:


# Schlüssel-Authentifizierung aktivieren
curl -X POST http://localhost:8001/routes/{route_id}/plugins \
    --data "name=key-auth"

# Einen Verbraucher erstellen
curl -X POST http://localhost:8001/consumers \
    --data "username=alice"

# Einen Schlüssel für den Verbraucher erstellen
curl -X POST http://localhost:8001/consumers/alice/key-auth \
    --data "key=secret_key_123"

# ACL-Plugin aktivieren
curl -X POST http://localhost:8001/routes/{route_id}/plugins \
    --data "name=acl" \
    --data "config.whitelist=group_a"

# Den Verbraucher einer Gruppe zuweisen
curl -X POST http://localhost:8001/consumers/alice/acls \
    --data "group=group_a"

Diese Einrichtung stellt sicher, dass nur authentifizierte Benutzer mit der richtigen Gruppenmitgliedschaft auf die geschützte Route zugreifen können.

Debugging und Leistungsoptimierung: Wenn die Dinge schiefgehen

Selbst mit den besten Plänen können Dinge schiefgehen. Lassen Sie uns einige Strategien zum Debuggen und Optimieren Ihrer API-Gateway-Einrichtung betrachten.

Protokollierung wie ein Profi

Sowohl Envoy als auch Kong bieten umfangreiche Protokollierungsfunktionen. So könnten Sie detaillierte Zugriffsprotokolle in Envoy konfigurieren:


static_resources:
  listeners:
  - address:
      socket_address:
        address: 0.0.0.0
        port_value: 8080
    filter_chains:
    - filters:
      - name: envoy.filters.network.http_connection_manager
        typed_config:
          "@type": type.googleapis.com/envoy.extensions.filters.network.http_connection_manager.v3.HttpConnectionManager
          stat_prefix: ingress_http
          access_log:
          - name: envoy.access_loggers.file
            typed_config:
              "@type": type.googleapis.com/envoy.extensions.access_loggers.file.v3.FileAccessLog
              path: "/var/log/envoy/access.log"
              log_format:
                json_format:
                  time: "%START_TIME%"
                  protocol: "%PROTOCOL%"
                  duration: "%DURATION%"
                  request_method: "%REQ(:METHOD)%"
                  request_host: "%REQ(HOST)%"
                  path: "%REQ(X-ENVOY-ORIGINAL-PATH?:PATH)%"
                  response_code: "%RESPONSE_CODE%"
                  response_flags: "%RESPONSE_FLAGS%"
                  bytes_received: "%BYTES_RECEIVED%"
                  bytes_sent: "%BYTES_SENT%"
                  upstream_host: "%UPSTREAM_HOST%"
                  upstream_cluster: "%UPSTREAM_CLUSTER%"
                  upstream_local_address: "%UPSTREAM_LOCAL_ADDRESS%"

Diese Konfiguration richtet detaillierte, JSON-formatierte Zugriffsprotokolle ein, die für Debugging und Leistungsanalyse von unschätzbarem Wert sein können.

Leistungsoptimierung: Jeden letzten Tropfen herausquetschen

Bei der Leistungsoptimierung gibt es mehrere Bereiche, auf die Sie sich konzentrieren sollten:

Verbindungspooling: Konfigurieren Sie Verbindungspools richtig, um das Gleichgewicht zwischen Ressourcennutzung und Leistung zu halten.
Caching: Implementieren Sie Caching auf Gateway-Ebene, um die Belastung der Backend-Dienste zu reduzieren.
Timeout- und Wiederholungsrichtlinien: Optimieren Sie diese Einstellungen, um das Gleichgewicht zwischen Resilienz und Reaktionsfähigkeit zu halten.

Hier ist ein Beispiel, wie Sie Verbindungspooling in Envoy konfigurieren könnten:


clusters:
  - name: my_backend_service
    type: STRICT_DNS
    connect_timeout: 0.25s
    lb_policy: ROUND_ROBIN
    http2_protocol_options: {}
    upstream_connection_options:
      tcp_keepalive:
        keepalive_time: 300
    max_requests_per_connection: 1000
    circuit_breakers:
      thresholds:
        - priority: DEFAULT
          max_connections: 100
          max_pending_requests: 1000
          max_requests: 1000
    health_checks:
      - timeout: 1s
        interval: 10s
        unhealthy_threshold: 3
        healthy_threshold: 2
        http_health_check:
          path: "/healthz"

Diese Konfiguration richtet Verbindungspooling mit Keep-Alive ein, begrenzt die Anzahl der Anfragen pro Verbindung, konfiguriert Circuit Breaker und richtet Gesundheitsprüfungen für den Backend-Dienst ein.

Zusammenfassung: Das Tor zum API-Nirvana

Wir haben die fortgeschrittenen Bereiche der API-Gateway-Muster mit Envoy und Kong durchquert und alles von ausgeklügeltem Verkehrsmanagement bis hin zu eisenharten Sicherheitspraktiken erkundet. Denken Sie daran, mit großer Macht kommt große Verantwortung – und auch das Potenzial für einige wirklich coole API-Setups.

Wenn Sie diese Muster implementieren, denken Sie daran, dass jedes System einzigartig ist. Was für das eine funktioniert, muss nicht unbedingt für das andere funktionieren. Testen, messen und iterieren Sie immer. Und vor allem, haben Sie Spaß! Schließlich, wenn Sie keinen Spaß daran haben, Ihre API-Infrastruktur aufzubauen, machen Sie wahrscheinlich etwas falsch.

Gehen Sie nun hinaus und erobern Sie das API-Universum, bewaffnet mit Ihrem neu erworbenen Wissen über fortgeschrittene Gateway-Muster. Mögen Ihre Anfragen schnell, Ihre Sicherheit straff und Ihre Dienste immer verfügbar sein!

"Der einzige Weg, großartige Arbeit zu leisten, ist, zu lieben, was man tut." - Steve Jobs

(Und natürlich ein wirklich großartiges API-Gateway-Setup zu haben.)