Traefik

Traefik ist ein Open-Source Edge Router, der automatisch Routen zu Ihren Diensten entdeckt und konfiguriert, indem er sich direkt in Orchestratoren wie Docker und Kubernetes integriert und als dynamischer Reverse Proxy und Load Balancer fungiert.

Kernkonzepte

Traefik arbeitet mit einem dynamischen Konfigurationsmodell, wodurch manuelle Dateiaktualisierungen und Dienstneustarts entfallen, wenn sich Backend-Dienste ändern. Diese Echtzeit-Anpassungsfähigkeit wird durch mehrere miteinander verbundene Komponenten erreicht.

Provider

Provider sind die Konnektoren, die es Traefik ermöglichen, mit Ihrer Infrastruktur zu interagieren. Sie überwachen die API des zugrunde liegenden Orchestrators auf Änderungen, wie z.B. neue Container, Dienste oder Deployments.
Häufige Provider sind:
* Docker: Überwacht Docker-Daemon-Ereignisse und Container-Labels.
* Kubernetes: Überwacht die Kubernetes-API auf Ingress, IngressRoute, Service und Endpoint-Ressourcen.
* File: Liest die Konfiguration aus statischen YAML- oder TOML-Dateien.
* Consul, etcd, ZooKeeper: Integriert sich in Key-Value-Stores für dynamische Konfiguration.

Routing-Konfiguration

Traefik verarbeitet eingehende Anfragen über einen definierten Routing-Fluss:

• EntryPoints: Dies sind Netzwerk-Listener, die die Ports definieren, auf denen Traefik lauscht (z.B. web auf Port 80, websecure auf Port 443).
• Routers: Router analysieren eingehende Anfragen basierend auf definierten Regeln (z.B. Host(), PathPrefix(), Headers()). Wenn eine Anfrage einer Router-Regel entspricht, wird sie weitergeleitet. Router legen auch fest, auf welchen EntryPoints sie lauschen und können Middlewares anwenden.
• Middlewares: Middlewares sind Komponenten, die Anfragen ändern können, bevor sie den Dienst erreichen, oder Antworten ändern können, bevor sie an den Client zurückgesendet werden. Sie können miteinander verkettet werden.
• Services: Services definieren, wie die eigentlichen Backend-Anwendungsinstanzen erreicht werden. Ein Service verweist typischerweise auf eine oder mehrere IP-Adressen und Ports Ihrer Anwendung. Traefik kann Anfragen über mehrere Instanzen eines Dienstes hinweg lastverteilen.

Der Fluss ist: Anfrage -> EntryPoint -> Router -> Middleware(s) -> Service -> Backend-Anwendung.

Hauptmerkmale

Automatische Dienst-Erkennung

Traefik integriert sich direkt in Orchestratoren wie Docker und Kubernetes. Es entdeckt Dienste automatisch, indem es Metadaten (z.B. Docker-Labels, Kubernetes-Annotationen oder Custom Resources) liest und seine Routing-Konfiguration dynamisch aktualisiert, ohne manuelle Eingriffe oder Neustarts. Dies eliminiert die Notwendigkeit, separate Proxy-Konfigurationsdateien zu pflegen.

SSL/TLS-Terminierung

Traefik bietet integrierte Unterstützung für SSL/TLS-Terminierung. Es kann Zertifikate automatisch bereitstellen und erneuern, indem es Let's Encrypt über das ACME-Protokoll (Automatic Certificate Management Environment) verwendet, das HTTP-01-, TLS-ALPN-01- und DNS-01-Challenges unterstützt. Benutzerdefinierte Zertifikate können ebenfalls konfiguriert werden.

Lastverteilung

Traefik fungiert als Load Balancer und verteilt eingehenden Datenverkehr auf mehrere Instanzen eines Dienstes.
Verfügbare Load-Balancing-Strategien umfassen:
* Round Robin: Verteilt Anfragen sequenziell an jeden Server.
* Weighted Round Robin: Ermöglicht die Zuweisung von Gewichten zu Servern, um die Datenverkehrsverteilung zu steuern.
* Sticky Sessions: Stellt sicher, dass Anfragen von einem bestimmten Client immer an denselben Server weitergeleitet werden.

Middlewares

Middlewares bieten eine flexible Möglichkeit, Anfragen oder Antworten zu ändern. Sie können auf bestimmte Router oder global angewendet werden.
Beispiele für gängige Middlewares sind:
* Authentifizierung: Basic Authentication (BasicAuth), Digest Authentication.
* Rate Limiting: Steuert die Anzahl der Anfragen, die ein Client innerhalb einer bestimmten Zeit stellen kann.
* Header Manipulation: Hinzufügen, Entfernen oder Ändern von Anfrage-/Antwort-Headern.
* Redirects: HTTP-zu-HTTPS-Umleitung, permanente Umleitungen.
* IP Whitelisting/Blacklisting: Beschränkt den Zugriff basierend auf Client-IP-Adressen.

Dashboard

Traefik enthält ein webbasiertes Dashboard, das eine Echtzeitübersicht der konfigurierten Router, Dienste und Middlewares bietet. Es ermöglicht Administratoren, die aktive Konfiguration zu überprüfen und den Datenverkehr zu überwachen.

Traefik mit Docker

Die Integration von Traefik mit Docker beinhaltet das Ausführen von Traefik als Container und das Ermöglichen des Zugriffs auf den Docker-Daemon-Socket. Die Dienstkonfiguration wird typischerweise über Docker-Labels auf Anwendungscontainern verwaltet.

Beispiel docker-compose.yml Setup

Das folgende Beispiel demonstriert eine docker-compose.yml-Datei für die Einrichtung von Traefik und einer Beispielanwendung whoami.

version: '3.8'

services:
  traefik:
    image: traefik:v2.10
    command:
      - --api.dashboard=true
      - --providers.docker=true
      - --providers.docker.exposedbydefault=false # Only expose services with traefik.enable=true
      - --entrypoints.web.address=:80
      - --entrypoints.websecure.address=:443
      - --certificatesresolvers.myresolver.acme.tlschallenge=true # For Let's Encrypt
      - --certificatesresolvers.myresolver.acme.email=your-email@example.com
      - --certificatesresolvers.myresolver.acme.storage=/letsencrypt/acme.json # Persistent storage for certs
    ports:
      - "80:80"
      - "443:443"
      - "8080:8080" # Expose Traefik Dashboard
    volumes:
      - "/var/run/docker.sock:/var/run/docker.sock:ro" # Mount Docker socket for provider access
      - "./letsencrypt:/letsencrypt" # Persistent storage for ACME certificates
    labels:
      # Enable Traefik for the dashboard service itself
      - "traefik.enable=true"
      # Router for the Traefik dashboard
      - "traefik.http.routers.traefik-dashboard.rule=Host(`traefik.yourdomain.com`)"
      - "traefik.http.routers.traefik-dashboard.entrypoints=websecure"
      - "traefik.http.routers.traefik-dashboard.service=api@internal" # Internal Traefik API service
      - "traefik.http.routers.traefik-dashboard.tls.certresolver=myresolver"
      # Basic authentication middleware for the dashboard (replace with actual htpasswd hash)
      - "traefik.http.routers.traefik-dashboard.middlewares=dashboard-auth@docker"
      - "traefik.http.middlewares.dashboard-auth.basicauth.users=user:$$apr1$$YOUR_HTPASSWD_HASH"
    networks:
      - web

  whoami:
    image: traefik/whoami
    labels:
      - "traefik.enable=true" # Enable Traefik for this service
      - "traefik.http.routers.whoami.rule=Host(`whoami.yourdomain.com`)" # Define routing rule
      - "traefik.http.routers.whoami.entrypoints=websecure" # Listen on websecure (HTTPS)
      - "traefik.http.routers.whoami.tls.certresolver=myresolver" # Use Let's Encrypt resolver
    networks:
      - web

networks:
  web:
    external: true # Use an external network for all web-facing services

Hinweis: Bevor Sie docker-compose up -d ausführen, erstellen Sie das externe Netzwerk mit docker network create web.
Generieren Sie einen htpasswd-Hash für dashboard-auth mit echo $(htpasswd -nb user password).

Traefik mit Kubernetes

Traefik integriert sich in Kubernetes über dessen API, wobei es Standard-Ingress-Ressourcen und eigene Custom Resource Definitions (CRDs) für erweiterte Konfigurationen nutzt. Die empfohlene Installationsmethode ist über Helm.

Installation mit Helm

helm repo add traefik https://traefik.github.io/charts
helm repo update
helm install traefik traefik/traefik \
  --namespace traefik \
  --create-namespace \
  -f values.yaml

Die values.yaml-Datei konfiguriert typischerweise Traefiks EntryPoints, Providers und ACME-Resolver (z.B. myresolver für Let's Encrypt).

Konfiguration über Custom Resource Definitions (CRDs)

Traefik erweitert die Kubernetes-Funktionen mit eigenen CRDs und bietet mehr Kontrolle als Standard-Ingress:
* IngressRoute: Definiert Routing-Regeln, Entry Points und zugehörige Dienste, einschließlich TLS-Konfiguration und Middlewares. Dies ist eine leistungsfähigere Alternative zum Standard-Kubernetes-Ingress.
* Middleware: Definiert wiederverwendbare Anfrage-/Antwort-Modifikatoren, die auf IngressRoutes angewendet werden können.
* TraefikService: Ermöglicht die detailliertere Definition von Backend-Diensten, einschließlich Load-Balancing-Strategien und externen Diensten.

Beispiel Kubernetes-Konfiguration

Dieses Beispiel zeigt ein Kubernetes Deployment, Service und eine IngressRoute für eine whoami-Anwendung.

# whoami-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: whoami
  labels:
    app: whoami
spec:
  replicas: 2
  selector:
    matchLabels:
      app: whoami
  template:
    metadata:
      labels:
        app: whoami
    spec:
      containers:
      - name: whoami
        image: traefik/whoami
        ports:
        - containerPort: 80

---
# whoami-service.yaml
apiVersion: v1
kind: Service
metadata:
  name: whoami
spec:
  selector:
    app: whoami
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80

---
# whoami-ingressroute.yaml
apiVersion: traefik.containo.us/v1alpha1
kind: IngressRoute
metadata:
  name: whoami-ingressroute
spec:
  entryPoints:
    - websecure # Assumes 'websecure' entry point is configured in Traefik's Helm values
  routes:
    - match: Host(`whoami.yourdomain.com`)
      kind: Rule
      services:
        - name: whoami # Refers to the Kubernetes Service 'whoami'
          port: 80
  tls:
    certResolver: myresolver # Assumes 'myresolver' for Let's Encrypt is configured in Traefik's Helm values

Vergleich: Traefik vs. Traditionelle Proxys (Nginx/HAProxy)

Monitoring und Dashboard

Das Traefik-Dashboard bietet eine grafische Oberfläche zur Visualisierung der aktuellen Routing-Konfiguration und zur Überwachung des Traefik-Status. Es kann über einen Webbrowser aufgerufen werden, typischerweise auf Port 8080 (wie im Docker-Beispiel konfiguriert). Aus Sicherheitsgründen ist es üblich, das Dashboard mit einer Middleware wie der Basisauthentifizierung zu schützen.

Best Practices

• Traefik isolieren: Führen Sie Traefik in einem dedizierten Netzwerk oder Kubernetes-Namespace aus, um die Sicherheit zu erhöhen und die Verwaltung zu vereinfachen.
• Dashboard sichern: Schützen Sie das Traefik-Dashboard immer mit Authentifizierung (z.B. BasicAuth-Middleware) und stellen Sie sicher, dass es nur autorisiertem Personal zugänglich ist.
• Persistenter Speicher für ACME: Stellen Sie für Let's Encrypt-Zertifikate sicher, dass der ACME-Speicherpfad (z.B. /letsencrypt/acme.json) auf persistenten Speicher abgebildet wird. Dies verhindert den Verlust von Zertifikaten beim Neustart oder der erneuten Bereitstellung von Containern.
• Geringstes Privileg: Wenn Sie den Docker-Socket (/var/run/docker.sock) mounten, stellen Sie sicher, dass Traefik mit den minimal notwendigen Privilegien ausgeführt wird. Erwägen Sie die Verwendung eines schreibgeschützten Mounts (:ro), wenn Schreibzugriff nicht erforderlich ist.
• exposedbydefault=false: Für Docker-Provider ist das Setzen von --providers.docker.exposedbydefault=false eine bewährte Sicherheits- und Verwaltungspraxis. Dies erfordert explizite traefik.enable=true-Labels auf Containern, die exponiert werden sollen.