Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 11: TLS für die Gateway API

Ziel: Du baust mit cert-manager eine eigene CA, terminierst HTTPS am Gateway für mehrere Hostnamen, leitest HTTP auf HTTPS um, erneuerst Zertifikate im laufenden Betrieb und verschlüsselst auch die Strecke vom Gateway zum Backend. · Dauer: ca. 90 min · Voraussetzung: Tag 10 (Gateway-API-CRDs, Controller an)

Briefing

  • CKNE: Advanced Traffic Management – Gateway API mit TLS; dazu Network Security (Verschlüsselung auf dem Weg zum Backend).
  • Ein HTTPS-Listener verweist per certificateRefs auf ein Secret vom Typ kubernetes.io/tls. Woher es kommt, ist dem Gateway egal – hier von cert-manager.
  • cert-manager-Kette: selfSigned-Issuer → CA-Zertifikat → ca-Issuer → beliebig viele Server-Zertifikate.
  • Cilium kopiert benutzte Secrets in den Namespace cilium-secrets, Envoy lädt sie ohne Neustart nach.
 curl (SNI shop/api) ──TLS──> Gateway web :443 ──HTTP──> echo:8080
                    └─HTTP──> Gateway web :80  ──301──> https://…
                                    :443 /secure ──TLS (BackendTLSPolicy)──> secure:443
 ClusterIssuer tag11-selfsigned ─> Certificate lab-ca ─> ClusterIssuer tag11-ca
                                                          └─> shop-tls, api-tls, …

Drill 1: cert-manager installieren

Aktuell ist cert-manager v1.21.3. Das Chart liegt als OCI-Artefakt; die Gateway-API-Integration ist ein Konfigurationsschalter des Controllers:

mkdir -p ~/ckne/tag11 && cd ~/ckne/tag11
helm install cert-manager oci://quay.io/jetstack/charts/cert-manager \
  --version v1.21.3 -n cert-manager --create-namespace \
  --set crds.enabled=true \
  --set config.apiVersion=controller.config.cert-manager.io/v1alpha1 \
  --set config.kind=ControllerConfiguration \
  --set config.gatewayAPI.enabled=true
k -n cert-manager rollout status deploy
k -n cert-manager get pods
k -n cert-manager logs deploy/cert-manager | grep -o '"enabling the sig-network.*"'

Erwartet (gekürzt):

Pulled: quay.io/jetstack/charts/cert-manager:v1.21.3
STATUS: deployed
deployment "cert-manager" successfully rolled out
deployment "cert-manager-cainjector" successfully rolled out
deployment "cert-manager-webhook" successfully rolled out
NAME                                       READY   STATUS    RESTARTS   AGE
cert-manager-78dd6bb79c-vbnml              1/1     Running   0          20s
cert-manager-cainjector-557444dc8d-8cv8s   1/1     Running   0          20s
cert-manager-webhook-bf7f8b575-4wt5m       1/1     Running   0          20s
"enabling the sig-network Gateway API certificate-shim and HTTP-01 solver" logger="cert-
manager"

Dazu die CLI cmctl (Erneuern, Status) – als einzelne Binärdatei pro Architektur:

ARCH=$(dpkg --print-architecture)
CM=https://github.com/cert-manager/cmctl/releases/download/v2.6.2
curl -fsSLO $CM/cmctl_linux_${ARCH}
curl -fsSL $CM/checksums.txt | grep " cmctl_linux_${ARCH}$" | sha256sum -c
sudo install -m 0755 cmctl_linux_${ARCH} /usr/local/bin/cmctl
cmctl check api

Erwartet:

cmctl_linux_amd64: OK
The cert-manager API is ready

Fortschritt speichern? Kostenlos registrieren

Drill 2: Eigene CA

Ein selfSigned-Issuer unterschreibt nur sich selbst – genau richtig für das eine CA-Zertifikat. Ein ClusterIssuer liest Secrets aus dem Namespace cert-manager, deshalb liegt die CA dort:

k create namespace tag11
k config set-context --current --namespace=tag11
cat > ca.yaml <<'EOF'
apiVersion: cert-manager.io/v1
kind: ClusterIssuer
metadata:
  name: tag11-selfsigned
spec:
  selfSigned: {}
---
apiVersion: cert-manager.io/v1
kind: Certificate
metadata:
  name: lab-ca
  namespace: cert-manager
spec:
  isCA: true
  commonName: CKNE Lab CA
  secretName: lab-ca
  duration: 87600h
  privateKey:
    algorithm: ECDSA
    size: 256
  issuerRef:
    name: tag11-selfsigned
    kind: ClusterIssuer
---
apiVersion: cert-manager.io/v1
kind: ClusterIssuer
metadata:
  name: tag11-ca
spec:
  ca:
    secretName: lab-ca
EOF
k apply -f ca.yaml
k -n cert-manager wait --for=condition=Ready certificate lab-ca
k get clusterissuer
k -n cert-manager get secret lab-ca -o jsonpath='{.data.tls\.crt}' | base64 -d \
  | openssl x509 -noout -subject -issuer -enddate

Erwartet:

clusterissuer.cert-manager.io/tag11-selfsigned created
certificate.cert-manager.io/lab-ca created
clusterissuer.cert-manager.io/tag11-ca created
certificate.cert-manager.io/lab-ca condition met
NAME               READY   AGE
tag11-ca           True    0s
tag11-selfsigned   True    0s
subject=CN = CKNE Lab CA
issuer=CN = CKNE Lab CA
notAfter=Nov 15 23:54:08 2036 GMT

Subject gleich Issuer: selbst signiert, zehn Jahre gültig.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Zertifikat und HTTPS-Listener

Backend und NodePort-GatewayClass wie in Tag 10 (Begründung dort):

cp ~/ckne/tag10/echo.yaml .
k apply -f echo.yaml
k expose deployment echo-v1 --name=echo --port=8080 --target-port=3000
cat > nodeport.yaml <<'EOF'
apiVersion: cilium.io/v2alpha1
kind: CiliumGatewayClassConfig
metadata:
  name: nodeport
spec:
  service:
    type: NodePort
---
apiVersion: gateway.networking.k8s.io/v1
kind: GatewayClass
metadata:
  name: tag11-nodeport
spec:
  controllerName: io.cilium/gateway-controller
  parametersRef:
    group: cilium.io
    kind: CiliumGatewayClassConfig
    name: nodeport
    namespace: tag11
EOF
k apply -f nodeport.yaml

Das Server-Zertifikat – bewusst kurz gültig, damit Drill 6 etwas zu erneuern hat:

cat > cert-shop.yaml <<'EOF'
apiVersion: cert-manager.io/v1
kind: Certificate
metadata:
  name: shop
spec:
  secretName: shop-tls
  dnsNames:
  - shop.example.com
  duration: 24h
  renewBefore: 8h
  issuerRef:
    name: tag11-ca
    kind: ClusterIssuer
EOF
k apply -f cert-shop.yaml
k wait --for=condition=Ready certificate shop
k get certificate,certificaterequest
k get secret shop-tls -o jsonpath='{.data.tls\.crt}' | base64 -d \
  | openssl x509 -noout -issuer -ext subjectAltName -dates

Erwartet (gekürzt):

certificate.cert-manager.io/shop condition met
NAME                               READY   SECRET     AGE
certificate.cert-manager.io/shop   True    shop-tls   1s
NAME                                        APPROVED   DENIED   READY   ISSUER     ...
certificaterequest.cert-manager.io/shop-1   True                True    tag11-ca   ...
issuer=CN = CKNE Lab CA
X509v3 Subject Alternative Name: critical
    DNS:shop.example.com
notBefore=Nov 18 23:54:33 2026 GMT
notAfter=Nov 19 23:54:33 2026 GMT

Nun das Gateway mit zwei Listenern. tls.mode: Terminate heißt: Envoy entschlüsselt, das Backend sieht HTTP. Die Route hängt per sectionName nur am HTTPS-Listener:

cat > gw.yaml <<'EOF'
apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata:
  name: web
spec:
  gatewayClassName: tag11-nodeport
  listeners:
  - name: http
    protocol: HTTP
    port: 80
  - name: https-shop
    protocol: HTTPS
    port: 443
    hostname: shop.example.com
    tls:
      mode: Terminate
      certificateRefs:
      - name: shop-tls
EOF
cat > route-shop.yaml <<'EOF'
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: shop
spec:
  parentRefs:
  - name: web
    sectionName: https-shop
  hostnames:
  - shop.example.com
  rules:
  - backendRefs:
    - name: echo
      port: 8080
EOF
k apply -f gw.yaml -f route-shop.yaml
k wait --for=condition=Programmed gateway web
k get svc cilium-gateway-web
k -n cilium-secrets get secrets

Erwartet (gekürzt):

gateway.gateway.networking.k8s.io/web condition met
NAME                 TYPE       CLUSTER-IP     EXTERNAL-IP   PORT(S)
cilium-gateway-web   NodePort   10.103.44.25   <none>        80:32739/TCP,443:31589/TCP
NAME                                                    TYPE                DATA   AGE
cilium-sync-secret-1b5fe3bec1b1e9fc34e4350baee3d9c...   kubernetes.io/tls   3      2s

Testen mit SNI: --resolve lässt curl shop.example.com auf die Node-IP auflösen und schickt den Namen im TLS-Handshake mit. Das CA-Zertifikat steht in ca.crt jedes ausgestellten Secrets:

NPS=$(k get svc cilium-gateway-web -o jsonpath='{.spec.ports[?(@.port==443)].nodePort}')
NPH=$(k get svc cilium-gateway-web -o jsonpath='{.spec.ports[?(@.port==80)].nodePort}')
k get secret shop-tls -o jsonpath='{.data.ca\.crt}' | base64 -d > ca.crt
R="--resolve shop.example.com:$NPS:172.16.0.228"
curl -s $R https://shop.example.com:$NPS/; echo "exit=$?"
curl -s $R --cacert ca.crt https://shop.example.com:$NPS/ | grep -E '"(host|pod)"'
curl -sv $R --cacert ca.crt https://shop.example.com:$NPS/ -o /dev/null 2>&1 \
  | grep -E 'SSL connection|subjectAltName|issuer:'

Erwartet:

exit=60
 "host": "shop.example.com:31589",
 "pod": "echo-v1-5dbcd994f5-rxm7p"
* SSL connection using TLSv1.3 / TLS_AES_256_GCM_SHA384 / X25519 / RSASSA-PSS
*  subjectAltName: host "shop.example.com" matched cert's "shop.example.com"
*  issuer: CN=CKNE Lab CA

Exit 60 heißt: Zertifikat nicht prüfbar – curl kennt die Lab-CA nicht. Mit --cacert klappt die Kette.

Fortschritt speichern? Kostenlos registrieren

Drill 4: HTTP auf HTTPS umleiten

curl -s -o /dev/null -w '%{http_code}\n' -H 'Host: shop.example.com' \
  http://172.16.0.228:$NPH/
cat > route-redirect.yaml <<'EOF'
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: to-https
spec:
  parentRefs:
  - name: web
    sectionName: http
  rules:
  - filters:
    - type: RequestRedirect
      requestRedirect:
        scheme: https
        statusCode: 301
EOF
k apply -f route-redirect.yaml
curl -si -H 'Host: shop.example.com' http://172.16.0.228:$NPH/cart \
  | grep -iE '^HTTP|^location'

Erwartet:

404
httproute.gateway.networking.k8s.io/to-https created
HTTP/1.1 301 Moved Permanently
location: https://shop.example.com:443/cart

Ohne hostnames gilt die Redirect-Route für jeden Host am Listener http. Pfad und Host bleiben, nur Schema und Port wechseln. Im Labor erreichst du 443 nur über den NodePort – mit echter LB-IP (Tag 15) folgt curl -L direkt.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Mehrere Hostnamen per SNI

Zweites Zertifikat, zweiter HTTPS-Listener auf demselben Port 443 – Envoy wählt das Zertifikat anhand des SNI-Namens:

sed -e 's/name: shop$/name: api/' -e 's/shop-tls/api-tls/' \
  -e 's/shop.example.com/api.example.com/' cert-shop.yaml > cert-api.yaml
cat >> gw.yaml <<'EOF'
  - name: https-api
    protocol: HTTPS
    port: 443
    hostname: api.example.com
    tls:
      mode: Terminate
      certificateRefs:
      - name: api-tls
EOF
sed -e 's/name: shop$/name: api/' -e 's/https-shop/https-api/' \
  -e 's/shop.example.com/api.example.com/' route-shop.yaml > route-api.yaml
k apply -f cert-api.yaml -f gw.yaml -f route-api.yaml
k wait --for=condition=Ready certificate api
for h in shop api; do
  openssl s_client -connect 172.16.0.228:$NPS -servername $h.example.com \
    -CAfile ca.crt </dev/null 2>/dev/null | grep 'Verify return code'
  openssl s_client -connect 172.16.0.228:$NPS -servername $h.example.com \
    </dev/null 2>/dev/null | openssl x509 -noout -ext subjectAltName | tail -1
done
curl -sS --cacert ca.crt --resolve other.example.com:$NPS:172.16.0.228 \
  https://other.example.com:$NPS/; echo "exit=$?"

Erwartet:

certificate.cert-manager.io/api created
gateway.gateway.networking.k8s.io/web configured
httproute.gateway.networking.k8s.io/api created
certificate.cert-manager.io/api condition met
Verify return code: 0 (ok)
    DNS:shop.example.com
Verify return code: 0 (ok)
    DNS:api.example.com
curl: (35) Recv failure: Connection reset by peer
exit=35

Ein unbekannter SNI-Name trifft keinen Listener – Envoy bricht den Handshake ab, statt ein falsches Zertifikat zu zeigen. Ein Wildcard-Zertifikat (*.example.com) auf einem Listener ohne hostname wäre die Alternative.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Zertifikat erneuern

cert-manager erneuert selbst, sobald renewalTime erreicht ist (Ablauf minus renewBefore). Für Tests oder nach einem Schlüssel-Leck stößt cmctl renew sofort an:

k get certificate shop -o jsonpath='{.status.revision} {.status.renewalTime}{"\n"}'
openssl s_client -connect 172.16.0.228:$NPS -servername shop.example.com \
  </dev/null 2>/dev/null | openssl x509 -noout -serial
cmctl renew shop
k wait --for=condition=Ready certificate shop
k get certificaterequest
k get certificate shop -o jsonpath='{.status.revision}{"\n"}'
openssl s_client -connect 172.16.0.228:$NPS -servername shop.example.com \
  </dev/null 2>/dev/null | openssl x509 -noout -serial
cmctl status certificate shop | grep -E 'Generated|Requested'

Erwartet (gekürzt):

1 2026-11-19T15:54:33Z
serial=5085F82A41E8965AB8D3A22B3B1CFCBAE928D8CF
Manually triggered issuance of Certificate tag11/shop
certificate.cert-manager.io/shop condition met
NAME     APPROVED   DENIED   READY   ISSUER     ...
api-1    True                True    tag11-ca   ...
shop-2   True                True    tag11-ca   ...
2
serial=4405D4DC31312314DE1E8D98B782310D4FBADF12
  Normal  Generated  95s  cert-manager-certificates-key-manager      Stored new ...
  Normal  Requested  95s  cert-manager-certificates-request-manager  Created new ...
  Normal  Generated  17s  cert-manager-certificates-key-manager      Stored new ...
  Normal  Requested  17s  cert-manager-certificates-request-manager  Created new ...

Neue Seriennummer, neuer privater Schlüssel (Standard rotationPolicy: Always), und Envoy liefert das neue Zertifikat schon beim nächsten Handshake – kein Neustart, kein Verbindungsabbruch für bestehende Clients.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Falsches Secret, fremder Namespace

Erst ein Tippfehler im Secret-Namen am Listener https-shop (Index 1):

LC='{range .status.listeners[*]}{.name}: {.conditions[?(@.type=="Programmed")].status}'\
' {.conditions[?(@.type=="ResolvedRefs")].reason}{"\n"}{end}'
k patch gateway web --type=json -p '[{"op":"replace",
 "path":"/spec/listeners/1/tls/certificateRefs/0/name","value":"shop-tsl"}]'
k get gateway web -o jsonpath="$LC"
k get gateway web
k get gateway web -o \
  jsonpath='{.status.listeners[1].conditions[?(@.type=="Accepted")].message}'
echo
curl -sS --cacert ca.crt $R https://shop.example.com:$NPS/ -o /dev/null; echo "exit=$?"
k patch gateway web --type=json -p '[{"op":"replace",
 "path":"/spec/listeners/1/tls/certificateRefs/0/name","value":"shop-tls"}]'

Erwartet:

gateway.gateway.networking.k8s.io/web patched
http: True ResolvedRefs
https-shop: False InvalidCertificateRef
https-api: True ResolvedRefs
NAME   CLASS            ADDRESS       PROGRAMMED   AGE
web    tag11-nodeport   172.16.0.83   True         2m12s
Listener not valid. Invalid CertificateRef, Secret "shop-tsl" not found
curl: (35) Recv failure: Connection reset by peer
exit=35
gateway.gateway.networking.k8s.io/web patched

Tückisch: Das Gateway bleibt insgesamt PROGRAMMED True, nur der eine Listener fällt aus. Gib dem Status ein paar Sekunden – direkt nach dem Patch steht dort noch der alte Wert. Jetzt liegt das Zertifikat für api zentral in einem eigenen Namespace:

k create namespace tag11-certs
k -n tag11-certs apply -f cert-api.yaml
k -n tag11-certs wait --for=condition=Ready certificate api
k patch gateway web --type=json -p '[{"op":"replace",
 "path":"/spec/listeners/2/tls/certificateRefs/0",
 "value":{"name":"api-tls","namespace":"tag11-certs"}}]'
k get gateway web -o jsonpath="$LC"
k get gateway web -o jsonpath='{.status.listeners[2].conditions[0].message}{"\n"}'

Erwartet:

namespace/tag11-certs created
certificate.cert-manager.io/api created
certificate.cert-manager.io/api condition met
gateway.gateway.networking.k8s.io/web patched
http: True ResolvedRefs
https-shop: True ResolvedRefs
https-api: False RefNotPermitted
CertificateRef is not permitted

Wie bei Routen auf Services aus Tag 10: Der Namespace mit dem Secret muss zustimmen – diesmal für die Art Gateway und Ziel Secret:

cat > grant-secret.yaml <<'EOF'
apiVersion: gateway.networking.k8s.io/v1
kind: ReferenceGrant
metadata:
  name: tag11-gateway-secrets
  namespace: tag11-certs
spec:
  from:
  - group: gateway.networking.k8s.io
    kind: Gateway
    namespace: tag11
  to:
  - group: ""
    kind: Secret
EOF
k apply -f grant-secret.yaml
k get gateway web -o jsonpath="$LC"
curl -s --cacert ca.crt --resolve api.example.com:$NPS:172.16.0.228 \
  https://api.example.com:$NPS/ | grep '"host"'

Erwartet:

referencegrant.gateway.networking.k8s.io/tag11-gateway-secrets created
http: True ResolvedRefs
https-shop: True ResolvedRefs
https-api: True ResolvedRefs
 "host": "api.example.com:31589",

Fortschritt speichern? Kostenlos registrieren

Drill 8: BackendTLSPolicy – TLS bis zum Pod

Bisher endet TLS am Gateway, die letzte Strecke ist Klartext. Ein Backend, das selbst nur HTTPS spricht (echo-basic mit HTTPS_PORT), mit Zertifikat für seinen Service-Namen:

cat > secure.yaml <<'EOF'
apiVersion: cert-manager.io/v1
kind: Certificate
metadata:
  name: secure
spec:
  secretName: secure-tls
  dnsNames:
  - secure.tag11.svc
  issuerRef:
    name: tag11-ca
    kind: ClusterIssuer
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: secure
spec:
  selector:
    matchLabels: {app: secure}
  template:
    metadata:
      labels: {app: secure}
    spec:
      containers:
      - name: echo
        image: registry.k8s.io/gateway-api/echo-basic:v1.5.1
        env:
        - name: POD_NAME
          valueFrom: {fieldRef: {fieldPath: metadata.name}}
        - name: HTTPS_PORT
          value: "8443"
        - name: TLS_SERVER_CERT
          value: /tls/tls.crt
        - name: TLS_SERVER_PRIVKEY
          value: /tls/tls.key
        volumeMounts:
        - name: tls
          mountPath: /tls
      volumes:
      - name: tls
        secret:
          secretName: secure-tls
EOF
k apply -f secure.yaml
k expose deployment secure --port=443 --target-port=8443
k rollout status deployment secure
cat > route-secure.yaml <<'EOF'
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: secure
spec:
  parentRefs:
  - name: web
    sectionName: https-shop
  hostnames:
  - shop.example.com
  rules:
  - matches:
    - path:
        type: PathPrefix
        value: /secure
    backendRefs:
    - name: secure
      port: 443
EOF
k apply -f route-secure.yaml
curl -s -w ' %{http_code}\n' $R --cacert ca.crt https://shop.example.com:$NPS/secure

Erwartet:

deployment "secure" successfully rolled out
httproute.gateway.networking.k8s.io/secure created
Client sent an HTTP request to an HTTPS server.
 400

Envoy spricht Klartext mit einem TLS-Port. Die BackendTLSPolicy (seit Gateway API v1.4 im Standard-Kanal, Cilium 1.20 meldet BackendTLSPolicy als unterstütztes Feature) sagt ihm: TLS zum Service secure, Zertifikat gegen die Lab-CA prüfen, erwarteter Name secure.tag11.svc. Die CA kommt aus einer ConfigMap:

k create configmap lab-ca --from-file=ca.crt=ca.crt
cat > btls.yaml <<'EOF'
apiVersion: gateway.networking.k8s.io/v1
kind: BackendTLSPolicy
metadata:
  name: secure
spec:
  targetRefs:
  - group: ""
    kind: Service
    name: secure
  validation:
    caCertificateRefs:
    - group: ""
      kind: ConfigMap
      name: lab-ca
    hostname: secure.tag11.svc
EOF
k apply -f btls.yaml
k get backendtlspolicy secure -o jsonpath=\
'{range .status.ancestors[*].conditions[*]}{.type}={.status} {.reason}{"\n"}{end}'
curl -s $R --cacert ca.crt https://shop.example.com:$NPS/secure \
  | sed -n '/"tls"/,/}/p'

Erwartet:

configmap/lab-ca created
backendtlspolicy.gateway.networking.k8s.io/secure created
Accepted=True Accepted
ResolvedRefs=True ResolvedRefs
 "tls": {
  "version": "TLSv1.3",
  "serverName": "secure.tag11.svc",
  "negotiatedProtocol": "http/1.1",
  "cipherSuite": "TLS_AES_128_GCM_SHA256"
 }

Das Backend bestätigt: TLS 1.3, SNI secure.tag11.svc. Gegenprobe mit falschem erwarteten Namen – Envoy verweigert dann die Verbindung:

k patch backendtlspolicy secure --type=merge \
  -p '{"spec":{"validation":{"hostname":"falsch.tag11.svc"}}}'
curl -s -w ' %{http_code}\n' $R --cacert ca.crt https://shop.example.com:$NPS/secure
k patch backendtlspolicy secure --type=merge \
  -p '{"spec":{"validation":{"hostname":"secure.tag11.svc"}}}'

Erwartet:

backendtlspolicy.gateway.networking.k8s.io/secure patched
upstream connect error or disconnect/reset before headers. reset reason: remote
connection failure 503
backendtlspolicy.gateway.networking.k8s.io/secure patched

Fortschritt speichern? Kostenlos registrieren

Übung: Speed-Drills

  1. Stelle über tag11-ca ein Zertifikat docs für docs.example.com und www.docs.example.com ins Secret docs-tls aus. Zeitziel: 2 min
  2. Zeige für alle Certificates in tag11 Ablauf und nächsten Erneuerungszeitpunkt. Zeitziel: 60 s
  3. Prüfe, welches Zertifikat (Aussteller, SAN, Ablauf) das Gateway für SNI api.example.com ausliefert. Zeitziel: 60 s
  4. Zeige je Listener von web, ob er Programmed ist und warum. Zeitziel: 60 s

Lösung

cat > cert-docs.yaml <<'EOF'
apiVersion: cert-manager.io/v1
kind: Certificate
metadata:
  name: docs
spec:
  secretName: docs-tls
  dnsNames:
  - docs.example.com
  - www.docs.example.com
  issuerRef:
    name: tag11-ca
    kind: ClusterIssuer
EOF
k apply -f cert-docs.yaml
k wait --for=condition=Ready certificate docs
k get secret docs-tls -o jsonpath='{.data.tls\.crt}' | base64 -d \
  | openssl x509 -noout -ext subjectAltName
k get certificate -o custom-columns=\
NAME:.metadata.name,NOTAFTER:.status.notAfter,RENEW:.status.renewalTime
openssl s_client -connect 172.16.0.228:$NPS -servername api.example.com \
  </dev/null 2>/dev/null | openssl x509 -noout -issuer -ext subjectAltName -enddate
k get gateway web -o jsonpath="$LC"

Erwartet (gekürzt):

certificate.cert-manager.io/docs condition met
X509v3 Subject Alternative Name: critical
    DNS:docs.example.com, DNS:www.docs.example.com
NAME     NOTAFTER               RENEW
api      2026-11-19T23:55:13Z   2026-11-19T15:55:13Z
docs     2027-02-16T23:58:18Z   2027-01-17T23:58:18Z
secure   2027-02-16T23:57:11Z   2027-01-17T23:57:11Z
shop     2026-11-19T23:55:51Z   2026-11-19T15:55:51Z
issuer=CN = CKNE Lab CA
X509v3 Subject Alternative Name: critical
    DNS:api.example.com
notAfter=Nov 19 23:56:22 2026 GMT
http: True ResolvedRefs
https-shop: True ResolvedRefs
https-api: True ResolvedRefs

Ohne duration stellt cert-manager 90 Tage aus und erneuert nach zwei Dritteln. Das ausgelieferte api-Zertifikat stammt aus tag11-certs (Drill 7) – deshalb weicht sein Ablauf vom gleichnamigen Certificate in tag11 ab.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

k -n cert-manager get deploy

Erwartet: cert-manager, cert-manager-cainjector, cert-manager-webhook, alle 1/1 – cert-manager bleibt installiert für Tag 21 (Runde 6) und Anhang B (Aufgabe 9).

k get clusterissuer tag11-ca

Erwartet: READY True.

curl -s $R --cacert ca.crt https://shop.example.com:$NPS/ | grep '"pod"'

Erwartet: ein Pod echo-v1-…, ohne Zertifikatsfehler.

curl -si -H 'Host: shop.example.com' http://172.16.0.228:$NPH/ | head -1

Erwartet: HTTP/1.1 301 Moved Permanently.

k get backendtlspolicy secure -o jsonpath='{.status.ancestors[0].conditions[0].status}'

Erwartet: True.

Challenge

Lass cert-manager das Zertifikat selbst anlegen: Ein zweites Gateway auto mit HTTPS-Listener für auto.example.com soll ohne eigenes Certificate-Objekt ein gültiges Lab-CA-Zertifikat ausliefern.

Hinweis: Die Gateway-API-Integration (Drill 1) reagiert auf die Annotation cert-manager.io/cluster-issuer am Gateway.

Lösung

cat > gw-auto.yaml <<'EOF'
apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata:
  name: auto
  annotations:
    cert-manager.io/cluster-issuer: tag11-ca
spec:
  gatewayClassName: tag11-nodeport
  listeners:
  - name: https
    protocol: HTTPS
    port: 443
    hostname: auto.example.com
    tls:
      mode: Terminate
      certificateRefs:
      - name: auto-tls
EOF
sed -e 's/name: shop$/name: auto/' -e 's/- name: web/- name: auto/' \
  -e 's/sectionName: https-shop/sectionName: https/' \
  -e 's/shop.example.com/auto.example.com/' route-shop.yaml > route-auto.yaml
k apply -f gw-auto.yaml -f route-auto.yaml
k wait --for=condition=Programmed gateway auto
k get certificate auto-tls -o jsonpath='{.metadata.ownerReferences[0].kind}/'\
'{.metadata.ownerReferences[0].name} {.spec.dnsNames}'
echo
NPA=$(k get svc cilium-gateway-auto -o jsonpath='{.spec.ports[0].nodePort}')
curl -s --cacert ca.crt --resolve auto.example.com:$NPA:172.16.0.228 \
  https://auto.example.com:$NPA/ | grep '"host"'

Erwartet:

gateway.gateway.networking.k8s.io/auto created
httproute.gateway.networking.k8s.io/auto created
gateway.gateway.networking.k8s.io/auto condition met
Gateway/auto ["auto.example.com"]
 "host": "auto.example.com:32488",

Das Certificate auto-tls gehört dem Gateway (ownerReference) und übernimmt den Listener-hostname als SAN. Nicht mischen: Ein von Hand angelegtes Certificate für dasselbe Secret und die Annotation am selben Gateway kämpfen um das Secret.

Fortschritt speichern? Kostenlos registrieren

Aufräumen

k delete namespace tag11 tag11-certs
k delete gatewayclass tag11-nodeport
k delete clusterissuer tag11-ca tag11-selfsigned
k -n cert-manager delete certificate lab-ca
k -n cert-manager delete secret lab-ca
k config set-context --current --namespace=default

cert-manager (Helm-Release cert-manager) und cmctl bleiben für Tag 21 (Runde 6) und Anhang B (Aufgabe 9); Gateway-API-CRDs und gatewayAPI.enabled=true ebenfalls (Tag 18, Tag 21 Runde 6, Anhang B Aufgaben 8 und 9).

Prüfungstipp

  • HTTPS-Listener brauchen tls.certificateRefs (mode: Terminate ist Standard, explizit schreiben schadet nicht); ein Secret in einem anderen Namespace braucht dort einen ReferenceGrant (kind: Gateway → Secret).
  • Status je Listener lesen (.status.listeners[*].conditions): Das Gateway kann Programmed sein, während ein Listener mit InvalidCertificateRef ausfällt.
  • Doku: gateway-api.sigs.k8s.io „TLS“ und „BackendTLSPolicy“, cert-manager.io „Gateway“, docs.cilium.io „Gateway API – HTTPS Example“.

Enterprise-Notiz

  • Öffentliche Namen bekommen ACME-Zertifikate (Let’s Encrypt, HTTP-01 über die Gateway API oder DNS-01); interne Namen eine Firmen-CA über Vault oder einen CA-Issuer.
  • Die CA-Wurzel gehört nicht ins Cluster-Secret eines Labors, sondern in ein HSM/KMS; im Cluster liegt höchstens eine Zwischen-CA mit kurzer Laufzeit.
  • trust-manager verteilt CA-Bündel als ConfigMaps in alle Namespaces – passend zu caCertificateRefs der BackendTLSPolicy.
  • Zertifikats-Abläufe überwachen: cert-manager exportiert certmanager_certificate_expiration_timestamp_seconds für Prometheus (Tag 19).
  • Für mTLS zwischen allen Pods statt nur Gateway→Backend: Mutual Authentication oder ein Service Mesh (Tag 14).