Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 10: Ingress mit Gateway API

Ziel: Die App ist von außen per HTTPS erreichbar – einmal über ein Gateway außerhalb des Mesh, einmal über einen Proxy im Mesh – und du weißt, was das für mTLS und Policies bedeutet. · Dauer: ca. 75 min · Voraussetzung: Tag 9

Briefing

  • Linkerd bringt keinen Ingress mit. Es arbeitet mit dem Gateway oder Ingress-Controller, den du schon hast.
  • Variante A: Gateway außerhalb des Mesh – hier Cilium (Envoy auf jedem Node). Der erste Hop ins Mesh ist kein mTLS, das Ziel sieht nur eine IP. Policies brauchen dafür eine NetworkAuthentication.
  • Variante B: Ingress-Proxy im Mesh – ab dem Eingangs-Pod läuft alles mit mTLS und Identität.
  • Im Labor gibt es keine LoadBalancer-IPs; du erreichst beide über NodePorts.
  • Heute in tag10 mit eigener Kopie von web und notes-api.
 Laptop ─HTTPS─> cp1:NodePort ─> Cilium-Envoy ──Klartext──> web ─mTLS─> notes-api
 Laptop ─HTTPS─> cp1:30443 ───> edge (im Mesh) ──mTLS─────> web ─mTLS─> notes-api

Drill 1: Die App für heute

mkdir -p ~/linkerd/tag10 && cd ~/linkerd/tag10
kubectl create namespace tag10
kubectl annotate namespace tag10 linkerd.io/inject=enabled
cat > app.yaml <<'EOF'
apiVersion: v1
kind: ServiceAccount
metadata: {name: web, namespace: tag10}
---
apiVersion: v1
kind: ServiceAccount
metadata: {name: notes-api, namespace: tag10}
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: notes-api, namespace: tag10}
spec:
  replicas: 1
  selector: {matchLabels: {app: notes-api}}
  template:
    metadata: {labels: {app: notes-api}}
    spec:
      serviceAccountName: notes-api
      containers:
      - name: notes-api
        image: ghcr.io/thomaszachmann/notes-api:0.7.1
        env: [{name: NOTES_API_KEY, value: lab-key-123}]
        ports: [{containerPort: 8080, name: http}]
        readinessProbe:
          httpGet: {path: /healthz, port: http}
---
apiVersion: v1
kind: Service
metadata: {name: notes-api, namespace: tag10}
spec:
  selector: {app: notes-api}
  ports: [{port: 80, targetPort: http, name: http}]
---
apiVersion: v1
kind: ConfigMap
metadata: {name: web-conf, namespace: tag10}
data:
  default.conf: |
    server {
      listen 8080;
      location = / { default_type text/plain; return 200 "notes web\n"; }
      location /api/ {
        proxy_set_header X-API-Key lab-key-123;
        proxy_pass http://notes-api.tag10.svc.cluster.local/;
      }
    }
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: web, namespace: tag10}
spec:
  replicas: 1
  selector: {matchLabels: {app: web}}
  template:
    metadata: {labels: {app: web}}
    spec:
      serviceAccountName: web
      containers:
      - name: web
        image: docker.io/nginxinc/nginx-unprivileged:1.31.7-alpine
        ports: [{containerPort: 8080, name: http}]
        volumeMounts: [{name: conf, mountPath: /etc/nginx/conf.d}]
      volumes: [{name: conf, configMap: {name: web-conf}}]
---
apiVersion: v1
kind: Service
metadata: {name: web, namespace: tag10}
spec:
  selector: {app: web}
  ports: [{port: 80, targetPort: http, name: http}]
EOF
kubectl apply -f app.yaml
kubectl -n tag10 rollout status deploy --timeout=180s
kubectl -n tag10 get pods

Erwartet (gekürzt):

NAME                         READY   STATUS    RESTARTS   AGE
notes-api-7d55845b4f-cmmlx   2/2     Running   0          10s
web-7d94ccc84d-ngbvt         2/2     Running   0          10s

notes-api läuft ohne Datenbank mit einem Speicher im RAM – für heute reicht das.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Ein Gateway mit Cilium

kubectl get gatewayclass
cat > gateway.yaml <<'EOF'
apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata: {name: notes, namespace: tag10}
spec:
  gatewayClassName: cilium
  listeners:
  - {name: http, protocol: HTTP, port: 80}
---
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata: {name: web, namespace: tag10}
spec:
  parentRefs:
  - {name: notes}
  hostnames: [notes.lab.internal]
  rules:
  - backendRefs:
    - {name: web, port: 80}
EOF
kubectl apply -f gateway.yaml
sleep 15
kubectl -n tag10 get gateway notes
kubectl -n tag10 get svc cilium-gateway-notes

Erwartet (gekürzt):

NAME     CONTROLLER                     ACCEPTED   AGE
cilium   io.cilium/gateway-controller   True       12h
NAME    CLASS    ADDRESS   PROGRAMMED   AGE
notes   cilium             False        16s
NAME                   TYPE           CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
cilium-gateway-notes   LoadBalancer   10.99.157.141   <pending>     80:31972/TCP   16s

Der Parent ist jetzt ein Gateway, kein Service wie an Tag 9. Cilium legt dafür einen Service vom Typ LoadBalancer an. Die IP bleibt <pending>: Cilium könnte sie vergeben (LB-IPAM ist an), aber im Labor gibt es keinen IP-Pool und keine L2-Ankündigung. PROGRAMMED False heißt genau das (AddressNotAssigned). Jeder LoadBalancer-Service hat aber auch einen NodePort – der reicht fürs Labor:

NP=$(kubectl -n tag10 get svc cilium-gateway-notes \
  -o jsonpath='{.spec.ports[?(@.port==80)].nodePort}')
curl -s -i -H 'Host: notes.lab.internal' http://172.16.0.126:$NP/ | head -2
curl -s -H 'Host: notes.lab.internal' http://172.16.0.228:$NP/api/notes; echo
curl -s -o /dev/null -w '%{http_code}\n' http://172.16.0.126:$NP/

Erwartet:

HTTP/1.1 200 OK
server: envoy
[]
404

Jeder Node nimmt den NodePort an, auch worker1. Ohne passenden Host-Header antwortet Envoy mit 404 – die Route gilt nur für notes.lab.internal.

Wer bedient welche Route? Das entscheidet der parentRef:

kubectl -n tag10 get httproute web \
  -o jsonpath='{.status.parents[*].controllerName}{"\n"}'
kubectl -n tag10 get endpointslices -l io.cilium.gateway/owning-gateway=notes

Erwartet:

io.cilium/gateway-controller
NAME                   ADDRESSTYPE   PORTS   ENDPOINTS         AGE
cilium-gateway-notes   IPv4          9999    192.192.192.192   16s
parentRef wer setzt um wo
Gateway notes Cilium Envoy auf dem Node, Nord-Süd
Service (Tag 9) Linkerd und Cilium Client-Proxy bzw. Envoy, Ost-West

Diese Route kennt nur Cilium; Linkerd ignoriert Routen mit Gateway-Parent. Die EndpointSlice mit 192.192.192.192:9999 ist Ciliums Platzhalter für den Gateway-Service und gehört dem Gateway – sie verschwindet mit ihm. Anders bei Routen mit Service-Parent: Dort bleibt sie nach dem Löschen der Route liegen (Tag 9, Drill 7).

Fortschritt speichern? Kostenlos registrieren

Drill 3: HTTPS mit cert-manager

Eine kleine Labor-CA in tag10, daraus ein Zertifikat für notes.lab.internal:

cat > tls.yaml <<'EOF'
apiVersion: cert-manager.io/v1
kind: Issuer
metadata: {name: selfsigned, namespace: tag10}
spec:
  selfSigned: {}
---
apiVersion: cert-manager.io/v1
kind: Certificate
metadata: {name: lab-ca, namespace: tag10}
spec:
  isCA: true
  commonName: lab-ca.tag10
  secretName: lab-ca
  privateKey: {algorithm: ECDSA, size: 256}
  issuerRef: {name: selfsigned, kind: Issuer}
---
apiVersion: cert-manager.io/v1
kind: Issuer
metadata: {name: lab-ca, namespace: tag10}
spec:
  ca: {secretName: lab-ca}
---
apiVersion: cert-manager.io/v1
kind: Certificate
metadata: {name: notes-tls, namespace: tag10}
spec:
  secretName: notes-tls
  dnsNames: [notes.lab.internal]
  duration: 720h
  privateKey: {algorithm: ECDSA, size: 256}
  issuerRef: {name: lab-ca, kind: Issuer}
EOF
kubectl apply -f tls.yaml
kubectl -n tag10 wait --for=condition=Ready certificate --all --timeout=60s
cat > gateway-tls.yaml <<'EOF'
apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata: {name: notes, namespace: tag10}
spec:
  gatewayClassName: cilium
  listeners:
  - {name: http, protocol: HTTP, port: 80}
  - name: https
    protocol: HTTPS
    port: 443
    hostname: notes.lab.internal
    tls:
      mode: Terminate
      certificateRefs: [{name: notes-tls}]
EOF
kubectl apply -f gateway-tls.yaml
sleep 15
kubectl -n tag10 get svc cilium-gateway-notes

Erwartet (gekürzt):

certificate.cert-manager.io/lab-ca condition met
certificate.cert-manager.io/notes-tls condition met
gateway.gateway.networking.k8s.io/notes configured
NAME                   TYPE           ...   EXTERNAL-IP   PORT(S)
cilium-gateway-notes   LoadBalancer   ...   <pending>     80:31972/TCP,443:32290/TCP

Die Route aus Drill 2 hängt ohne sectionName an beiden Listenern. Jetzt mit der CA prüfen statt mit -k:

kubectl -n tag10 get secret lab-ca -o jsonpath='{.data.ca\.crt}' | base64 -d \
  > lab-ca.crt
NP=$(kubectl -n tag10 get svc cilium-gateway-notes \
  -o jsonpath='{.spec.ports[?(@.port==443)].nodePort}')
G="--cacert lab-ca.crt --resolve notes.lab.internal:$NP:172.16.0.126 \
https://notes.lab.internal:$NP"
curl -s -w ' %{http_code}\n' $G/api/notes
curl -sv $G/ 2>&1 | grep -E 'SSL connection|issuer:|^< server'

Erwartet:

[]
 200
* SSL connection using TLSv1.3 / TLS_AES_256_GCM_SHA384 / X25519 / id-ecPublicKey
*  issuer: CN=lab-ca.tag10
< server: envoy

Vom Laptop aus geht es genauso – CA holen, dann curl mit derselben Adresse:

scp [email protected]:linkerd/tag10/lab-ca.crt .
curl -s -w ' %{http_code}\n' --cacert lab-ca.crt \
  --resolve notes.lab.internal:32290:172.16.0.126 \
  https://notes.lab.internal:32290/api/notes

Erwartet:

[]
 200

Setz statt 32290 deinen NodePort ein. Cilium liest das Secret notes-tls selbst und spiegelt es nach cilium-secrets – ein Neustart ist nicht nötig.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Was das Mesh davon sieht

timeout 20 linkerd viz tap -n tag10 deploy/web --path /api/notes > tap.txt &
sleep 3
for i in 1 2 3; do curl -s -o /dev/null $G/api/notes; done
wait
head -2 tap.txt
kubectl get ciliumnodes \
  -o jsonpath='{range .items[*]}{.metadata.name} {.spec.ingress.ipv4}{"\n"}{end}'

Erwartet (gekürzt):

req id=0:0 proxy=in  src=10.0.0.235:41865 dst=10.0.1.28:8080 tls=no_tls_from_remote ...
rsp id=0:0 proxy=in  src=10.0.0.235:41865 dst=10.0.1.28:8080 tls=no_tls_from_remote ...
cp1 10.0.0.235
worker1 10.0.1.169
worker2 10.0.2.57

tls=no_tls_from_remote: Der Request kam im Klartext, ohne Identität. Absender ist keine Pod-IP, sondern die Ingress-IP von Cilium auf cp1 – der Node, auf dem der NodePort getroffen wurde. Jeder Node hat eine eigene. Das Gateway selbst kannst du nicht ins Mesh holen: Ciliums Envoy läuft als DaemonSet cilium-envoy im Host-Netz, nicht als Pod mit Sidecar.

Achtung: Der Weg Laptop → Envoy ist TLS, Envoy → web ist Klartext über das Pod-Netz. Ab web übernimmt Linkerd. Brauchst du Verschlüsselung bis zum ersten Pod, ist das ein Argument für Variante B.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Das Gateway in die Policy aufnehmen

Ab Tag 6 kennst du Server und AuthorizationPolicy. Ein Server ohne Policy sperrt alles:

cat > server.yaml <<'EOF'
apiVersion: policy.linkerd.io/v1beta3
kind: Server
metadata: {name: web-http, namespace: tag10}
spec:
  podSelector: {matchLabels: {app: web}}
  port: http
EOF
kubectl apply -f server.yaml
sleep 5
curl -s -w ' %{http_code}\n' $G/api/notes

Erwartet:

server.policy.linkerd.io/web-http created
 403

Eine MeshTLSAuthentication hilft hier nicht – Envoy hat keine Identität. Bleibt die Absender-IP. Trag die Ingress-IPs aus Drill 4 ein:

cat > authz-gateway.yaml <<'EOF'
apiVersion: policy.linkerd.io/v1alpha1
kind: NetworkAuthentication
metadata: {name: cilium-ingress, namespace: tag10}
spec:
  networks:
  - cidr: 10.0.0.235/32
  - cidr: 10.0.1.169/32
  - cidr: 10.0.2.57/32
---
apiVersion: policy.linkerd.io/v1alpha1
kind: AuthorizationPolicy
metadata: {name: web-from-gateway, namespace: tag10}
spec:
  targetRef: {group: policy.linkerd.io, kind: Server, name: web-http}
  requiredAuthenticationRefs:
  - {group: policy.linkerd.io, kind: NetworkAuthentication, name: cilium-ingress}
EOF
kubectl apply -f authz-gateway.yaml
sleep 5
curl -s -w ' %{http_code}\n' $G/api/notes
kubectl -n tag10 run ohne --image=curlimages/curl:8.23.0 --restart=Never \
  --annotations=linkerd.io/inject=disabled --command -- sleep 3600
kubectl -n tag10 wait --for=condition=Ready pod/ohne --timeout=60s
kubectl -n tag10 exec ohne -- curl -s -w ' %{http_code}\n' http://web/api/notes

Erwartet:

networkauthentication.policy.linkerd.io/cilium-ingress created
authorizationpolicy.policy.linkerd.io/web-from-gateway created
[]
 200
pod/ohne created
pod/ohne condition met
 403

Das Gateway kommt durch, ein Pod ohne Proxy direkt auf web nicht. Der Preis: Die Regel hängt an IP-Adressen. Kommt ein Node dazu, braucht die Liste einen Eintrag – ein ganzes Pod-CIDR einzutragen würde jeden Pod ohne Proxy hereinlassen.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Ein Ingress-Proxy im Mesh

Variante B: ein nginx als Eingang, mit Proxy, TLS mit demselben Secret, per NodePort 30443 erreichbar:

cat > edge.yaml <<'EOF'
apiVersion: v1
kind: ServiceAccount
metadata: {name: edge, namespace: tag10}
---
apiVersion: v1
kind: ConfigMap
metadata: {name: edge-conf, namespace: tag10}
data:
  default.conf: |
    server {
      listen 8443 ssl;
      server_name notes.lab.internal;
      ssl_certificate     /tls/tls.crt;
      ssl_certificate_key /tls/tls.key;
      location / {
        proxy_pass http://web.tag10.svc.cluster.local;
      }
    }
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: edge, namespace: tag10}
spec:
  replicas: 1
  selector: {matchLabels: {app: edge}}
  template:
    metadata: {labels: {app: edge}}
    spec:
      serviceAccountName: edge
      containers:
      - name: nginx
        image: docker.io/nginxinc/nginx-unprivileged:1.31.7-alpine
        ports: [{containerPort: 8443, name: https}]
        volumeMounts:
        - {name: conf, mountPath: /etc/nginx/conf.d}
        - {name: tls, mountPath: /tls, readOnly: true}
      volumes:
      - {name: conf, configMap: {name: edge-conf}}
      - {name: tls, secret: {secretName: notes-tls}}
---
apiVersion: v1
kind: Service
metadata: {name: edge, namespace: tag10}
spec:
  type: NodePort
  selector: {app: edge}
  ports: [{port: 443, targetPort: https, nodePort: 30443, name: https}]
EOF
kubectl apply -f edge.yaml
kubectl -n tag10 rollout status deploy/edge --timeout=120s
sleep 10
E="--cacert lab-ca.crt --resolve notes.lab.internal:30443:172.16.0.126 \
https://notes.lab.internal:30443"
curl -s -w ' %{http_code}\n' $E/api/notes

Erwartet:

deployment "edge" successfully rolled out
 403

Richtig so: web lässt nur das Gateway herein. edge hat aber eine Identität – die Freigabe läuft deshalb über mTLS statt über IPs:

cat > authz-edge.yaml <<'EOF'
apiVersion: policy.linkerd.io/v1alpha1
kind: MeshTLSAuthentication
metadata: {name: edge, namespace: tag10}
spec:
  identityRefs:
  - {kind: ServiceAccount, name: edge}
---
apiVersion: policy.linkerd.io/v1alpha1
kind: AuthorizationPolicy
metadata: {name: web-from-edge, namespace: tag10}
spec:
  targetRef: {group: policy.linkerd.io, kind: Server, name: web-http}
  requiredAuthenticationRefs:
  - {group: policy.linkerd.io, kind: MeshTLSAuthentication, name: edge}
EOF
kubectl apply -f authz-edge.yaml
sleep 5
for i in $(seq 20); do curl -s -o /dev/null -w '%{http_code}\n' $E/api/notes; done \
  | sort | uniq -c

Erwartet:

     20 200

nginx spricht den Service web an. Der Proxy im edge-Pod erkennt das Ziel, macht Load Balancing, mTLS und – mit HTTPRoutes – Retries und Canaries wie für jeden anderen Client. Controller, die selbst Endpunkte auswählen, brauchen dafür linkerd.io/inject: ingress (siehe Enterprise-Notiz).

Fortschritt speichern? Kostenlos registrieren

Drill 7: Beide Eingänge im Vergleich

for i in $(seq 90); do
  curl -s -o /dev/null $E/api/notes; curl -s -o /dev/null $G/api/notes; sleep 0.5
done
linkerd viz edges -n tag10 deploy
linkerd viz authz -n tag10 deploy/web | grep -E 'ROUTE|web-http'

Erwartet (gekürzt, Zahlen schwanken):

SRC    DST         SRC_NS   DST_NS   SECURED
edge   web         tag10    tag10    √
web    notes-api   tag10    tag10    √
ROUTE    SERVER    AUTHORIZATION                         UNAUTHORIZED  SUCCESS     RPS
default  web-http  authorizationpolicy/web-from-edge           0.0rps  100.00%  1.5rps
default  web-http  authorizationpolicy/web-from-gateway        0.0rps  100.00%  1.5rps

Beide Wege tragen gleich viel Verkehr, aber nur einer ist eine Kante im Mesh: Für edges existiert das Gateway nicht. authz zeigt, welche Policy welchen Verkehr durchlässt – das ist dein Nachweis für Variante A.

Fortschritt speichern? Kostenlos registrieren

Übung: Speed-Drills

  1. Zeig die beiden NodePorts des Gateways. Zeitziel: 20 s
  2. Zeig, wann notes-tls abläuft und wann cert-manager es erneuert. Zeitziel: 30 s
  3. Zeig den Aussteller des Zertifikats, das edge ausliefert. Zeitziel: 45 s
  4. Zeig, welche Policies den Verkehr auf web zulassen. Zeitziel: 15 s

Lösung

kubectl -n tag10 get svc cilium-gateway-notes \
  -o jsonpath='{.spec.ports[*].nodePort}{"\n"}'
kubectl -n tag10 get certificate notes-tls \
  -o jsonpath='{.status.notAfter} {.status.renewalTime}{"\n"}'
echo | openssl s_client -connect 172.16.0.126:30443 -servername notes.lab.internal \
  2>/dev/null | openssl x509 -noout -issuer
linkerd viz authz -n tag10 deploy/web

Erwartet (Auszug):

31972 32290
2026-12-19T16:29:52Z 2026-12-09T16:29:52Z
issuer=CN = lab-ca.tag10

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

curl -s -o /dev/null -w '%{http_code}\n' $G/api/notes
curl -s -o /dev/null -w '%{http_code}\n' $E/api/notes

Erwartet: zweimal 200.

kubectl -n tag10 exec ohne -- curl -s -o /dev/null -w '%{http_code}\n' http://web/

Erwartet: 403

linkerd viz edges -n tag10 deploy | grep edge

Erwartet: edge web tag10 tag10 √

Challenge

Erneuere notes-tls mit cmctl renew und prüf mit openssl, welcher der beiden Eingänge ($NP aus Drill 3 und 30443) das neue Zertifikat sofort ausliefert. Bring den anderen dazu, es ebenfalls zu tun.

Hinweis: Vergleiche die Seriennummern; nginx liest Zertifikate nur beim Start.

Lösung

cmctl renew -n tag10 notes-tls
kubectl -n tag10 wait --for=condition=Ready certificate/notes-tls
sleep 10
for p in $NP 30443; do
  echo | openssl s_client -connect 172.16.0.126:$p -servername notes.lab.internal \
    2>/dev/null | openssl x509 -noout -serial
done
kubectl -n tag10 rollout restart deploy/edge
kubectl -n tag10 rollout status deploy/edge
echo | openssl s_client -connect 172.16.0.126:30443 -servername notes.lab.internal \
  2>/dev/null | openssl x509 -noout -serial

Erwartet (Seriennummern abweichend):

Manually triggered issuance of Certificate tag10/notes-tls
serial=2A1C7A9FB13DCC28AFD893690D4229F7F6E2CB1D
serial=716A09D2B37D8E82BA2C8C87F6C32E746E9AEE05
deployment "edge" successfully rolled out
serial=2A1C7A9FB13DCC28AFD893690D4229F7F6E2CB1D

Cilium beobachtet das Secret und liefert sofort das neue Zertifikat aus. Der kubelet aktualisiert zwar das gemountete Secret in edge nach ein bis zwei Minuten, nginx liest es aber nicht neu. Ein echter Ingress-Controller beobachtet Secrets selbst; ein selbstgebauter Eingang braucht einen Reload – oder läuft beim nächsten Ablauf ins Leere.

Fortschritt speichern? Kostenlos registrieren

Aufräumen

kubectl delete namespace tag10

Interview-Notiz

  • Muss der Ingress im Mesh sein? Nein, aber nur dann gibt es ab dem ersten Pod mTLS, Identität für Policies und Linkerd-Metriken pro Kante.
  • Wie lässt du ein Gateway außerhalb des Mesh durch eine Default-Deny-Policy? Mit einer NetworkAuthentication auf die Absender-IPs des Gateways – und nur diese.
  • Was ist der Ingress-Modus? linkerd.io/inject: ingress lässt den Proxy das Ziel aus dem Header l5d-dst-override oder dem Host lesen – für Controller, die selbst Endpunkte auswählen.

Enterprise-Notiz

  • In Produktion bekommt das Gateway eine echte LoadBalancer-IP (Cilium LB-IPAM mit L2/BGP, MetalLB oder Cloud-LB) und ein Zertifikat aus ACME oder der Firmen-CA.
  • Gängige Controller im Mesh: Envoy Gateway, Traefik, Contour, Emissary. Jeder Controller hat in der Linkerd-Doku („Handling ingress traffic“) eigene Hinweise.
  • Im Ingress-Modus muss der Controller l5d-dst-override aus Client-Requests entfernen – sonst wird er zum offenen Relay in den Cluster.
  • Die Annotation ingress gehört an das Deployment des Controllers, nicht an den Namespace.
  • Der Weg Gateway → Pod ohne mTLS ist für viele Prüfer ein Befund. Ein Gateway außerhalb des Mesh braucht dann Verschlüsselung zum Backend (BackendTLSPolicy) oder Variante B.