Eine grundlegende Einführung in Traefik

Voraussetzungen: Docker-Kenntnisse

1. Was ist Traefik?

Traefik ist eine Open-Source-Lösung, die als Reverse-Proxy und Lastausgleich für Dienste dient. Was sie auszeichnet, ist die Möglichkeit des dynamischen Routings.

2. Warum Traefik verwenden?

Traefik verwendet dynamisches Routing, um Dienste ohne manuelle Eingriffe anzusteuern, was es sehr praktisch macht, wenn Sie eine einfache und schnelle Implementierung einer Lösung für Ihre Microservices benötigen. Im Vergleich zu anderen Reverse-Proxy-Lösungen, bei denen Sie die Konfiguration manuell aktualisieren müssen (was mühsam und zeitaufwendig sein kann), erkennt Traefik diese Änderungen nun automatisch und aktiviert sie.  

3. Wie funktioniert Traefik?

Da wir das Grundkonzept von Traefik erklärt haben, können wir nun damit fortfahren zu verstehen, wie es funktioniert. Zunächst müssen wir uns mit seinen Komponenten und der Konfiguration vertraut machen.

Die automatische Konfigurationserkennung erfolgt mit Hilfe von Anbietern. Die Anbieter können Cloud-Anbieter, Container-Engines und andere Infrastrukturkomponenten sein. Docker, Kubernetes, oder Amazon ECS, um nur einige zu nennen. Traefik arbeitet mit Dutzenden von ihnen zusammen. Zusätzlich zum dynamischen Routing müssen Sie keine Konfigurationsdateien mehr pflegen. Stattdessen scannt Traefik die gesamte Infrastruktur alle 2 Sekunden (standardmäßig, aber dies kann geändert werden) und liest die Informationen, die Sie den Diensten zuordnen. Die Labels im Docker-Provider enthalten solche Informationen, anhand derer Traefik die Anfragen weiterleitet.

Installation von Traefik und Basic-Demonstration

Lassen Sie uns demonstrieren, wie Traefik Anfragen dynamisch weiterleitet. Zu diesem Zweck werden wir den Docker-Anbieter verwenden.

Zunächst müssen wir die erforderlichen Container ziehen. (Zum Zeitpunkt des Schreibens ist die neueste Version v2.9)

Bevor wir den Container starten, müssen wir noch einige Optionen hinzufügen. Wir werden eine docker-compose-Datei verwenden und alle Optionen beschreiben, die für die Ausführung einer grundlegenden Arbeitskonfiguration von Traefik erforderlich sind.

Zunächst wollen wir ein Netzwerk für Traefik erstellen:

Als Nächstes schreiben wir die Kompositionsdatei mit den folgenden Optionen, die in einem Kommentar erläutert werden:

version: '3'

services:
  traefik:
    image: "traefik:v2.9"
    container_name: "traefik"
    ports:
      - "80:80"
      - "8080:8080" # Expose Dashboard
    command:
      - --providers.docker=true # Enables docker as the provider
      - --api.insecure=true # Allows using the api without any ssl certs
      - --api.dashboard=true # Allows dashboard to detect services (dashboard explained below)
      - --providers.docker.network=traefik-net # Traefik will be working in the network we created named “traefik-net”
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
    networks:
      - traefik-net

networks:
  traefik-net:
    external: true

Wir sind bereit, den Container zu starten:

Wir können den laufenden Container mit dem Befehl docker ps überprüfen

CONTAINER ID   IMAGE          COMMAND                  CREATED          STATUS          PORTS                                                                          NAMES
144e6e1cbcd2   traefik:v2.9   "/entrypoint.sh --pr…"   19 minutes ago   Up 18 minutes   0.0.0.0:80->80/tcp, :::80->80/tcp, 0.0.0.0:8080->8080/tcp, :::8080->8080/tcp   traefik

Wie Sie wahrscheinlich schon in der Compose-Datei bemerkt haben, haben wir das Dashboard von Traefik bereits veröffentlicht. Wir können es über Port 8080 erreichen:

Ein paar Worte zum Armaturenbrett

Das Dashboard ist eine sehr bequeme und hübsche Möglichkeit, die Statistiken Ihrer Dienste und Routen einzusehen. Wenn ein Dienst von Traefik gescannt wird, erscheint er automatisch auf dem Dashboard. Wenn wir zum Abschnitt HTTP gehen, sehen wir, dass wir bereits 3 Router haben . Laut der offiziellen Dokumentation ist ein Router dafür zuständig, eingehende Anfragen mit den Diensten zu verbinden, die sie bearbeiten können. Der Port 80, der einer der Eingangspunkte ist, ist für die eingehenden Anfragen reserviert.

Die Router , die wir hier sehen, sind die Standardrouter, die die Routen zu den Traefik-Komponenten definieren. 

Hinweis: Wie wir bereits erwähnt haben, kann das Dashboard sehr praktisch sein. Es stellt jedoch eine Sicherheitslücke dar und sollte in einer Umgebung mit Netzwerkzugriff von außen nicht offengelegt werden. Daher sollte es in einer Produktionsumgebung entweder deaktiviert (Port 8080 aus der Compose-Datei entfernen), mit SSL-Zertifikaten und anderen Mitteln ordnungsgemäß geschützt oder nur in einem internen Netzwerk verwendet werden.

Hinzufügen von Diensten zu Traefik

Fügen wir einen Dienst hinzu, an den Traefik die Anfragen weiterleiten wird. Für den alleinigen Zweck dieser Demonstration werden wir einen Nginx-Webserver in Docker verwenden.

Ziehen Sie direkt das Image und starten Sie den nginx-Container:

Beachten Sie, dass wir den Container in dem zuvor erstellten Docker-Netzwerk starten und Port 8081 für den Webserver freigeben, da Port 80 bereits von Traefik verwendet wird, um alle Anfragen durchzuleiten.

Nachdem wir sichergestellt haben, dass nginx läuft, können wir überprüfen, wie es im Dashboard erscheint. Und ohne weitere Eingriffe können wir den neuen Host sehen:

Nun ist der neue Host kein FQDN und wir können nicht auf diese Weise darauf zugreifen, was bedeutet, dass Traefik im Moment keine Anfragen über ihn leiten kann. Wie wir wissen, scannt Traefik die Dienste und sucht speziell nach Container-Labels. Die Labels dienen als Anweisungen für Traefik.

Fügen wir den Behältern Etiketten hinzu.

Run docker-compose down und bearbeiten Sie die Kompositionsdatei wie folgt:

version: '3'

services:
  traefik:
    image: "traefik:v2.9"
    container_name: "traefik"
    ports:
      - "80:80"
      - "8080:8080" # Expose Dashboard
    command:
      - --providers.docker=true
      - --api.insecure=true
      - --api.dashboard=true
      - --providers.docker.network=traefik-net
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
    networks:
      - traefik-net
    labels:
      - "traefik.enable=true" # Enable assigning subdomain to the dashboard
      - "traefik.http.routers.api.rule=Host(`traefik.localhost`)" # Domain for the dashboard

  nginx1:
    image: "nginx:latest"
    container_name: "nginx1"
    ports:
      - "8081:80"
    depends_on:
      - traefik
    networks:
      - traefik-net
    labels:
      - "traefik.http.routers.nginx1.rule=(Host(`nginx.localhost`)
      - "traefik.enable=true" # Enable assigning subdomain to the service
networks:
  traefik-net:
    external: true

traefik.http.routers.nginx1.rule legt den Localhost fest, von dem aus Traefik die Anfrage an den Webserver weiterleitet.

Wir sehen, dass wir jetzt einen richtigen Host haben. Testen wir, ob er funktioniert:

Beachten Sie, dass wir jetzt eine Verbindung zum Dashboard über die Domäne traefik.localhost herstellen können, die wir im Label des Containers festgelegt haben. Die nginx.localhost sollte uns auch auf den Webserver-Container umleiten:

Konfiguration von mehr als einem Dienst mit einer einzigen Domäne 

Der typische Anwendungsfall ist, dass wir Microservices haben, die eine Domain verwenden. Wir werden zwei benutzerdefinierte Nginx-Images mit benutzerdefinierten Konfigurationen erstellen. Nehmen wir an, dass diese 2 Container unterschiedliche Funktionen haben werden.

Erste Webserver default.conf:

server {
    listen       80;
    listen  [::]:80;
    server_name  localhost;


    location  /static {
        alias   /usr/share/nginx/html/static;
        try_files $uri $uri/ @static;
        index index.html;
    }

    location @ static {
      rewrite /static/(.*)$ /static/index.html?/$1 last;
    }

    error_page   500 502 503 504  /50x.html;
    location = /50x.html {
        root   /usr/share/nginx/html;
    }
}

Dockerfile:

FROM nginx 

RUN mkdir -p /usr/share/nginx/html/static
COPY index.html /usr/share/nginx/html/static
RUN chmod -R 755 /usr/share/nginx/html/static
COPY default.conf /etc/nginx/conf.d

Erstellen Sie eine benutzerdefinierte Indexdatei. Der Inhalt meiner Datei ist einfach "STATIC PAGE".

Zweiter Webserver default.conf:

server {
    listen       80;
    listen  [::]:80;
    server_name  localhost;


    location  /info {
        alias   /usr/share/nginx/html/info;
        try_files $uri $uri/ @info;
        index index.html;
    }

    location @ info {
      rewrite /info/(.*)$ /info/index.html?/$1 last;
    }

    error_page   500 502 503 504  /50x.html;
    location = /50x.html {
        root   /usr/share/nginx/html;
    }
}

Dockerfile:

FROM nginx 

RUN mkdir -p /usr/share/nginx/html/static
COPY index.html /usr/share/nginx/html/static
RUN chmod -R 755 /usr/share/nginx/html/static
COPY default.conf /etc/nginx/conf.d

Erstellen Sie die zweite Indexdatei mit einem anderen Inhalt.

Erstellen Sie die beiden Images in den jeweiligen Verzeichnissen. Ich werde sie nginx1 und nginx2 nennen.

docker build -t nginx1 .
docker build -t nginx2 .

Aktualisieren Sie die Kompositionsdatei und fügen Sie den neuen Containern die Etiketten mit den richtigen Regeln hinzu.

version: '3'

services:
  traefik:
    image: "traefik:v2.9"
    container_name: "traefik"
    ports:
      - "80:80"
      - "8080:8080" # Expose Dashboard
    command:
      - --providers.docker=true
      - --api.insecure=true
      - --api.dashboard=true
      - --providers.docker.network=traefik-net
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
    networks:
      - traefik-net
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.api.rule=Host(`traefik.localhost`)"

  nginx1:
    image: "nginx1:latest"
    container_name: "nginx1"
    ports:
      - "8081:80"
    depends_on:
      - traefik
    networks:
      - traefik-net
    labels:
      - "traefik.http.routers.nginx1.rule=(Host(`nginx.localhost`) && PathPrefix(`/static`))"
      - "traefik.enable=true"

  nginx2:
    image: "nginx2:latest"
    container_name: "nginx2"
    ports:
      - "8082:80"
    depends_on:
      - traefik
    networks:
      - traefik-net
    labels:
      - "traefik.http.routers.nginx2.rule=(Host(`nginx.localhost`) && PathPrefix(`/info`))"
      - "traefik.enable=true"

networks:
  traefik-net:
    external: true

Die PathPrefix-Regel entspricht dem Pfad des Anfragepräfixes. 

Starten Sie die Container:

sudo docker-compose up -d

Auf dem Dashboard können wir nun beide Hosts sehen.

Prüfen wir, ob wir Zugang zu jeder der URLs haben:

Traefik leitet die Anfragen entsprechend der URL auf der Grundlage der in den Containern festgelegten Labels erfolgreich um. Auf diese Weise können Sie ein dynamisches und automatisches Routing für Ihre Microservices einrichten. 

Schlussfolgerung

In diesem Leitfaden haben wir gezeigt, dass Traefik mit einer einfachen Konfiguration von großem praktischen Nutzen sein kann. Darüber hinaus sind seine Möglichkeiten keineswegs auf die von uns vorgestellten beschränkt. Traefik bietet viele erweiterte Optionen, wie das Hinzufügen von HTTP-Middleware, zusätzlichen Regeln, SSL-Zertifikaten zu den Diensten und mehr. Es gibt noch viele weitere Fälle, in denen Traefik hilfreich sein kann. Tauchen Sie ein und erforschen Sie neue Fallbeispiele und erfahren Sie mehr darüber, wie Sie Ihre Arbeit mit diesem modernen Reverse Proxy vereinfachen können!