d0040 - Internes TLS für `*.homeserver` (Security-Härtung Phase 5)
Quelle: pkr-lab/pkr-lab-docs/capulus/capulus-core/d-sicherheit/d0040-internal-tls.md
Internes TLS für *.homeserver (Security-Härtung Phase 5)
Detail-Doku zu Phase 5 aus capulus-core/d-sicherheit/d0010-security-hardening-roadmap.md.
Status (16.08.2026): Umstellung auf cert-manager. Der ursprüngliche
Ansatz (manuell per openssl signierte Leaf-Zertifikate, als SealedSecret
committet — siehe Vorheriger Ansatz
unten) ist abgelöst durch cert-manager, das
Zertifikate automatisch aus derselben Homeserver-Root-CA signiert und vor
Ablauf selbstständig erneuert.
Konkreter Auslöser der Umstellung: Die Domain-Tier-Migration
(capulus-core/c-netzwerk-dns/c0040-domain-tiers.md, <app>.homeserver →
<app>.tech.homeserver/<app>.prod.homeserver) hat die SAN-Liste des
damals committeten Zertifikats stillschweigend veralten lassen — das
Zertifikat trug noch die alten, untierten Hostnamen. Jeder neue
tier-behaftete Host bekam seither einen Zertifikats-Hostname-Mismatch, und
weil der CA-Private-Key bewusst nie im Repo lag, ließ sich das nicht per
Commit reparieren (siehe capulus-core/c-netzwerk-dns/c0040-domain-tiers.md, Abschnitt "Offener Punkt", jetzt
aufgelöst). Das war der praktische Bruchpunkt, der die Automatisierung
nötig gemacht hat.
Ziel
Alle *.homeserver-Adressen liefen bisher über Klartext-http:// intern
im LAN (Traefik hatte kein TLS-Zertifikat für diese Zone — nur der externe
Pfad über den Cloudflare-Tunnel, *.pke-lab.de, ist bereits TLS-terminiert
bei Cloudflare). Diese Phase schließt die Lücke für den lokalen Pfad —
jetzt mit automatischer Ausstellung/Erneuerung statt eines manuellen,
CA-Key-abhängigen Ablaufs.
Design-Entscheidungen
cert-manager statt weiterhin manuellem openssl
Der ursprüngliche Grund gegen einen laufenden CA-Server (siehe
Vorheriger Ansatz) war die
zusätzliche dauerhaft laufende Komponente für einen selten wechselnden
Bedarf. Das hat sich als falsche Abwägung erwiesen, sobald sich die
SAN-Liste (Domain-Tier-Migration) tatsächlich geändert hat: ohne
laufenden Signier-Dienst bedeutet jede SAN-Änderung wieder denselben
manuellen, CA-Key-abhängigen Ablauf — genau das Risiko, das gerade
eingetreten ist. cert-manager übernimmt Signieren + Erneuern vollständig
und ist als reiner Kubernetes-Controller (kein separater ACME-Server wie
step-ca) die kleinstmögliche Automatisierung für genau dieses Problem.
Bestehende CA weiterverwenden statt neuer Self-Signed-Root
cert-managers Standardweg für eine private CA ist ein SelfSigned-
Bootstrap-ClusterIssuer, der eine komplett neue Root-CA erzeugt. Bewusst
NICHT so umgesetzt — das hätte auf jedem Client-Gerät einen erneuten
Trust-Store-Rollout nötig gemacht (siehe Client-Geräte
unten, der aufwendigste Teil des ursprünglichen Rollouts). Stattdessen
signiert ein ClusterIssuer vom Typ CA mit der bestehenden
Homeserver-Root-CA (rootCA.pem/rootCA-key.pem, bisher nur lokal für
den manuellen openssl x509 -req -CA ...-Schritt genutzt) — exakt
dieselbe CA bleibt gültig, das bereits auf allen Geräten installierte
pki/homeserver-root-ca.pem
musste nicht ersetzt werden.
CA-Private-Key: einmaliger manueller Import, kein SealedSecret
Der CA-Private-Key muss jetzt zwingend im Cluster liegen, sonst kann
cert-manager nicht selbstständig signieren — das ist der ganze Sinn dieser
Migration. Trotzdem bewusst kein SealedSecret dafür im Repo, aus
demselben Grund wie beim vorherigen Ansatz: der CA-Key ist höherwertiger
als ein normales App-Secret (er signiert praktisch beliebig viele
Leaf-Zertifikate), ein Repo-Leak der sealed-secrets-Controller-Keys soll
ihn nicht mit offenlegen. Import bleibt deshalb ein einmaliger manueller
kubectl create secret-Schritt außerhalb von GitOps (siehe
Rollout unten) — das Secret existiert nur im Cluster, nie im
Repo, nicht mal versiegelt.
Kein Wildcard — weiterhin explizite SAN-Liste
Unverändert gegenüber dem vorherigen Ansatz: *.homeserver scheitert
strukturell an X509_check_host (OpenSSL, von curl/den meisten
TLS-Stacks genutzt), das Wildcards unter einem Suffix mit nur einem
DNS-Label ablehnt — dieselbe Schutzregel, die ein *.com-Zertifikat
verhindert. Das ist eine Eigenschaft von .homeserver als Zone, keine
Tool-Einschränkung — auch cert-manager kann daran nichts ändern. Die
Certificate-Ressource
trägt deshalb weiterhin eine explizite, jetzt tier-behaftete dnsNames-
Liste. Ein neuer *.homeserver-Host braucht weiterhin einen Eintrag dort
- Commit — was sich geändert hat, ist nur, dass danach niemand mehr
openssl/kubesealvon Hand ausführen muss: cert-manager erneuert das
Zertifikat automatisch, sobald der geänderte Manifest gesynct ist.
Zertifikat
- Subject Alternative Names: alle aktuellen
*.homeserver-Hosts
(tier-behaftet,<app>.tech.homeserver/<app>.prod.homeserver) plus
der nackte Apexhomeserver— siehe
certificate-homeserver-wildcard.yaml. - Gültigkeit: 90 Tage (
duration: 2160h), automatische Erneuerung 30
Tage vor Ablauf (renewBefore: 720h) — bewusst kurz, weil das jetzt
nichts mehr kostet (keine ACME-Rate-Limits wie bei einer öffentlichen
CA, keine manuelle Arbeit): häufige Rotation ist bei einer internen CA
reiner Sicherheitsgewinn ohne Nachteil.
Ablage im Cluster: TLSStore statt pro-App-Ingress
Unverändert: ein einziges TLSStore-Objekt namens default
(argocd/apps/tech/traefik-config/tlsstore.yaml)
verweist auf das von cert-manager verwaltete Secret — default ist dabei
kein Freitext, sondern der von Traefik selbst reservierte Name, der
automatisch für jeden Router greift, der nicht explizit ein anderes
TLSStore referenziert.
cert-manager-Namespace: Infrastruktur, kein App-Tier
cert-manager läuft in einem eigenen Namespace, ist aber bewusst nicht
Teil von argocd_platform_apps
(capulus-ansible/roles/argocd/defaults/main.yml)
— genau wie kube-system und argocd selbst ist das Cluster-
Infrastruktur, kein App mit eigenem Nutzerkreis/Tier. Die Namespace-
Berechtigung steht deshalb als zusätzlicher, fest kodierter Eintrag in der
platform-AppProject-Destination-Liste
(capulus-ansible/roles/argocd/templates/bootstrap-appprojects.yaml.j2),
analog zum bestehenden kube-system-Eintrag — sonst bekäme der
Namespace ein tier-default-ingress-NetworkPolicy und ein
security-tier-Label, die für Cluster-Infrastruktur nicht sinnvoll sind
(siehe capulus-core/d-sicherheit/d0030-network-policies.md).
Rollout
1. Committen + pushen (macht der Nutzer selbst) — sobald
argocd/apps/tech/cert-manager/,
argocd/apps/tech/traefik-config/tlsstore.yaml und
capulus-ansible/roles/argocd/templates/bootstrap-appprojects.yaml.j2 +
argocd/bootstrap/projects.yaml im Repo sind, holt sich ArgoCD die
Änderung automatisch (automated: {prune: true, selfHeal: true}, kein
manueller Sync-Trigger nötig). cert-manager selbst (Controller + CRDs +
ClusterIssuer + Certificate) synct in einem Zug — der ClusterIssuer
bleibt bis Schritt 2 NotReady (fehlendes Secret), das lässt den Sync
nicht fehlschlagen, nur das Certificate bleibt so lange Pending.
2. CA-Keypair einmalig ins Cluster importieren (nicht Teil von
GitOps, siehe Design-Entscheidungen
oben — CA-Key aus dem Passwort-Manager zurückspielen, falls nicht mehr am
Rechner, der ihn generiert hat):
kubectl create secret tls homeserver-ca-keypair \
--cert=rootCA.pem --key=rootCA-key.pem \
--namespace=cert-manager
3. Sync + Zertifikat-Status verifizieren:
kubectl get application cert-manager -n argocd \
-o custom-columns='NAME:.metadata.name,SYNC:.status.sync.status,HEALTH:.status.health.status'
kubectl get clusterissuer homeserver-ca-issuer -o wide
kubectl -n kube-system get certificate homeserver-wildcard-tls
# READY sollte "True" zeigen, sobald Schritt 2 erledigt ist
kubectl -n kube-system get secret homeserver-wildcard-tls
4. HTTPS lokal testen (von einem Gerät, auf dem die CA schon
installiert ist — siehe Client-Geräte unten):
curl -v https://whoami.prod.homeserver/ 2>&1 | grep -E "issuer|subject|SSL certificate verify"
Erwartung: issuer: O=Homeserver Internal CA, CN=Homeserver Root CA
(dieselbe CA wie vorher), kein
SSL certificate problem: unable to get local issuer certificate (das
würde bedeuten, die CA ist auf diesem Gerät nicht vertraut — Schritt für
dieses Gerät nachholen, siehe unten). Nicht nur kubectl get secret
prüfen — das zeigt nur, dass irgendein Zertifikat da ist, nicht, dass die
SAN-Liste zum tatsächlichen Host passt.
Client-Geräte (Vertrauensspeicher)
Da dieselbe CA weiterverwendet wird (siehe Design-Entscheidungen oben),
ändert sich hier nichts gegenüber dem bisherigen Stand — Geräte, auf
denen die CA schon installiert ist, brauchen keinen erneuten Rollout.
Für alle anderen Geräte gilt weiterhin, pro Gerät manuell, kein
Ansible/Automatisierung möglich (unterschiedliche OS-Mechanismen, teils
kein Remote-Zugriff auf private Geräte):
Ausnahme Banana-Pi-Alarmmonitore: anders als die privaten Geräte unten
sind diese bereits Ansible-verwaltet (capulus-ansible/roles/banana_pi_kiosk),
sowohl das System-Trust-Store-Update (update-ca-certificates) als auch
der NSS-Datenbank-Import für den Kiosk-User (~/.pki/nssdb, siehe
"Linux" unten — Chromium braucht beides, der System-Trust-Store allein
reicht nicht) laufen dort deshalb automatisch bei jedem Rollout — Quelle
ist direkt das committete pki/homeserver-root-ca.pem, keine
separate Kopie. Nichts manuell zu tun, solange make banana-pi-kiosks
regelmäßig läuft.
Linux:
sudo apt-get install -y mkcert libnss3-tools # falls noch nicht installiert
mkcert -install
Installiert automatisch in den System-Trust-Store und in Firefox/
Chrome (NSS-Datenbank, dafür libnss3-tools).
Weitere Linux-Rechner (ohne mkcert/CA-Private-Key dort): CA-Zertifikat
kopieren und manuell registrieren, statt mkcert erneut zu installieren
(braucht nur die public .pem, keinen Private Key):
sudo cp pki/homeserver-root-ca.pem /usr/local/share/ca-certificates/homeserver-root-ca.crt
sudo update-ca-certificates
# Für Firefox/Chrome zusätzlich (NSS-Datenbank):
certutil -d sql:$HOME/.pki/nssdb -A -t "C,," -n "homeserver-root-ca" -i pki/homeserver-root-ca.pem
Windows: pki/homeserver-root-ca.pem doppelklicken →
"Zertifikat installieren" → Lokaler Computer → "Alle Zertifikate in
folgendem Speicher speichern" → Vertrauenswürdige Stammzertifizierungsstellen.
Firefox verwendet einen eigenen Speicher (about:preferences#privacy →
Zertifikate → Zertifikate anzeigen → Zertifizierungsstellen → Importieren).
macOS: pki/homeserver-root-ca.pem in Schlüsselbundverwaltung
importieren (System-Schlüsselbund) → Zertifikat öffnen → "Vertrauen" →
"Bei Verwendung dieses Zertifikats" auf Immer vertrauen setzen.
iOS: Datei per AirDrop/Mail an das Gerät schicken → öffnen → Profil
installieren (Einstellungen → Profil geladen) → zusätzlich
Einstellungen → Allgemein → Info → Zertifikatsvertrauenseinstellungen →
das Root-Zertifikat manuell aktivieren (iOS installiert es sonst nur,
vertraut ihm aber nicht automatisch für TLS).
Android: Datei aufs Gerät kopieren → Einstellungen → Sicherheit →
Verschlüsselung & Anmeldedaten → Zertifikat installieren → CA-Zertifikat.
Ab Android 7 gelten benutzerinstallierte CAs nicht automatisch für alle
Apps (nur für den Browser/System-WebView) — für Apps mit eigenem
Netzwerk-Stack ggf. nicht wirksam, hier aber nicht relevant (nur
Browser-Zugriff auf *.homeserver).
Neuen Host hinzufügen / Zertifikat erneuern
Neuer Host: Eintrag in dnsNames in
certificate-homeserver-wildcard.yaml
ergänzen, committen, pushen — cert-manager erstellt automatisch ein neues
Zertifikat mit der erweiterten SAN-Liste, kein openssl/kubeseal mehr
nötig.
Reguläre Erneuerung: komplett automatisch (siehe
Zertifikat oben, renewBefore: 720h) — nichts zu tun.
CA läuft aus (alle 10 Jahre) oder CA-Key kompromittiert: einziger
noch verbliebener manueller Fall — neue Root-CA per openssl erzeugen
(gleiches Verfahren wie beim ursprünglichen Rollout), rootCA.pem in
pki/homeserver-root-ca.pem
ersetzen + committen, homeserver-ca-keypair-Secret im Cluster mit dem
neuen Keypair überschreiben (Schritt 2 aus Rollout erneut),
und — anders als bei einer normalen Zertifikats-Erneuerung — auf jedem
Client-Gerät erneut installieren (siehe
Client-Geräte), weil sich die CA
selbst ändert.
Zusätzlich liegt je eine Kopie der Root-CA in den Charts, deren Pods intern per HTTPS sprechen: argocd/apps/tech/n8n/files/, argocd/apps/tech/uptime-kuma/files/ und argocd/apps/tech/github-release-watcher/files/. Alle drei beim CA-Tausch mit aktualisieren.
Aufräumen
- CA-Private-Key (lokale Kopie, z. B.
~/.local/share/mkcert/rootCA-key.pem) bleibt zusätzlich im
Passwort-Manager gesichert — geht sowohl die lokale Kopie als auch
dashomeserver-ca-keypair-Secret im Cluster verloren, muss bei der
nächsten Änderung eine komplett neue CA generiert und auf allen
Geräten neu installiert werden.
Vorheriger Ansatz: manuelles openssl/mkcert
Bis 16.08.2026 wurde jedes Leaf-Zertifikat manuell per openssl x509 -req -CA rootCA.pem -CAkey rootCA-key.pem ... signiert und als SealedSecret
committet, mit der SAN-Liste per Hand aus kubectl get ingress -A
gezogen. Grund für die Ablösung: siehe Status-Absatz ganz oben. Root-CA-
Erzeugung (openssl req -x509 ... mit neutralem Subject statt mkcerts
OU=user@host, wegen des öffentlichen Repos) und die Argumentation dafür
sind unverändert gültig — nur der Leaf-Signier-Schritt ist jetzt
automatisiert, siehe Design-Entscheidungen oben.
PROD-Cluster (Phase 2.8, Multi-Cluster-Plan)
Der PROD-Cluster (prod-vm, vom TECH-Hub verwaltet) bekommt kein Abbild
des Root-CA-Keys. Stattdessen stellt die gemeinsame Homeserver-Root-CA eine
PROD-eigene Intermediate-CA aus, deren Key als einziger in PROD liegt
(Entscheidung 0.3, 40080 Baustein 4).
Clients vertrauen weiterhin nur der Root-CA — kein neuer Trust-Store-Rollout.
Wird der PROD-Cluster kompromittiert, ist der Root-Key nicht betroffen; die
Intermediate-CA lässt sich mit der Root-CA neu ausstellen.
Im Repo: argocd/apps/prod/cert-manager/ (Chart, ClusterIssuer,
Certificate nur für *.prod.homeserver-Hosts) und
argocd/apps/prod/traefik-config/tlsstore.yaml. Der ApplicationSet
home-server-apps-prod erzeugt daraus prod-cert-manager und
prod-traefik-config.
Einmaliger manueller Schritt (nicht GitOps, Key nie ins Repo), auf dem
Rechner, auf dem rootCA.pem/rootCA-key.pem liegen (Passwort-Manager, falls
nicht mehr lokal):
mkdir -p ~/prod-ca && cd ~/prod-ca
openssl genrsa -out prod-ca-key.pem 4096
openssl req -new -key prod-ca-key.pem \
-subj "/O=Homeserver Internal CA/CN=Homeserver PROD Intermediate CA" -out prod-ca.csr
cat > prod-ca-ext.cnf <<'EXT'
basicConstraints=critical,CA:TRUE,pathlen:0
keyUsage=critical,keyCertSign,cRLSign
subjectKeyIdentifier=hash
authorityKeyIdentifier=keyid,issuer
EXT
openssl x509 -req -in prod-ca.csr -CA /pfad/zu/rootCA.pem -CAkey /pfad/zu/rootCA-key.pem \
-CAcreateserial -days 1825 -sha256 -extfile prod-ca-ext.cnf -out prod-ca.pem
openssl verify -CAfile /pfad/zu/rootCA.pem prod-ca.pem # muss "OK" zeigen
Import erst, nachdem prod-cert-manager gesynct und der Namespace
cert-manager in PROD existiert:
kubectl create secret tls homeserver-ca-keypair --cert=prod-ca.pem --key=prod-ca-key.pem \
--namespace=cert-manager --dry-run=client -o yaml \
| ssh [email protected] 'sudo k3s kubectl apply -f -'
Danach die Dateien in ~/prod-ca/ sichern (Key in den Passwort-Manager) und
lokal löschen.
Prüfen (auf prod-vm bzw. per ssh [email protected] 'sudo k3s kubectl …'):
kubectl get clusterissuer homeserver-ca-issuer -o wide # Ready=True
kubectl -n kube-system get certificate homeserver-wildcard-tls # READY=True
curl -v --resolve whoami.prod.homeserver:443:192.168.178.99 https://whoami.prod.homeserver/ 2>&1 | grep -E "issuer|verify"
Der Test mit curl funktioniert erst, wenn ein Host in PROD tatsächlich
läuft (Phase 3) — bis dahin liefert Traefik in PROD sein Standardzertifikat
bzw. einen 404, das Zertifikat selbst ist aber bereits prüfbar
(kubectl get secret homeserver-wildcard-tls -n kube-system).
Zertifikat für ArgoCD auf der ENTW-VM
Die ENTW-VM hat kein cert-manager. Das Zertifikat für argocd.dev.homeserver stellt der Betreiber von Hand mit der Homeserver-Root-CA aus (Gültigkeit 365 Tage) und legt
es als Vault-Variablen in capulus-ansible/host_vars/entw-vm/vars.yml ab. Grund und Einbindung: 60030.
kubectl -n cert-manager get secret homeserver-ca-keypair -o jsonpath='{.data.tls\.crt}' | base64 -d > ca.crt
kubectl -n cert-manager get secret homeserver-ca-keypair -o jsonpath='{.data.tls\.key}' | base64 -d > ca.key
openssl req -new -newkey rsa:2048 -nodes -keyout leaf.key -subj "/CN=argocd.dev.homeserver" -out leaf.csr
printf 'subjectAltName=DNS:argocd.dev.homeserver\nbasicConstraints=CA:FALSE\nkeyUsage=digitalSignature,keyEncipherment\nextendedKeyUsage=serverAuth\n' > ext.cnf
openssl x509 -req -in leaf.csr -CA ca.crt -CAkey ca.key -CAcreateserial -days 365 -extfile ext.cnf -out leaf.crt
openssl verify -CAfile ca.crt leaf.crt
ansible-vault encrypt_string --vault-password-file ~/.vault_pass --name argocd_ingress_tls_crt < leaf.crt
ansible-vault encrypt_string --vault-password-file ~/.vault_pass --name argocd_ingress_tls_key < leaf.key
shred -u ca.key leaf.key; rm -f ca.crt leaf.csr leaf.crt ext.cnf ca.srl
Die zwei Ausgaben ersetzen die gleichnamigen Einträge in host_vars/entw-vm/vars.yml. Danach:
ansible-playbook -i inventory/hosts.yml entw.yml --tags argocd --vault-password-file ~/.vault_pass
curl -s --cacert pki/homeserver-root-ca.pem https://argocd.dev.homeserver/api/version
Das Ablaufdatum steht in ops/token-register.yaml (entw-argocd-ingress-cert). Läuft das Zertifikat ab, antwortet der Ingress weiter, aber die
Promotion-Kette lehnt es ab und das Gate der ENTW-Stufe blockiert. Rollback: die Variablen entfernen, der Ingress rendert dann ohne TLS.
Zertifikat für den WoL-Agent auf dem Vereinsheim-Pi
Der banana-pi-wol-agent (60020) spricht HTTPS mit einem Zertifikat der Homeserver-Root-CA, das die Tailscale-IP 100.123.214.4 als IP-SAN trägt. Der Pi hat kein cert-manager,
deshalb stellt der Betreiber es von Hand aus (Gültigkeit 365 Tage) und legt es als Vault-Variablen vault_vereinsheim_wol_agent_tls_crt und vault_vereinsheim_wol_agent_tls_key in
capulus-ansible/host_vars/vereinsheim-alarmmonitor/vault.yml ab. Der CA-Schlüssel verlässt dabei den Cluster nicht: cert-manager stellt das Blatt-Zertifikat selbst aus.
cat > cert.yaml <<'EOF'
apiVersion: cert-manager.io/v1
kind: Certificate
metadata:
name: wol-agent-tls-tmp
namespace: cert-manager
spec:
secretName: wol-agent-tls-tmp
issuerRef:
name: homeserver-ca-issuer
kind: ClusterIssuer
commonName: vereinsheim-wol-agent
ipAddresses:
- 100.123.214.4
duration: 8760h
privateKey:
algorithm: ECDSA
size: 256
encoding: PKCS8
usages:
- digital signature
- server auth
EOF
kubectl apply -f cert.yaml
kubectl -n cert-manager wait certificate/wol-agent-tls-tmp --for=condition=Ready --timeout=60s
umask 077
kubectl -n cert-manager get secret wol-agent-tls-tmp -o jsonpath='{.data.tls\.crt}' | base64 -d > tls.crt
kubectl -n cert-manager get secret wol-agent-tls-tmp -o jsonpath='{.data.tls\.key}' | base64 -d > tls.key
openssl verify -CAfile pki/homeserver-root-ca.pem -verify_ip 100.123.214.4 tls.crt
kubectl -n cert-manager delete certificate wol-agent-tls-tmp
kubectl -n cert-manager delete secret wol-agent-tls-tmp
ansible-vault encrypt_string --name vault_vereinsheim_wol_agent_tls_crt < tls.crt
ansible-vault encrypt_string --name vault_vereinsheim_wol_agent_tls_key < tls.key
shred -u tls.key; rm -f tls.crt cert.yaml
Die zwei Ausgaben ersetzen die gleichnamigen Einträge in vault.yml. Danach issued und expires des Eintrags vereinsheim-wol-agent-cert im Token-Register anpassen und den Pi ausrollen, erst als Prüflauf:
ansible-playbook -i inventory/hosts.yml banana-pi-kiosks.yml --limit vereinsheim-alarmmonitor --tags banana-pi-kiosk --check --diff --ask-vault-pass
ansible-playbook -i inventory/hosts.yml banana-pi-kiosks.yml --limit vereinsheim-alarmmonitor --tags banana-pi-kiosk --ask-vault-pass
curl -s -o /dev/null -w '%{http_code}\n' --cacert pki/homeserver-root-ca.pem -X POST https://100.123.214.4:9102/wol
Erwartung der letzten Zeile: 401 (kein Token, es wird nichts geweckt). Läuft das Zertifikat ab, lehnt die iOS-App den Agent ab und das Aufwecken aus der App fällt aus, der Agent selbst läuft weiter.
Rollback: banana_pi_kiosk_wol_agent_tls_enabled: false in host_vars/vereinsheim-alarmmonitor/vars.yml und Rollenlauf (der Agent spricht dann wieder HTTP, die Rolle löscht Zertifikat und Schlüssel vom Pi), in der App
wolAgentBaseURL zurück auf http://.
Fehlersuche
kubectl -n kube-system get certificate homeserver-wildcard-tls # READY=True?
kubectl -n kube-system describe certificate homeserver-wildcard-tls
kubectl -n cert-manager get pods
kubectl get clusterissuer
kubectl -n cert-manager logs deploy/cert-manager --tail=100
echo | openssl s_client -connect <host>:443 -servername <host> -CAfile pki/homeserver-root-ca.pem 2>/dev/null | openssl x509 -noout -subject -dates -ext subjectAltName
| Symptom | Ursache | Lösung |
|---|---|---|
| Browser: Zertifikat nicht vertrauenswürdig | Root-CA nicht auf dem Gerät installiert und aktiviert | Abschnitt „Client-Geräte (Vertrauensspeicher)“ |
Browser: falscher Name (NET::ERR_CERT_COMMON_NAME_INVALID) |
Host nicht in der SAN-Liste | Host in dnsNames ergänzen (Abschnitt „Neuen Host hinzufügen“) |
Certificate bleibt READY=False |
ClusterIssuer nicht bereit, CA-Keypair-Secret fehlt |
kubectl describe certificate, kubectl get clusterissuer, Secret homeserver-ca-keypair (Abschnitt „Rollout“) |
| Zertifikat wird nicht erneuert | cert-manager nicht bereit oder Issuer-Fehler | kubectl -n cert-manager logs deploy/cert-manager. Erneuerung erfolgt 30 Tage vor Ablauf (renewBefore: 720h, Gültigkeit 90 Tage) |
Traefik zeigt TRAEFIK DEFAULT CERT |
TLSStore verweist auf ein fehlendes Secret |
Traefik-Konfiguration |
| iOS-App meldet Verbindungsfehler | App prüft nur gegen die gebündelte CA, Server-CA abweichend, CA-Datei in der App veraltet | iOS: Verbindung und Sicherheit |
| Root-CA läuft ab (10-Jahres-Zyklus) oder Schlüssel kompromittiert | CA-Wechsel | Abschnitt „Neuen Host hinzufügen / Zertifikat erneuern“, letzter Absatz: Root-CA ersetzen, Keypair-Secret überschreiben, alle Clients neu installieren, pki/homeserver-root-ca.pem in capulus-core und capulus-ios aktualisieren |
| PROD, ENTW oder WoL-Agent zeigen Zertifikatsfehler | eigene Zertifikate je Ziel | Abschnitte „PROD-Cluster“, „Zertifikat für ArgoCD auf der ENTW-VM“, „Zertifikat für den WoL-Agent auf dem Vereinsheim-Pi“ |
| cert-manager-Namespace bekommt eine unerwünschte NetworkPolicy | Namespace im falschen Bootstrap-Tier | Abschnitt „cert-manager-Namespace: Infrastruktur, kein App-Tier“ |
Allgemeine Fehlersuche: zentrale Fehlersuche.