Ingress Controller und Ingress-Ressourcen

Ziel

In diesem Projekt geht es um die Einrichtung eines Ingress Controllers und die Konfiguration von Ingress-Ressourcen für externe HTTP/HTTPS-Zugriffe. Sie werden:

Helm als Package Manager für Kubernetes installieren
Traefik als Ingress Controller über Helm bereitstellen
Eine Ingress-Ressource für die Demo-Anwendung erstellen
Den externen Zugriff über den Ingress Controller testen
Die Unterschiede zu NodePort und LoadBalancer Services verstehen

Vorbereitung

Stellen Sie sicher, dass die Demo-Anwendung aus der vorherigen Aufgabe noch läuft

kubectl get pods -n docker-demoapp
kubectl get services -n docker-demoapp

Erstellen Sie ein Arbeitsverzeichnis und wechseln Sie hinein
```
cd ~/workspace
mkdir ingress-setup
cd ingress-setup
```

Aufgabe 1: Helm installieren

Helm Binary herunterladen

Laden Sie die aktuelle Helm-Version herunter und installieren Sie sie

wget https://get.helm.sh/helm-v3.19.0-linux-amd64.tar.gz
tar -zxvf helm-v3.19.0-linux-amd64.tar.gz
cp linux-amd64/helm .
rm -r helm-v3.19.0-linux-amd64.tar.gz linux-amd64

Überprüfen Sie die Installation
```
./helm version
```

Lösung

Nach der Installation sollten Sie eine Ausgabe ähnlich dieser sehen:

version.BuildInfo{Version:"v3.19.0", GitCommit:"...", GitTreeState:"clean", GoVersion:"go1.23.4"}

Aufgabe 2: Traefik Ingress Controller installieren

Helm Repository konfigurieren

Fügen Sie das Traefik Helm Repository hinzu

./helm repo add traefik https://traefik.github.io/charts

Aktualisieren Sie die Repository-Informationen
```
./helm repo update
```
Listen Sie die verfügbaren Repositories auf
```
./helm repo list
```

Traefik installieren

Installieren Sie Traefik mit Helm in einem eigenen Namespace

./helm install traefik traefik/traefik \
  --namespace traefik \
  --create-namespace

Überprüfen Sie den Installationsstatus
```
./helm list -n traefik
```

Traefik-Pods überprüfen

Warten Sie, bis alle Traefik-Pods laufen
```
kubectl -n traefik get pods
```
Überprüfen Sie die Services im Traefik-Namespace
```
kubectl -n traefik get services
```

Betrachten Sie die Details des Traefik-Service

kubectl -n traefik describe service traefik

Lösung

Sie sollten einen Pod im Status "Running" und einen Service vom Typ "LoadBalancer" (in der lokalen Umgebung als NodePort) sehen.

Aufgabe 3: Ingress-Ressource erstellen

Hostname ermitteln

Finden Sie den Hostname Ihres Worker-Nodes heraus (ersetzen Sie worker-0 mit dem entsprechenden Node)
```
kubectl get nodes -o wide
```
Notieren Sie sich den internen Hostname oder die IP-Adresse

Ingress-Manifest erstellen

Erstellen Sie eine ingress.yaml Datei für die Docker-Demo-App

Verwenden Sie den Hostname Ihres Clusters (angepasst an Ihre Umgebung)

cat > ingress.yaml << 'EOF'
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: docker-demoapp
  namespace: docker-demoapp
spec:
  ingressClassName: traefik
  rules:
  - host: HOSTNAME_HIER_EINFUEGEN
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: docker-demoapp
            port:
              number: 5000
EOF

Wichtig: Ersetzen Sie HOSTNAME_HIER_EINFUEGEN mit dem tatsächlichen Hostname Ihres Systems

Lösung

Wenn Ihr Worker-Node zum Beispiel worker-0.example.com heißt, sollte die host-Zeile so aussehen:

- host: worker-0.example.com

Ingress-Ressource bereitstellen

Wenden Sie das Ingress-Manifest an
```
kubectl apply -f ingress.yaml
```
Überprüfen Sie die erstellte Ingress-Ressource
```
kubectl get ingress -n docker-demoapp
```

Betrachten Sie die Details der Ingress-Ressource

kubectl describe ingress -n docker-demoapp docker-demoapp

Aufgabe 4: Ingress Controller Service überprüfen

NodePort des Traefik-Service ermitteln

Finden Sie den NodePort des Traefik-Service heraus
```
kubectl -n traefik get service traefik
```
Notieren Sie sich den Port für den HTTP-Traffic (normalerweise Port 80 wird auf einen NodePort gemappt)

Lösung

Die Ausgabe sollte ähnlich dieser sein:

NAME      TYPE       CLUSTER-IP     EXTERNAL-IP   PORT(S)                      AGE
traefik   NodePort   10.96.xxx.xxx  <none>        80:30080/TCP,443:30443/TCP   5m

In diesem Beispiel wäre der NodePort für HTTP-Traffic 30080.

Worker-Node IP ermitteln

Ermitteln Sie die externe IP-Adresse Ihres Worker-Nodes
```
kubectl get nodes -o wide
```

Aufgabe 5: Anwendung über Ingress testen

Browser-Zugriff

Öffnen Sie die Anwendung im Browser über die Ingress-URL
Format: http://HOSTNAME:NODEPORT
Beispiel: http://worker-0.example.com:30080

Funktionalität testen

Testen Sie die Anwendung:
Erstellen Sie eine neue Notiz
Speichern Sie die Notiz ab
Aktualisieren Sie die Seite und überprüfen Sie, ob die Notiz erhalten bleibt

Ingress-Logs überprüfen

Betrachten Sie die Logs des Traefik Ingress Controllers
```
kubectl -n traefik logs deployment/traefik
```

Aufgabe 6: Ingress-Konfiguration analysieren

Traefik Dashboard (Optional)

Überprüfen Sie, ob das Traefik Dashboard verfügbar ist

kubectl -n traefik port-forward deployment/traefik 9000:9000

Öffnen Sie http://localhost:9000 im Browser, um das Traefik Dashboard zu sehen

Ingress-Klassen verstehen

Listen Sie alle verfügbaren Ingress-Klassen auf
```
kubectl get ingressclass
```
Betrachten Sie die Details der Traefik Ingress-Klasse
```
kubectl describe ingressclass traefik
```

Aufgabe 7: Service-Typen vergleichen

Aktuelle Service-Konfiguration überprüfen

Vergleichen Sie die verschiedenen Service-Typen in Ihrem Cluster

# Demo-App Service (NodePort)
kubectl get service -n docker-demoapp docker-demoapp

# Traefik Service (LoadBalancer/NodePort)
kubectl get service -n traefik traefik

LoadBalancer vs NodePort vs Ingress

Dokumentieren Sie die Unterschiede zwischen den verschiedenen Zugriffsmethoden:
NodePort (docker-demoapp):
Direkter Zugriff über Node-IP:NodePort
Jeder Service benötigt einen eigenen Port
Ingress (über Traefik):
HTTP-basiertes Routing über Hostnamen/Pfade
Ein Ingress Controller kann mehrere Services bedienen
Layer 7 (HTTP/HTTPS) Funktionalität

Aufgabe 8: Troubleshooting (Optional)

DNS-Auflösung testen

Testen Sie die DNS-Auflösung zu Ihrem konfigurierten Hostname
```
nslookup HOSTNAME_HIER_EINFUEGEN
```

Ingress Controller Status

Überprüfen Sie den Status des Ingress Controllers

kubectl -n traefik get pods -o wide
kubectl -n traefik describe pod <traefik-pod-name>

Service Endpoints überprüfen

Überprüfen Sie, ob die Endpoints korrekt konfiguriert sind

kubectl get endpoints -n docker-demoapp docker-demoapp
kubectl get endpoints -n traefik traefik

Ingress Events

Betrachten Sie Events related zur Ingress-Ressource

kubectl get events -n docker-demoapp --field-selector involvedObject.name=docker-demoapp

Aufgabe 9: Cleanup (Optional)

Ressourcen entfernen

Entfernen Sie die Ingress-Ressource
```
kubectl delete -f ingress.yaml
```

Entfernen Sie Traefik (falls gewünscht)

./helm uninstall traefik -n traefik
kubectl delete namespace traefik

Ausblick

Nach Abschluss dieser Aufgabe haben Sie einen vollständigen Ingress Controller eingerichtet und verstehen die Unterschiede zwischen verschiedenen Service-Typen. Ingress Controller sind in produktiven Umgebungen der Standard-Weg für HTTP/HTTPS-Traffic, da sie flexibles Routing, SSL-Terminierung und andere Layer-7-Features bieten.

Produktive Umgebungen

In produktiven Umgebungen würde man zusätzlich konfigurieren: - SSL/TLS-Zertifikate (z.B. über cert-manager) - Authentifizierung und Autorisierung - Rate Limiting und andere Sicherheitsfeatures - Monitoring und Logging - Hochverfügbarkeit des Ingress Controllers

Hostname-Konfiguration

In dieser Lab-Umgebung verwenden wir einfache Hostnamen. In produktiven Umgebungen würden Sie echte DNS-Namen verwenden und entsprechende DNS-Einträge konfigurieren.