Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 13: Ingress-Migration

Ziel: Du migrierst einen ingress-nginx-Altbestand mit Annotationen auf Gateway API, betreibst alt und neu parallel, schaltest per DNS um und kannst jederzeit zurück. · Dauer: ca. 120 min · Voraussetzung: Tag 12

Briefing

  • ingress-nginx (kubernetes/ingress-nginx) ist seit März 2026 retired: Repo archiviert, letztes Release Chart 4.15.1 / Controller v1.15.1, keine Security-Fixes mehr. Nicht betroffen ist der NGINX Ingress Controller von F5 (nginx/kubernetes-ingress).
  • RKE2 bringt seit v1.36 Traefik als Standard-Ingress mit. In unserem Lab ist er aus (ingress-controller: none, Tag 8), weil sein CRD-Chart Gateway API v1.5.1 Standard mitbringt.
  • ingress2gateway übersetzt Ingress plus Annotationen in Gateway-API-Objekte – aber nicht alles. Jede Warnung ist ein Arbeitspaket.
  • Ablauf: Inventur → Konvertieren → Nachbearbeiten → Parallelbetrieb → DNS umschalten → Beobachten → Altlast entfernen. Rollback ist bis zum Schluss ein DNS-Eintrag.
                     DNS legacy.apps.lab.internal
                    ┌──────────────┴──────────────┐
            vorher  ▼                      nachher ▼
   10.10.20.110 ingress-nginx         10.10.20.100 Envoy Gateway (infra/web)
   Ingress shop, shop-canary,         HTTPRoute shop/legacy
   shop-legacy-api (Annotationen)     + BackendTrafficPolicy + SecurityPolicy
                    └──────► Service shop-v1 / shop-v2 ◄──┘

Achtung: Alle Drills laufen auf dem RKE2-Cluster aus Tag 9–12. Die Konvertierung mit ingress2gateway v1.2.0 ist live gegen die Beispieldateien gelaufen (Ausgaben echt); Manifeste sind mit kubeconform geprüft. Cluster-Ausgaben sind nicht live erzeugt.

Drill 1: Den Altbestand aufbauen

Ohne Traefik im RKE2 installieren wir einen Legacy-Controller selbst – ingress-nginx in der letzten Version, auf eigener IP 10.10.20.110 aus dem Cilium-Pool:

export KUBECONFIG=~/.kube/rke2-lab.yaml
mkdir -p ~/gw-lab/tag13 && cd ~/gw-lab/code/tag13
cat ingress-nginx-values.yaml

Erwartet:

# Legacy-Controller für den Parallelbetrieb auf RKE2 (Tag 13).
# ingress-nginx ist seit März 2026 retired: 4.15.1/v1.15.1 ist das letzte Release.
controller:
  ingressClassResource:
    name: nginx
    default: false
  service:
    type: LoadBalancer
    externalTrafficPolicy: Cluster       # Cilium L2 wie beim Gateway
    annotations:
      lbipam.cilium.io/ips: 10.10.20.110
  allowSnippetAnnotations: true          # nur für den Altbestand-Test (Snippets!)
  config:
    annotations-risk-level: Critical     # sonst lehnt v1.12+ Snippets ab
  admissionWebhooks:
    enabled: true
helm upgrade --install legacy ingress-nginx \
  --repo https://kubernetes.github.io/ingress-nginx --version 4.15.1 \
  -n ingress-nginx --create-namespace -f ingress-nginx-values.yaml --wait
kubectl apply -f legacy-ingress.yaml
kubectl -n shop get ingress

Erwartet (gekürzt, kann je nach Version abweichen):

Release "legacy" does not exist. Installing it now.
STATUS: deployed
ingress.networking.k8s.io/shop created
ingress.networking.k8s.io/shop-canary created
ingress.networking.k8s.io/shop-legacy-api created
NAME              CLASS   HOSTS                      ADDRESS        PORTS   AGE
shop              nginx   legacy.apps.lab.internal   10.10.20.110   80      20s
shop-canary       nginx   legacy.apps.lab.internal   10.10.20.110   80      20s
shop-legacy-api   nginx   legacy.apps.lab.internal   10.10.20.110   80      20s

Damit der Name heute schon auf den alten Controller zeigt, bekommt er im DNS einen spezifischen Eintrag vor dem Wildcard aus Tag 9 (dnsmasq/Pi-hole):

echo 'address=/legacy.apps.lab.internal/10.10.20.110' \
  | ssh pihole 'sudo tee /etc/dnsmasq.d/20-legacy.conf && sudo pihole reloaddns'
dig +short legacy.apps.lab.internal
curl -s http://legacy.apps.lab.internal/api/v1/orders -D - -o /dev/null \
  | grep -i '^x-legacy'

Erwartet (gekürzt, kann je nach Version abweichen):

address=/legacy.apps.lab.internal/10.10.20.110
10.10.20.110
X-Legacy: true

Drei Ingresses, sieben Annotationsarten: Canary per Gewicht, Regex mit Capture-Group- Rewrite, IP-Allowlist, CORS, Body-Limit, Timeout und ein configuration-snippet. Das ist ein typischer Ausschnitt aus Kundenclustern.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Inventur

Vor jeder Konvertierung: Was gibt es, und welche Ingresses sind riskant? inventory.sh liest alle Ingresses und zählt Klassen, Hosts und Annotationen:

./inventory.sh

Erwartet:

== Ingress pro Klasse
   3 nginx
== Hosts
   3 legacy.apps.lab.internal
== Annotationen (Häufigkeit)
   1 nginx.ingress.kubernetes.io/whitelist-source-range
   1 nginx.ingress.kubernetes.io/use-regex
   1 nginx.ingress.kubernetes.io/ssl-redirect
   1 nginx.ingress.kubernetes.io/rewrite-target
   1 nginx.ingress.kubernetes.io/proxy-read-timeout
   1 nginx.ingress.kubernetes.io/proxy-body-size
   1 nginx.ingress.kubernetes.io/enable-cors
   1 nginx.ingress.kubernetes.io/cors-allow-origin
   1 nginx.ingress.kubernetes.io/configuration-snippet
   1 nginx.ingress.kubernetes.io/canary-weight
   1 nginx.ingress.kubernetes.io/canary
== Risiko: Snippets und Regex
shop/shop-legacy-api

Im Kundencluster sind es Hunderte. Sortiere die Annotationsliste gegen die Tabelle in Drill 4: Alles, was dort „manuell” heißt, ist Aufwand. Snippets (*-snippet) sind rohe NGINX-Konfiguration – dafür gibt es nie eine automatische Übersetzung.

Tipp: Ingresses ohne ingressClassName, nur mit der alten Annotation kubernetes.io/ingress.class, zählt das Skript mit. ingress2gateway findet sie auch, der Default-Controller-Fall (gar keine Klasse) muss aber explizit geprüft werden.

Fortschritt speichern? Kostenlos registrieren

Drill 3: ingress2gateway laufen lassen

brew install ingress2gateway       # Linux: Release-Tarball v1.2.0 nach ~/.local/bin
ingress2gateway version
ingress2gateway print --providers=ingress-nginx -n shop --no-color \
  > i2gw-standard.yaml 2> i2gw-warnings.txt
grep '^│' i2gw-warnings.txt | grep -v 'source:\|object:' | cut -c1-86

Erwartet:

ingress2gateway version: 1.2.0
│  Ingress NGINX serves TLS traffic for host "legacy.apps.lab.internal" with a self-si
│  Unsupported annotation nginx.ingress.kubernetes.io/configuration-snippet
│  Using case-insensitive regex path matches. You may want to change this.
│  ingress-nginx only supports TCP-level timeouts; i2gw has made a best-effort transla
│  Failed to apply shop.shop.metadata.annotations."nginx.ingress.kubernetes.io/proxy-b
│  Failed to apply shop.shop-legacy-api.metadata.annotations."nginx.ingress.kubernetes
│  Failed to apply metadata.annotations."nginx.ingress.kubernetes.io/rewrite-target" f
│  Gateway API does not support configuring URL normalization (RFC 3986, Section 6). P

Ohne Cluster geht es auch mit Dateien – ideal für Reviews im Merge Request: --input-file legacy-ingress.yaml -A. Was ist herausgekommen?

yq -N 'select(.kind=="HTTPRoute") | .spec.rules[] | [.matches[0].path.type,
  .matches[0].path.value, (.backendRefs | map(.name + ":" + (.weight // 1
  | tostring)) | join(" ")), (.timeouts.request // "-")] | join("  ")' \
  i2gw-standard.yaml
yq -N 'select(.kind=="Gateway") | .metadata.name + " " + .spec.gatewayClassName' \
  i2gw-standard.yaml

Erwartet:

RegularExpression  (?i)/.*  shop-v1:80 shop-v2:20  5m0s
RegularExpression  (?i)/api/v1(/|$)(.*).*  shop-v1:1  -
nginx nginx

Was auffällt:

  • Canary wurde sauber zu Gewichten 80/20 – gut.
  • use-regex gilt bei ingress-nginx für alle Pfade des Hosts. Darum ist auch / jetzt eine case-insensitive Regex (?i)/.*. Die Reihenfolge zwischen Regex-Regeln legt die Gateway API nicht fest – das ist implementierungsabhängig.
  • Der Rewrite /$2 fehlt komplett, /api/v1/orders käme ungekürzt beim Backend an.
  • Aus proxy-read-timeout: 30 wurde timeouts.request: 5m0s – ein ganz anderer Wert.
  • Das generierte Gateway nginx mit GatewayClass nginx gibt es bei uns nicht.
  • ingress-nginx beantwortet HTTPS für jeden Host, notfalls mit Fake-Zertifikat. Das neue Gateway liefert HTTPS über den Wildcard-Listener https mit echtem Lab-CA-Zertifikat.

Mit --emitter envoy-gateway erzeugt das Tool zusätzlich Envoy-Gateway-Policies:

ingress2gateway print --providers=ingress-nginx -n shop --no-color \
  --emitter envoy-gateway 2>/dev/null | yq -N 'select(.apiVersion
  | test("envoyproxy")) | .kind + " -> " + (.spec | keys | join(","))'

Erwartet:

BackendTrafficPolicy -> requestBuffer,targetRefs
SecurityPolicy -> authorization,targetRefs

proxy-body-size wird zu requestBuffer.limit: 8Mi (größere Requests: 413), die IP-Allowlist zu einer SecurityPolicy mit clientCIDRs.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Annotation → Gateway API, dann nachbearbeiten

Die Mapping-Tabelle für die häufigsten ingress-nginx-Annotationen:

Annotation Gateway API / Envoy Gateway i2gw
canary, canary-weight, canary-by-header backendRefs[].weight, Header-matches (Tag 5) ja
rewrite-target ohne $1 Filter URLRewrite (Tag 3) ja
rewrite-target mit $1/$2 URLRewrite ReplacePrefixMatch oder EG HTTPRouteFilter nein
use-regex RegularExpression, besser PathPrefix ja
ssl-redirect, force-ssl-redirect Filter RequestRedirect auf dem HTTP-Listener (Tag 4) ja
permanent-redirect, app-root Filter RequestRedirect ja
enable-cors, cors-* Filter CORS (Tag 3) bzw. EG SecurityPolicy (Tag 10) ja
proxy-read/send/connect-timeout timeouts.request/backendRequest (Tag 3), EG BackendTrafficPolicy teils
proxy-body-size EG BackendTrafficPolicy.requestBuffer Emitter
whitelist-source-range EG SecurityPolicy.authorization (clientCIDRs) Emitter
auth-url, auth-signin EG SecurityPolicy.extAuth (HTTP/gRPC) nein
auth-type: basic EG SecurityPolicy.basicAuth (Tag 10) nein
limit-rps, limit-connections EG BackendTrafficPolicy.rateLimit (Tag 10) nein
affinity: cookie sessionPersistence (experimentell) teils
backend-protocol: GRPC GRPCRoute (Tag 6) ja
ssl-passthrough TLSRoute mit Passthrough-Listener (Tag 4) ja
configuration-snippet, server-snippet Filter oder EnvoyPatchPolicy – Einzelfall nein

Die nachbearbeitete Fassung routes-migrated.yaml hängt an unserem Gateway und ersetzt die Regex durch PathPrefix plus Rewrite:

yq -N 'select(.kind=="HTTPRoute") | .spec.rules[] | .name + ": "
  + .matches[0].path.type + " " + .matches[0].path.value + " | "
  + (.filters | map(.type) | join(","))' routes-migrated.yaml
yq -N 'select(.kind!="HTTPRoute") | .kind + " -> " + .spec.targetRefs[0].sectionName' \
  routes-migrated.yaml

Erwartet:

api: PathPrefix /api/v1 | URLRewrite,ResponseHeaderModifier
web: PathPrefix / | CORS
BackendTrafficPolicy -> web
SecurityPolicy -> api

Warum geht ReplacePrefixMatch: / statt /$2? Bei PathPrefix /api/v1 ersetzt der Filter genau dieses Präfix: /api/v1/orders → /orders, /api/v1 → /. Das deckt den häufigsten Capture-Group-Fall ab. PathPrefix vergleicht pfadelementweise: /api/v10 passt nicht – wie die alte Regex (/|$). Den configuration-snippet (more_set_headers) ersetzt ein ResponseHeaderModifier, die Policies zielen per sectionName auf die benannten Regeln api und web.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Parallelbetrieb und Vergleich

Die neue Route kommt dazu, der alte Controller bleibt unverändert. Weil DNS noch auf .110 zeigt, sieht kein Nutzer die neue Strecke.

kubectl apply -f routes-migrated.yaml
~/gw-lab/code/demo/conds.sh httproute legacy shop
~/gw-lab/code/demo/conds.sh securitypolicy legacy-api shop | head -2

Erwartet (gekürzt, kann je nach Version abweichen):

parent infra/web/http:
  Accepted=True (Accepted): Route is accepted
  ResolvedRefs=True (ResolvedRefs): Resolved all the Object references for the Route
parent infra/web/https:
  Accepted=True (Accepted): Route is accepted
  ResolvedRefs=True (ResolvedRefs): Resolved all the Object references for the Route
ancestor infra/web/:
  Accepted=True (Accepted): Policy has been accepted.

parallel-check.sh schickt dieselben Requests per --resolve an beide IPs und vergleicht Statuscode, den beim Backend angekommenen Pfad (echo-basic meldet ihn als .path) und den Header X-Legacy:

./parallel-check.sh

Erwartet (gekürzt, kann je nach Version abweichen):

✔ /  200|/|0
✔ /index.html  200|/index.html|0
✔ /api/v1/orders  200|/orders|1
✔ /api/v1  200|/|1
✘ /API/v1/orders  alt=200|/orders|1 neu=200|/API/v1/orders|0
✔ /api/v10  200|/api/v10|0

Ein echter Unterschied: ingress-nginx matcht mit use-regex case-insensitive (~*), Gateway API PathPrefix nicht. Ob Clients wirklich /API/... schicken, sagen dir die Access Logs des alten Controllers – meist ist es ein Fall für die Release Notes, nicht für eine Regex. Wenn doch: Challenge.

Achtung: Mit externalTrafficPolicy: Cluster sehen beide Controller als Quelle die Node-IP, nicht den Client. IP-Allowlists greifen dann ins Leere – auch beim alten Controller. Echte Client-IPs brauchen Local oder Proxy-Protocol/XFF (Tag 10).

Fortschritt speichern? Kostenlos registrieren

Drill 6: DNS umschalten und beobachten

Die Umschaltung ist das Löschen des spezifischen Eintrags – danach greift der Wildcard aus Tag 9 und zeigt auf 10.10.20.100. Vorher: TTL prüfen. Lokale dnsmasq-Einträge haben TTL 0, beim Kunden-DNS senkst du die TTL einen Tag vorher auf 60 Sekunden.

ssh pihole 'sudo rm /etc/dnsmasq.d/20-legacy.conf && sudo pihole reloaddns'
dig +short legacy.apps.lab.internal
curl -s -o /dev/null -w '%{http_code} %{remote_ip}\n' \
  https://legacy.apps.lab.internal/ --cacert ~/gw-lab/tag09/rke2-lab-ca.crt

Erwartet (gekürzt, kann je nach Version abweichen):

10.10.20.100
200 10.10.20.100

Bonus der Migration: HTTPS mit gültigem Zertifikat, das es vorher für diesen Host nicht gab. Jetzt beobachten – mit den Werkzeugen aus Tag 11. Neue Strecke:

curl -s localhost:9090/api/v1/query --data-urlencode \
  'query=sum by (envoy_cluster_name) (rate(envoy_cluster_upstream_rq_total{
   envoy_cluster_name=~"httproute/shop/legacy/.*"}[5m]))' \
  | jq -r '.data.result[] | "\(.metric.envoy_cluster_name) \(.value[1])"'

Erwartet (gekürzt, kann je nach Version abweichen):

httproute/shop/legacy/rule/0 0.4
httproute/shop/legacy/rule/1 2.1

Alte Strecke: Der Controller sollte nach Ablauf der TTLs keine Requests mehr sehen.

kubectl -n ingress-nginx logs deploy/legacy-ingress-nginx-controller --since=10m \
  | grep -c 'legacy.apps.lab.internal' || true

Erwartet (gekürzt, kann je nach Version abweichen):

0

Nicht 0? Dann haben Clients die IP fest eingetragen oder cachen DNS – die IPs stehen im Log, das sind deine Ansprechpartner vor dem Rückbau.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Rollback-Plan und Rückbau

Solange der alte Controller läuft, ist der Rollback eine Zeile DNS. Schreib ihn als Skript, bevor du ihn brauchst:

cat > ~/gw-lab/tag13/rollback.sh <<'EOF'
#!/usr/bin/env bash
# Rollback Tag 13: legacy.apps.lab.internal zurück auf ingress-nginx
set -euo pipefail
echo 'address=/legacy.apps.lab.internal/10.10.20.110' \
  | ssh pihole 'sudo tee /etc/dnsmasq.d/20-legacy.conf && sudo pihole reloaddns'
dig +short legacy.apps.lab.internal
EOF
chmod +x ~/gw-lab/tag13/rollback.sh

Die Regeln für den Rollback-Plan:

  • Alter Controller und Ingresses bleiben unverändert stehen, bis die Beobachtungsphase (z. B. zwei Wochen, ein Monatsabschluss) vorbei ist.
  • Die neue Route bleibt beim Rollback ebenfalls stehen – sie stört ohne DNS niemanden.
  • Rückbau erst, wenn der alte Controller über die ganze Phase keine Requests mehr hatte.

Rückbau, wenn es so weit ist:

kubectl -n shop delete ingress shop shop-canary shop-legacy-api
helm -n ingress-nginx uninstall legacy
kubectl delete namespace ingress-nginx
kubectl get ingressclass

Erwartet (gekürzt, kann je nach Version abweichen):

ingress.networking.k8s.io "shop" deleted
ingress.networking.k8s.io "shop-canary" deleted
ingress.networking.k8s.io "shop-legacy-api" deleted
release "legacy" uninstalled
namespace "ingress-nginx" deleted
No resources found

Die IP 10.10.20.110 geht zurück in den Cilium-Pool.

Fortschritt speichern? Kostenlos registrieren

Drill 8: Und wenn der Altbestand Traefik ist?

Auf RKE2 ab v1.36 ohne ingress-controller: none ist Traefik der Standard. Der Provider traefik kennt nur wenige Annotationen. Offline gegen traefik-ingress.yaml:

ingress2gateway print --providers=traefik --input-file traefik-ingress.yaml -A \
  --no-color 2>&1 >/dev/null | grep '^│' | grep -v 'source:\|object:' | cut -c1-86

Erwartet:

│  Gateway API does not support configuring URL normalization (RFC 3986, Section 6). P
│  parsed "traefik.ingress.kubernetes.io/router.tls" annotation: added HTTPS listener
│  parsed "traefik.ingress.kubernetes.io/router.entrypoints" annotation (value: "webse
│  added HTTP->HTTPS redirect HTTPRoute "shop/portal-portal-apps-lab-internal-http" bo
│  annotation "traefik.ingress.kubernetes.io/router.middlewares" (value: "shop-strip-a

router.entrypoints: websecure plus router.tls wird zu zwei Listenern und einer Redirect-Route (301). Middlewares (router.middlewares, CRD Middleware) übersetzt das Tool nicht – jede Middleware ist ein Filter oder eine Envoy-Gateway-Policy von Hand. Und: Das Secret portal-apps-lab-internal-tls ist nur ein Platzhalter; bei uns liefert der Wildcard-Listener das Zertifikat.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

Nach Drill 6, vor dem Rückbau:

cat > ~/gw-lab/tag13/check.sh <<'EOF'
#!/usr/bin/env bash
check() { if eval "$2" >/dev/null 2>&1; then echo "✔ $1"; else echo "✘ $1"; fi; }
H=legacy.apps.lab.internal
check "DNS zeigt auf Envoy Gateway"  "[ \$(dig +short $H) = 10.10.20.100 ]"
check "Route legacy Accepted" "kubectl -n shop get httproute legacy -o \
  jsonpath='{.status.parents[*].conditions[?(@.type==\"Accepted\")].status}' \
  | grep -qv False"
check "Rewrite /api/v1 -> /" \
  "curl -s http://$H/api/v1/orders | jq -e '.path==\"/orders\"'"
check "Header X-Legacy gesetzt" \
  "curl -sI http://$H/api/v1/ | grep -qi '^x-legacy: true'"
check "Canary 80/20 aktiv" "for i in \$(seq 40); do curl -s http://$H/ \
  | jq -r .service; done | grep -q shop-v2"
check "Alter Controller noch da (Rollback)" \
  "kubectl -n ingress-nginx get deploy legacy-ingress-nginx-controller"
check "Rollback-Skript bereit" "[ -x ~/gw-lab/tag13/rollback.sh ]"
EOF
chmod +x ~/gw-lab/tag13/check.sh && ~/gw-lab/tag13/check.sh

Erwartet (gekürzt, kann je nach Version abweichen):

✔ DNS zeigt auf Envoy Gateway
✔ Route legacy Accepted
✔ Rewrite /api/v1 -> /
✔ Header X-Legacy gesetzt
✔ Canary 80/20 aktiv
✔ Alter Controller noch da (Rollback)
✔ Rollback-Skript bereit

Challenge

Der Fachbereich besteht darauf: /API/v1/orders muss wie früher bei /orders ankommen. Bau die Regel api so um, dass sie case-insensitive matcht und mit Capture Group umschreibt – ohne die SecurityPolicy zu verlieren.

Hinweis: URLRewrite kann kein Regex; Envoy Gateway kann es über ein HTTPRouteFilter mit ReplaceRegexMatch, eingebunden per ExtensionRef.

Lösung

cat challenge-regex.yaml
kubectl apply -f challenge-regex.yaml
yq -i '(select(.kind=="HTTPRoute") | .spec.rules[] | select(.name=="api")) |= (
  .matches = [{"path": {"type": "RegularExpression", "value": "(?i)/api/v1(/.*)?"}}]
  | .filters[0] = {"type": "ExtensionRef", "extensionRef": {
      "group": "gateway.envoyproxy.io", "kind": "HTTPRouteFilter",
      "name": "api-regex-rewrite"}})' routes-migrated.yaml
kubectl apply -f routes-migrated.yaml
./parallel-check.sh | grep API

Erwartet (gekürzt, kann je nach Version abweichen):

# Challenge Tag 13: Rewrite mit Capture Group, case-insensitive wie ingress-nginx
apiVersion: gateway.envoyproxy.io/v1alpha1
kind: HTTPRouteFilter
metadata:
  name: api-regex-rewrite
  namespace: shop
spec:
  urlRewrite:
    path:
      type: ReplaceRegexMatch
      replaceRegexMatch:
        pattern: '(?i)^/api/v1(/|$)(.*)'
        substitution: '/\2'
httproutefilter.gateway.envoyproxy.io/api-regex-rewrite created
httproute.gateway.networking.k8s.io/legacy configured
✔ /API/v1/orders  200|/orders|1

Die Regel heißt weiter api, deshalb greift die SecurityPolicy mit sectionName: api unverändert. Der Preis: wieder eine Regex-Regel, deren Reihenfolge gegenüber anderen Regex-Routen implementierungsabhängig ist – dokumentieren.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • ingress-nginx ist retired: Bestandscluster ohne Migrationsplan sind ein Audit-Befund. Übergangsweise gibt es kommerziellen Extended Support (z. B. HeroDevs) oder den Wechsel auf F5s NGINX Ingress Controller – das Ziel bleibt Gateway API.
  • Migration pro Hostname, nicht pro Cluster: Inventur → Welle → Umschalten → Beobachten. Snippets und auth-* zuerst anschauen, das sind die teuren Fälle.
  • Konvertierte Manifeste ins Git der App-Teams, mit ingress2gateway --input-file als CI-Prüfung für noch nicht migrierte Ingresses.
  • Auf RKE2 nie zwei Besitzer der Gateway-API-CRDs: entweder Traefik-CRD-Chart oder Envoy Gateway (Tag 8, Tag 12).
  • Externe Abhängigkeiten mitmigrieren: Firewall-Regeln und Allowlists auf die neue LB-IP, Monitoring-Checks, WAF/CDN-Origin, Zertifikate mit SANs für alle Hosts.