Diagnose & Verifizierung

Diese Seite stellt eine mehrschichtige UAT-Verifizierungsmatrix zur Ende-zu-Ende-Validierung Ihrer Clientseitigen Abwehr-Bereitstellung bereit. Jeder Testfall folgt der Infrastrukturabhängigkeitskette — von der DNS-Auflösung bis zur CSD-Telemetrie — sodass Sie systematisch nachweisen können, dass jede Komponente korrekt funktioniert.

Diese Befehle sind das API-Äquivalent der CSD-Konsolen-Walkthrough — verwenden Sie sie, wenn Sie über das Terminal verifizieren, die Überwachung automatisieren oder CSD-Funktionen ohne Benutzeroberfläche demonstrieren möchten.

Voraussetzungen

Richten Sie Ihre Umgebungsvariablen gemäß API-Automatisierung — Umgebungseinrichtung ein:

set -a && source .env && set +a

Alle nachstehenden Befehle verwenden das Platzhalterformat xTOKENx. Ersetzen Sie dieses durch Ihre Umgebungsvariablen ($F5XC_API_TOKEN, $F5XC_NAMESPACE usw.) oder verwenden Sie das interaktive Formular oben auf der Seite.

Hinweise zum API-Verhalten

Hinweis

PUT und DELETE geben bei HTTP 200 ein leeres \{\} zurück — dies ist die erwartete Erfolgsantwort, kein Fehler. Nur POST gibt das erstellte Objekt zurück. Listenendpunkte (z. B. /healthchecks) und einzelne GET-Endpunkte (z. B. /healthchecks/\{name\}) geben unterschiedliche Antwortstrukturen zurück — siehe API-Referenz — API-Konventionen für Details zu den korrekten jq-Pfaden für jeden Endpunkt.

Zeitbereichshilfen

Viele CSD-Endpunkte erfordern Epoch-Zeitstempel (Sekunden seit dem Unix-Epoch). Diese Einzeiler berechnen Start-/Endzeiten für gängige Bereiche.

Plattformübergreifend (macOS + Linux):

# Aktuelle Zeit als Epoch-Sekunden
NOW=$(date +%s)

# Vor 1 Stunde
START_1H=$(( NOW - 3600 ))

# Vor 24 Stunden
START_24H=$(( NOW - 86400 ))

# Vor 7 Tagen
START_7D=$(( NOW - 604800 ))

# Vor 30 Tagen
START_30D=$(( NOW - 2592000 ))

Voreinstellung	Sekunden	Shell-Ausdruck
1 Stunde	3.600	$(( $(date +%s) - 3600 ))
24 Stunden	86.400	$(( $(date +%s) - 86400 ))
7 Tage	604.800	$(( $(date +%s) - 604800 ))
30 Tage	2.592.000	$(( $(date +%s) - 2592000 ))

Hinweis

CSD-Endpunkte (/api/shape/csd/) verwenden Epoch-Sekunden (z. B. 1710000000). Zugriffsprotokolle-Endpunkte (/api/data/) verwenden ISO 8601-Zeitstempel (z. B. 2024-03-10T00:00:00Z). Die Befehle in jedem Abschnitt verwenden das korrekte Format für den jeweiligen Endpunkt.

Testfallformat

Jeder nachfolgende Test folgt dieser Struktur:

Feld	Beschreibung
Test-ID	Schichtnummer + fortlaufende ID (z. B. DNS-1, TLS-2)
Was es beweist	Die konkrete Infrastrukturtatsache, die verifiziert wird
Befehl	Ausführungsbereiter curl- oder dig-Befehl
BESTANDEN / FEHLGESCHLAGEN	Erwartete Ausgabe für gesunden vs. fehlerhaften Zustand
Behebung	Link zum relevanten Einrichtungs- oder Fehlerbehebungsabschnitt

---

Schicht 1: DNS-Auflösung

DNS ist die Grundlage — wenn die Domain nicht zur Load-Balancer-VIP aufgelöst wird, funktioniert nichts anderes.

DNS-1: A-Record-Auflösung

Was es beweist: Die Domain wird zur VIP-IP-Adresse des Load Balancers aufgelöst.

dig +short xF5XC_DOMAINNAMEx A

Ergebnis	Bedeutung
BESTANDEN — VIP-IP zurückgegeben (z. B. 72.19.3.185)	Domain wird zur virtuellen IP des LB aufgelöst
FEHLGESCHLAGEN — leere Antwort	DNS-A-Record nicht konfiguriert

Behebung: API-Automatisierung — Schritt 4: DNS konfigurieren

Tipp

Negativer DNS-Cache: Wenn die Domain zuvor NXDOMAIN zurückgegeben hat, können rekursive Resolver dieses Ergebnis zwischenspeichern. Verifizieren Sie gegen den autoritativen Nameserver, um veralteten Cache auszuschließen: dig +short xF5XC_DOMAINNAMEx A @ns1.f5clouddns.com oder verwenden Sie einen öffentlichen Resolver wie @8.8.8.8.

DNS-2: ACME-Challenge-Record

Was es beweist: Der ACME-Challenge-Record ist für die automatische TLS-Zertifikatbereitstellung vorhanden.

dig +short _acme-challenge.xF5XC_DOMAINNAMEx CNAME
dig +short _acme-challenge.xF5XC_DOMAINNAMEx TXT

Ergebnis	Bedeutung
BESTANDEN — CNAME zu *.autocerts.ves.volterra.io. (externes DNS)	ACME-Challenge-CNAME ist vorhanden
BESTANDEN — TXT-Record mit Domain-Wert (F5 Distributed Cloud (F5 XC) verwaltetes DNS)	Plattform-verwaltete ACME-Challenge per TXT-Record
FEHLGESCHLAGEN — beide leer	ACME-Record nicht konfiguriert; Zertifikat verbleibt in PreDomainChallengePending

Hinweis

Bei Verwendung von F5 XC verwaltetem DNS mit aktiviertem allow_http_lb_managed_records erstellt die Plattform automatisch einen TXT-Record (keinen CNAME) in der RR-Set-Gruppe x-ves-io-managed. Diese TXT-basierte ACME-Validierung wird intern verarbeitet. Bei Verwendung von externem DNS müssen Sie manuell einen CNAME zu *.autocerts.ves.volterra.io erstellen.

Behebung: Für externes DNS: CNAME erstellen: _acme-challenge.xF5XC_DOMAINNAMEx → *.autocerts.ves.volterra.io. Für F5 XC verwaltetes DNS: allow_http_lb_managed_records in der DNS-Zone aktivieren — siehe DNS-4. Siehe API-Automatisierung — Schritt 4.

DNS-3: Nameserver-Autorität

Was es beweist: Ob F5 XC der autoritative DNS-Anbieter für die Root-Domain ist.

dig +short NS xF5XC_ROOT_DOMAINx

Ergebnis	Bedeutung
Enthält ns1.f5clouddns.com und ns2.f5clouddns.com	F5 XC verwaltetes DNS — Records können automatisch erstellt werden
Andere Nameserver	Externes DNS — Records müssen manuell erstellt werden

Behebung: API-Automatisierung — DNS-Autorität erkennen

DNS-4: F5 XC verwaltete Records aktiviert

Was es beweist: Die F5 XC-DNS-Zone erlaubt die automatische Record-Erstellung für Load Balancer (nur F5 XC verwaltetes DNS).

curl -s \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/dns/namespaces/system/dns_zones/xF5XC_ROOT_DOMAINx" \
  | jq '.spec.primary.allow_http_lb_managed_records'

Ergebnis	Bedeutung
BESTANDEN — true	Plattform erstellt automatisch A- und ACME-Records für LBs
FEHLGESCHLAGEN — false oder null	Verwaltete Records deaktiviert; per Zone-Update aktivieren

Achtung

Ein false-Ergebnis ist eine häufige Fehlkonfiguration bei der Verwendung von F5 XC verwaltetem DNS. Ohne aktivierte verwaltete Records kann die Plattform weder den A-Record (der auf die VIP zeigt) noch den ACME-Challenge-CNAME (erforderlich für die TLS-Zertifikatbereitstellung) automatisch erstellen. Dies führt dazu, dass der Load Balancer in VIRTUAL_HOST_PENDING_A_RECORD verbleibt und das Zertifikat in PreDomainChallengePending stecken bleibt. Aktivieren Sie verwaltete Records in der DNS-Zone oder erstellen Sie die Records manuell.

Behebung: API-Automatisierung — Option A: F5 XC verwaltetes DNS

---

Schicht 2: TLS-Zertifikat

Nach der DNS-Auflösung muss der Load Balancer über ein gültiges TLS-Zertifikat verfügen.

TLS-1: Zertifikatsstatus

Hinweis

Dieser Test gilt nur für den HTTPS-LB (${F5XC_LB_NAME}-https). Der HTTP-LB verfügt über kein Zertifikat. In Demo-Umgebungen ist TLS-1 informativ — wenn AutoCertDomainRateLimited angezeigt wird, läuft die Demo normal weiter und verwendet http://-URLs über den HTTP-LB.

Was es beweist: Das automatische TLS-Zertifikat wurde für den HTTPS-LB ausgestellt.

curl -s \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/http_loadbalancers/xF5XC_LB_NAMEx-https" \
  | jq '.spec.cert_state'

Ergebnis	Bedeutung
BESTANDEN — "CertificateValid" oder "AutoCertRenewing"	Zertifikat ist gültig und aktiv
WARNUNG — "DomainChallengePending" oder "DomainChallengeStarted"	ACME-Challenge läuft — 5–10 Minuten warten
INFO — "AutoCertDomainRateLimited"	Let’s-Encrypt-Ratenlimit erreicht — in Demo-Umgebungen erwartet, betrifft HTTP-LB nicht
FEHLGESCHLAGEN — "PreDomainChallengePending"	ACME-Challenge-Record fehlt — siehe DNS-2

Behebung: Stellen Sie sicher, dass der ACME-Challenge-Record vorhanden ist (CNAME für externes DNS oder verwaltete Records für F5 XC DNS aktivieren). Die Zertifikatbereitstellung dauert 5–10 Minuten nach der Record-Konfiguration. Wenn nach 15 Minuten noch kein Fortschritt erkennbar ist, siehe Zertifikat feststeckend — Saubere Neuerstellung. Bei Ratenlimitierung ist der HTTP-LB nicht betroffen.

TLS-2: Zertifikatsdetails

Was es beweist: Das Zertifikat deckt die erwartete Domain ab und zeigt Ablaufinformationen an. Gilt nur für den HTTPS-LB.

curl -s \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/http_loadbalancers/xF5XC_LB_NAMEx-https" \
  | jq '{
    cert_state: .spec.cert_state,
    auto_cert_info: .spec.auto_cert_info
  }'

Ergebnis	Bedeutung
BESTANDEN — auto_cert_info enthält dns_records und Zertifikatsmetadaten	Details zur Zertifikatbereitstellung verfügbar
FEHLGESCHLAGEN — auto_cert_info ist null oder leer	Zertifikat noch nicht bereitgestellt

TLS-3: Live-TLS-Handshake

Was es beweist: Das TLS-Zertifikat ist gültig und der Handshake wird vom Client abgeschlossen. Gilt nur, wenn der HTTPS-LB über ein gültiges Zertifikat verfügt.

Hinweis

Verwenden Sie in Demo-Umgebungen curl http://xF5XC_DOMAINNAMEx/ (HTTP, nicht HTTPS) als primären Verifizierungspfad. Der TLS-Handshake-Test ist optional — er funktioniert nur, wenn das HTTPS-LB-Zertifikat CertificateValid ist.

curl -sv "https://xF5XC_DOMAINNAMEx/" 2>&1 \
  | grep -E 'SSL connection|subject:|expire date:|issuer:'

Ergebnis	Bedeutung
BESTANDEN — zeigt SSL connection using TLSv1.3, gültigen Betreff und Ablaufdatum	Ende-zu-Ende-TLS funktioniert
FEHLGESCHLAGEN — Verbindung abgelehnt oder Zertifikatsfehler	DNS-Auflösung und Zertifikatsstatus prüfen; bei Ratenlimitierung stattdessen HTTP verwenden

TLS-4: ACME-Record-Ziel vom LB

Was es beweist: Der HTTPS-Load-Balancer meldet das korrekte ACME-Ziel für die Zertifikatsvalidierung.

curl -s \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/http_loadbalancers/xF5XC_LB_NAMEx-https" \
  | jq '{
    vip_ip: .spec.dns_info[0].ip_address,
    acme_target: .spec.auto_cert_info.dns_records
  }'

Ergebnis	Bedeutung
BESTANDEN — vip_ip und acme_target befüllt	DNS-Records können gegen diese Werte verifiziert werden
FEHLGESCHLAGEN — null-Werte	LB hat möglicherweise https_auto_cert nicht konfiguriert

---

Schicht 3: HTTP-Load-Balancer

Der Load Balancer muss betriebsbereit und korrekt konfiguriert sein.

LB-1: Betriebsstatus

Was es beweist: Der HTTP-Load-Balancer (primär) ist vollständig betriebsbereit und nimmt Datenverkehr an.

Hinweis

HTTP-LB ist das primäre Verifizierungsziel. Überprüfen Sie in Demo-Umgebungen zunächst den HTTP-LB (${F5XC_LB_NAME}-http) — er erreicht VIRTUAL_HOST_READY, sobald DNS aufgelöst wird, ohne Zertifikatsabhängigkeit. Verwenden Sie curl http://xF5XC_DOMAINNAMEx/ für die primäre HTTP-basierte Verifizierung.

curl -s \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/http_loadbalancers/xF5XC_LB_NAMEx-http" \
  | jq '.spec.state'

Ergebnis	Bedeutung
BESTANDEN — "VIRTUAL_HOST_READY"	LB ist betriebsbereit
FEHLGESCHLAGEN — "VIRTUAL_HOST_PENDING_A_RECORD"	DNS-A-Record nicht konfiguriert — siehe DNS-1

Behebung: LB feststeckend in VIRTUAL_HOST_PENDING_A_RECORD

LB-2: Domain-Konfiguration

Was es beweist: Der HTTP-Load-Balancer ist für die korrekte(n) Domain(s) konfiguriert.

curl -s \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/http_loadbalancers/xF5XC_LB_NAMEx-http" \
  | jq '.spec.domains'

Ergebnis	Bedeutung
BESTANDEN — Array enthält Ihren FQDN (z. B. ["app.example.com"])	LB ist für die erwartete Domain konfiguriert
FEHLGESCHLAGEN — fehlende oder falsche Domain	LB-Spec mit der korrekten Domain aktualisieren

LB-3: CSD am LB aktiviert

Was es beweist: Clientseitige Abwehr ist am Load Balancer mit der korrekten JS-Injektionsrichtlinie aktiviert.

curl -s \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/http_loadbalancers/xF5XC_LB_NAMEx-http" \
  | jq '{
    csd_enabled: (if .spec.client_side_defense then true else false end),
    js_policy: .spec.client_side_defense.policy
  }'

Ergebnis	Bedeutung
BESTANDEN — csd_enabled: true mit js_insert_all_pages in der Richtlinie	CSD aktiv mit JS-Injektion auf allen Seiten
FEHLGESCHLAGEN — csd_enabled: false	CSD nicht am LB konfiguriert

Behebung: API-Referenz — CSD an einem Load Balancer aktivieren

LB-4: Standard-Routen-Pool

Was es beweist: Der Load Balancer referenziert den korrekten Ursprungspool mit erwartetem Gewicht und Priorität.

curl -s \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/http_loadbalancers/xF5XC_LB_NAMEx-http" \
  | jq '.spec.default_route_pools[] | {
    pool: .pool.name,
    namespace: .pool.namespace,
    weight: .weight,
    priority: .priority
  }'

Ergebnis	Bedeutung
BESTANDEN — zeigt Ihren Ursprungspoolnamen mit Gewicht/Priorität	LB leitet an das korrekte Backend weiter
FEHLGESCHLAGEN — leerer oder falscher Pool	LB-default_route_pools-Konfiguration aktualisieren

LB-5: Bereitstellungsstatus (standortbezogene Bedingungen)

Was es beweist: Der Load Balancer ist bereitgestellt und meldet gesunde Bedingungen an allen Standorten.

curl -s \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/http_loadbalancers/xF5XC_LB_NAMEx-http" \
  | jq '{
    state: .spec.state,
    dns_info: .spec.dns_info,
    host_name: .spec.host_name
  }'

Ergebnis	Bedeutung
BESTANDEN — state ist VIRTUAL_HOST_READY, dns_info befüllt	LB vollständig bereitgestellt mit zugewiesener VIP
FEHLGESCHLAGEN — ausstehender Status oder leeres dns_info	DNS- oder Zertifikatsproblem blockiert Bereitstellung

Tipp

Wenn der LB nicht im Status VIRTUAL_HOST_READY ist, prüfen Sie .status[].virtual_host_status.error_description auf die gleichen Fehlerdetails, die in der F5 XC-Konsolen-Benutzeroberfläche angezeigt werden:

curl -s \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/http_loadbalancers/xF5XC_LB_NAMEx-http" \
  | jq '[.status[]? | select(.virtual_host_status != null) | .virtual_host_status | {state, error_description, suggested_action}]'

LB-6: Vollständige LB-Zusammenfassung

Was es beweist: Umfassende Momentaufnahme beider LB-Konfigurationen zur Fehlerbehebung.

HTTP-LB (primär):

curl -s \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/http_loadbalancers/xF5XC_LB_NAMEx-http" \
  | jq '{
    name: .metadata.name,
    state: .spec.state,
    domains: .spec.domains,
    csd_enabled: (if .spec.client_side_defense then true else false end),
    route_pools: [.spec.default_route_pools[] | .pool.name],
    advertise: (if .spec.advertise_on_public_default_vip then "public_default_vip" else "custom" end)
  }'

HTTPS-LB (sekundär — enthält Zertifikatsstatus):

curl -s \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/http_loadbalancers/xF5XC_LB_NAMEx-https" \
  | jq '{
    name: .metadata.name,
    state: .spec.state,
    cert_state: .spec.cert_state,
    domains: .spec.domains,
    csd_enabled: (if .spec.client_side_defense then true else false end),
    route_pools: [.spec.default_route_pools[] | .pool.name]
  }'

---

Schicht 4: Ursprungspool

Der Ursprungspool definiert die Backend-Server, an die der Load Balancer den Datenverkehr weiterleitet.

OP-1: Ursprungspool-Konfiguration

Was es beweist: Der Ursprungspool ist mit dem korrekten Backend-Server, Port und LB-Algorithmus vorhanden.

curl -s \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/origin_pools/xF5XC_ORIGIN_POOLx" \
  | jq '{
    name: .metadata.name,
    origin_servers: [.spec.origin_servers[] | {
      ip: .public_ip.ip,
      labels: .labels
    }],
    port: .spec.port,
    lb_algorithm: .spec.loadbalancer_algorithm,
    endpoint_selection: .spec.endpoint_selection
  }'

Ergebnis	Bedeutung
BESTANDEN — zeigt korrekte IP, Port und Algorithmus	Ursprungspool korrekt konfiguriert
FEHLGESCHLAGEN — 404 oder falsche Werte	Ursprungspool fehlt oder ist falsch konfiguriert

Behebung: API-Automatisierung — Schritt 2: Ursprungspool erstellen

OP-2: TLS zum Ursprungsserver

Was es beweist: Ob TLS für die Verbindung zwischen LB und Ursprungsserver konfiguriert ist.

curl -s \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/origin_pools/xF5XC_ORIGIN_POOLx" \
  | jq '{
    tls_config: (if .spec.no_tls then "no_tls (plaintext)" elif .spec.use_tls then "use_tls (encrypted)" else "unknown" end)
  }'

Ergebnis	Bedeutung
no_tls (plaintext)	LB verbindet sich über HTTP mit dem Ursprungsserver (erwartet für Juice-Shop-Demo)
use_tls (encrypted)	LB verbindet sich über HTTPS mit dem Ursprungsserver

OP-3: Integritätsprüfungszuordnung

Was es beweist: Der Ursprungspool hat die korrekte Integritätsprüfung verknüpft (falls zutreffend).

curl -s \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/origin_pools/xF5XC_ORIGIN_POOLx" \
  | jq '.spec.healthcheck'

Ergebnis	Bedeutung
BESTANDEN — Array mit Integritätsprüfungsreferenz (Name, Namespace, Art)	Integritätsprüfung ist verknüpft
OK — leeres Array []	Keine Integritätsprüfung (akzeptabel — CSD erfordert keine)
FEHLGESCHLAGEN — Integritätsprüfung erwartet, aber Array ist leer	Integritätsprüfung wurde zum Erstellungszeitpunkt nicht gefunden — siehe Integritätsprüfung nicht verknüpft

OP-4: Ursprungsserver-Konnektivität

Was es beweist: Der Ursprungsserver ist vom Client aus erreichbar (testet nicht den LB-zu-Ursprung-Pfad).

curl -s -o /dev/null -w '%{http_code}' \
  "http://xF5XC_ORIGIN_IPx:xF5XC_ORIGIN_PORTx/"

Ergebnis	Bedeutung
BESTANDEN — 200 (oder anderer gültiger HTTP-Code)	Ursprungsserver antwortet
FEHLGESCHLAGEN — 000 oder Verbindung abgelehnt	Ursprungsserver von diesem Netzwerk aus nicht erreichbar

Hinweis

Dies testet die direkte Client-zu-Ursprung-Konnektivität. Der LB-zu-Ursprung-Pfad kann einen anderen Netzwerkpfad verwenden. Ein Fehler hier bedeutet nicht zwingend, dass der LB den Ursprungsserver nicht erreichen kann.

---

Schicht 5: Integritätsprüfung

Integritätsprüfungen überwachen die Backend-Verfügbarkeit. Sie sind für CSD optional, aber für Produktionsbereitstellungen nützlich.

HC-1: Integritätsprüfungskonfiguration

Was es beweist: Die Integritätsprüfung ist mit dem korrekten Typ, Pfad, Timing und Schwellenwerten vorhanden.

curl -s \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/healthchecks/xF5XC_HC_NAMEx" \
  | jq '{
    name: .metadata.name,
    type: (if .spec.http_health_check then "HTTP" elif .spec.tcp_health_check then "TCP" else "unknown" end),
    path: .spec.http_health_check.path,
    expected_status: .spec.http_health_check.expected_status_codes,
    timeout: .spec.timeout,
    interval: .spec.interval,
    unhealthy_threshold: .spec.unhealthy_threshold,
    healthy_threshold: .spec.healthy_threshold
  }'

Ergebnis	Bedeutung
BESTANDEN — zeigt HTTP-Typ mit Pfad / und erwartetem 200	Integritätsprüfung korrekt konfiguriert
FEHLGESCHLAGEN — 404-Antwort	Integritätsprüfung existiert nicht (wurde möglicherweise übersprungen — siehe Phase 1 Schritt 1)

HC-2: Alle Integritätsprüfungen auflisten

Was es beweist: Listet alle Integritätsprüfungen im Namespace auf, um Benennung und Anzahl zu verifizieren.

curl -s \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/healthchecks" \
  | jq -r '
    ["NAME", "NAMESPACE", "DESCRIPTION"],
    (.items[] | [
      .name,
      .namespace,
      (.description | if length == 0 then "—" else . end)
    ])
    | @tsv' | column -t

Hinweis

Der Listenendpunkt gibt nur Zusammenfassungsdaten zurück (Name, Namespace, Beschreibung). Um vollständige Konfigurationsdetails (Typ, Pfad, Intervall, Timeout) zu sehen, fragen Sie eine einzelne Integritätsprüfung mit HC-1 ab.

---

Schicht 6: CSD-Konfiguration

CSD muss auf Mandantenebene aktiviert sein und den JavaScript-Injektionstag konfiguriert haben.

CSD-1: Mandanten-CSD-Status

Was es beweist: CSD ist für den Mandanten konfiguriert und aktiviert.

curl -s \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/shape/csd/namespaces/xF5XC_NAMESPACEx/status" \
  | jq '{isConfigured, isEnabled}'

Ergebnis	Bedeutung
BESTANDEN — beide true	CSD ist für diesen Mandanten aktiv
FEHLGESCHLAGEN — isConfigured: false	CSD nicht auf Mandantenebene aktiviert — F5 XC-Administrator kontaktieren
FEHLGESCHLAGEN — isEnabled: false	CSD konfiguriert, aber nicht aktiv

CSD-2: JS-Injektionstag

Was es beweist: Der CSD-JavaScript-Injektionstag ist generiert und zur Injektion bereit.

curl -s \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/shape/csd/namespaces/xF5XC_NAMESPACEx/js_configuration" \
  | jq '{has_script_tag: (.scriptTag | length > 0)}'

Ergebnis	Bedeutung
BESTANDEN — has_script_tag: true	JS-Injektionstag ist konfiguriert
FEHLGESCHLAGEN — has_script_tag: false	Kein Script-Tag — verifizieren Sie, dass CSD aktiviert ist und eine geschützte Domain registriert ist

CSD-3: JS-Tag-Inhalt

Was es beweist: Zeigt den vollständigen Script-Tag zur Verifizierung oder manuellen Injektion.

curl -s \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/shape/csd/namespaces/xF5XC_NAMESPACEx/js_configuration" \
  | jq '.scriptTag'

CSD-4: Registrierung geschützter Domains

Was es beweist: Die Root-Domain ist als CSD-geschützte Domain beim Mandanten registriert.

curl -s \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/shape/csd/namespaces/xF5XC_NAMESPACEx/protected_domains" \
  | jq '.items[] | {name, namespace, description}'

Ergebnis	Bedeutung
BESTANDEN — zeigt ein Element mit einem nicht leeren name	Domain ist geschützt
FEHLGESCHLAGEN — Elemente haben leere name- und namespace-Felder	Keine geschützten Domains registriert — siehe Phase 1 Schritt 6

Hinweis

Der Listenendpunkt für geschützte Domains gibt Zusammenfassungsdaten zurück. Elemente mit vollständig leeren Feldern zeigen an, dass keine geschützten Domains konfiguriert sind. Der CSD-JavaScript-Tag (CSD-2) ist ein zuverlässigerer Indikator dafür, dass der Domainschutz aktiv ist.

CSD-5: Live-JS-Injektionsverifizierung

Was es beweist: Das CSD-JavaScript wird tatsächlich in Seitenantworten injiziert, die vom Load Balancer bereitgestellt werden.

curl -s "http://xF5XC_DOMAINNAMEx/" \
  | grep -oE '(zeronaught|shape)\.com[^"]*' | head -1

Ergebnis	Bedeutung
BESTANDEN — gibt ein zeronaught.com- oder shape.com-URL-Fragment zurück (z. B. zeronaught.com/__imp_apg__/js/...)	CSD-JavaScript wird in Seiten injiziert
FEHLGESCHLAGEN — leere Ausgabe	JS nicht injiziert — LB-3 und CSD-1 prüfen

---

Schicht 7: Datenverkehrsverifizierung

Verifizieren Sie, dass live Datenverkehr den Load Balancer erreicht und korrekt verarbeitet wird.

TV-1: Anfragezählung (letzte 24 Stunden)

Was es beweist: Datenverkehr erreicht den Load Balancer. Null Ergebnisse bedeutet, dass kein Datenverkehr eingeht.

curl -s -X POST \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  -H "Content-Type: application/json" \
  -d '{
    "start_time": "'"$(date -u -d '24 hours ago' +%Y-%m-%dT%H:%M:%SZ 2>/dev/null || date -u -v-24H +%Y-%m-%dT%H:%M:%SZ)"'",
    "end_time": "'"$(date -u +%Y-%m-%dT%H:%M:%SZ)"'"
  }' \
  "xF5XC_API_URLx/api/data/namespaces/xF5XC_NAMESPACEx/access_logs/aggregation" \
  | jq '{total_requests: .total_hits}'

Ergebnis	Bedeutung
BESTANDEN — total_requests ist eine nicht-leere Zeichenkette (z. B. "380")	Datenverkehr fließt durch den LB
FEHLGESCHLAGEN — "0" oder keine Daten	Kein Datenverkehr erreicht den LB — DNS-1 und LB-1 prüfen

Hinweis

Der total_hits-Wert wird als Zeichenkette zurückgegeben (z. B. "380"), nicht als Ganzzahl. Der Namespace wird aus dem URL-Pfad abgeleitet — fügen Sie ihn nicht in den Anforderungstext ein.

TV-2: Statuscodeverteilung

Was es beweist: Die Aufschlüsselung der Antwortstatuscodes deckt Fehlermuster auf.

curl -s -X POST \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  -H "Content-Type: application/json" \
  -d '{
    "start_time": "'"$(date -u -d '24 hours ago' +%Y-%m-%dT%H:%M:%SZ 2>/dev/null || date -u -v-24H +%Y-%m-%dT%H:%M:%SZ)"'",
    "end_time": "'"$(date -u +%Y-%m-%dT%H:%M:%SZ)"'",
    "sort": "DESCENDING",
    "limit": 100
  }' \
  "xF5XC_API_URLx/api/data/namespaces/xF5XC_NAMESPACEx/access_logs" \
  | jq -r '
    [.logs[] | fromjson | .rsp_code_class]
    | group_by(.) | map({class: .[0], count: length})
    | sort_by(-.count)
    | ["STATUS_CLASS", "COUNT"], (.[] | [.class, .count])
    | @tsv' | column -t

Hinweis

Der Aggregationsendpunkt unterstützt keine terms-Einteilung — aggs gibt immer leer zurück. Dieser Befehl ruft die neuesten 100 Protokolleinträge ab und berechnet die Verteilung clientseitig. Jeder Protokolleintrag ist eine JSON-Zeichenkette, die mit fromjson geparst werden muss.

Erwartete Ausgabe für eine gesunde Website:

STATUS_CLASS                  COUNT
2xx                           82
downstream_remote_disconnect  18

Ergebnis	Bedeutung
BESTANDEN — Mehrheit 2xx	Website liefert erfolgreiche Antworten
WARNUNG — hohe 4xx-Anzahl	Client-Fehler (fehlerhafte URLs, fehlende Ressourcen)
FEHLGESCHLAGEN — hohe 5xx-Anzahl	Serverfehler — Ursprungsserver-Integrität prüfen

Die Klasse downstream_remote_disconnect zeigt an, dass der Client die Verbindung vor Abschluss der Antwort getrennt hat (häufig bei Long-Polling oder WebSocket-Upgrade-Anfragen).

TV-3: Aktuelle Anfragebeispiele

Was es beweist: Einzelne Anfragen werden mit korrekten Feldern protokolliert.

curl -s -X POST \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  -H "Content-Type: application/json" \
  -d '{
    "start_time": "'"$(date -u -d '1 hour ago' +%Y-%m-%dT%H:%M:%SZ 2>/dev/null || date -u -v-1H +%Y-%m-%dT%H:%M:%SZ)"'",
    "end_time": "'"$(date -u +%Y-%m-%dT%H:%M:%SZ)"'",
    "sort": "DESCENDING",
    "limit": 10
  }' \
  "xF5XC_API_URLx/api/data/namespaces/xF5XC_NAMESPACEx/access_logs" \
  | jq -r '
    ["TIMESTAMP", "METHOD", "PATH", "STATUS", "SRC_IP"],
    (.logs[] | fromjson | [.["@timestamp"], .method, .req_path, .rsp_code, .src_ip])
    | @tsv' | column -t

Achtung

Jeder Eintrag im .logs[]-Array ist eine JSON-Zeichenkette, kein geparste Objekt. Sie müssen in jq durch fromjson leiten, bevor Sie auf Felder zugreifen (z. B. .logs[] | fromjson | .method).

TV-4: CSD-JS-Injektion in Zugriffsprotokollen

Was es beweist: Zugriffsprotokolle bestätigen, dass CSD-JavaScript in Antworten injiziert wird.

curl -s -X POST \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  -H "Content-Type: application/json" \
  -d '{
    "start_time": "'"$(date -u -d '1 hour ago' +%Y-%m-%dT%H:%M:%SZ 2>/dev/null || date -u -v-1H +%Y-%m-%dT%H:%M:%SZ)"'",
    "end_time": "'"$(date -u +%Y-%m-%dT%H:%M:%SZ)"'",
    "sort": "DESCENDING",
    "limit": 20
  }' \
  "xF5XC_API_URLx/api/data/namespaces/xF5XC_NAMESPACEx/access_logs" \
  | jq '[.logs[] | fromjson | select(.csd_js_injection == "true")] | length as $injected |
    {injected_count: $injected, total_sampled: 20}'

Ergebnis	Bedeutung
BESTANDEN — injected_count > 0	CSD-JS wird in Seitenantworten injiziert
FEHLGESCHLAGEN — injected_count: 0	JS nicht injiziert — CSD-1 und LB-3 prüfen

Hinweis

Das Feld csd_js_injection ist nur bei Protokolleinträgen vorhanden, bei denen eine Injektion stattgefunden hat. Bei Tests hatten 40 % der gesampleten Protokolleinträge csd_js_injection: "true" (HTML-Seitenanfragen), während 60 % das Feld nicht enthielten (statische Assets wie .ico-, .js-, .css-Dateien und WebSocket-Verbindungen). Bei HTML-Seitenanfragen sollte eine Injektion stattfinden; bei API-Aufrufen und statischen Asset-Anfragen in der Regel nicht.

TV-5: Ende-zu-Ende-Konnektivitätstest

Was es beweist: Eine vollständige Anfrage fließt vom Client durch DNS, LB und Ursprungsserver und gibt eine gültige Antwort zurück.

curl -sv "http://xF5XC_DOMAINNAMEx/" 2>&1 \
  | grep -E 'Connected to|< HTTP|< content-type'

Ergebnis	Bedeutung
BESTANDEN — zeigt Verbindung, HTTP 200 und Content-Type	Vollständiger Stack ist betriebsbereit
FEHLGESCHLAGEN — Verbindung abgelehnt oder DNS-Fehler	Fehlerbehebung bei Schicht 1: DNS beginnen

Tipp

Für HTTPS-Ende-zu-Ende-Tests (nur wenn das HTTPS-LB-Zertifikat gültig ist) verwenden Sie curl -sv "https://xF5XC_DOMAINNAMEx/" und prüfen Sie die Ausgabe auf SSL connection.

---

Schicht 8: CSD-Telemetrie & Domain-Richtlinie

Diese Befehle fragen dieselben Daten ab, die im Dashboard, der Skriptliste, den Formularfeldern und den Netzwerkansichten der CSD-Konsole angezeigt werden.

TEL-1: Skriptinventar

Was es beweist: CSD erkennt und katalogisiert Skripte, die auf der geschützten Domain ausgeführt werden.

NOW=$(date +%s)
START=$(( NOW - 604800 ))

curl -s -X POST \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  -H "Content-Type: application/json" \
  -d "{
    \"startTime\": \"${START}\",
    \"endTime\": \"${NOW}\"
  }" \
  "xF5XC_API_URLx/api/shape/csd/namespaces/xF5XC_NAMESPACEx/scripts" \
  | jq -r '
    ["SCRIPT", "RISK", "STATUS", "FIELDS", "USERS"],
    (.scripts[] | [
      (.script_name | if length > 50 then .[:47] + "..." else . end),
      .risk_level,
      .status,
      (.form_fields_read // 0),
      (.affected_users_count // 0)
    ])
    | @tsv' | column -t

Ergebnis	Bedeutung
BESTANDEN — Skripte mit Risikostufen aufgelistet	CSD überwacht Skripte aktiv
FEHLGESCHLAGEN — leeres Array	Siehe Fehlerbehebung: Leeres Skript-Array

Tipp

Skriptnamen sind vollständige URLs und können sehr lang sein. Der obige Befehl kürzt Namen auf 50 Zeichen für die Lesbarkeit im Terminal. Entfernen Sie den Kürzungsfilter, um vollständige URLs zu sehen.

TEL-2: Erkannte Domains

Was es beweist: CSD hat Skript-Quelldomains erkannt und nach Status klassifiziert.

curl -s \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/shape/csd/namespaces/xF5XC_NAMESPACEx/detected_domains" \
  | jq '{
    summary: {
      action_needed: .domain_summary.actionNeededCount.count,
      mitigated: .domain_summary.mitigatedDomains.count,
      allowed: .domain_summary.allowedDomains.count,
      total: .domain_summary.totalDomains.count
    },
    domains: [.domains_list[] | {
      domain: .domain,
      category: .category,
      status: .status,
      first_seen: (.firstSeenDate | tonumber | todate),
      latest_seen: (.latestSeenDate | tonumber | todate)
    }]
  }'

Ergebnis	Bedeutung
BESTANDEN — total > 0 mit aufgelisteten Domains	CSD verfolgt Skript-Domains
WARNUNG — action_needed > 0	Einige Domains benötigen Überprüfung
FEHLGESCHLAGEN — leere Antwort	Keine Telemetriedaten — CSD-5 prüfen

TEL-3: Domain-Richtlinienstatus

Was es beweist: Zeigt die Verteilung erlaubter vs. mitigierter Domains und ob die Richtlinie konsistent ist.

curl -s \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/shape/csd/namespaces/xF5XC_NAMESPACEx/detected_domains" \
  | jq '{
    action_needed: .domain_summary.actionNeededCount.count,
    mitigated: .domain_summary.mitigatedDomains.count,
    allowed: .domain_summary.allowedDomains.count,
    total: .domain_summary.totalDomains.count,
    domains_needing_action: [.domains_list[] | select(.status == "AN") | .domain]
  }'

Ergebnis	Bedeutung
BESTANDEN — action_needed: 0	Alle Domains wurden überprüft und klassifiziert
WARNUNG — action_needed > 0	In domains_needing_action aufgeführte Domains benötigen Überprüfung

TEL-4: Formularfeld-Inventar

Was es beweist: CSD hat Formularfelder erkannt, die Skripte lesen, mit Sensibilitätsklassifizierung.

NOW=$(date +%s)
START=$(( NOW - 604800 ))

curl -s \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/shape/csd/namespaces/xF5XC_NAMESPACEx/formFields?startTime=${START}&endTime=${NOW}" \
  | jq -r '
    ["FIELD", "SENSITIVITY", "SCRIPTS"],
    (.form_fields[] | [
      .name,
      .analysis,
      (.scripts_count // 0)
    ])
    | @tsv' | column -t

Ergebnis	Bedeutung
BESTANDEN — Formularfelder mit Sensibilität aufgelistet	CSD verfolgt Formularfeldzugriffe
INFO — leeres Array	Keine Formularfelder erkannt (erwartet, wenn keine Formulare auf der Website)

TEL-5: Skript-Detailanalyse

Was es beweist: Detaillierte Informationen zu einem bestimmten Skript einschließlich Risiko, Verhaltensweisen und Netzwerkinteraktionen.

Ermitteln Sie zunächst eine Skript-ID aus TEL-1 und fragen Sie dann deren Details ab:

SCRIPT_ID="your-script-id"

# Übersicht (Risikostufe, Typ, Quelldomain)
curl -s \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/shape/csd/namespaces/xF5XC_NAMESPACEx/scripts/${SCRIPT_ID}/dashboard" \
  | jq '{script_name, risk_level, type, source_domain, status}'

# Verhaltensweisen im Zeitverlauf
curl -s \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/shape/csd/namespaces/xF5XC_NAMESPACEx/scripts/${SCRIPT_ID}/behaviors" \
  | jq '.behaviors'

# Netzwerkinteraktionen (Domains, mit denen das Skript kommuniziert)
curl -s \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/shape/csd/namespaces/xF5XC_NAMESPACEx/scripts/${SCRIPT_ID}/networkInteractions" \
  | jq '.network_interactions'

TEL-6: Betroffene Benutzer

Was es beweist: Listet Benutzer auf, die von einem bestimmten Skript betroffen sind, und zeigt das Ausmaß der Exposition.

SCRIPT_ID="your-script-id"
NOW=$(date +%s)
START=$(( NOW - 604800 ))

curl -s -X POST \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  -H "Content-Type: application/json" \
  -d "{
    \"startTime\": \"${START}\",
    \"endTime\": \"${NOW}\"
  }" \
  "xF5XC_API_URLx/api/shape/csd/namespaces/xF5XC_NAMESPACEx/scripts/${SCRIPT_ID}/affectedUsers" \
  | jq -r '
    ["IP_ADDRESS", "DEVICE_ID", "GEO", "CHANNEL", "USER_AGENT"],
    (.affected_users[] | [
      .ip_address,
      (.device_id | if length > 12 then .[:12] + "..." else . end),
      .geolocation,
      .channel,
      (.user_agent | if length > 30 then .[:27] + "..." else . end)
    ])
    | @tsv' | column -t

TEL-7: Skriptanzahl nach Risikostufe

Was es beweist: Aggregierte Risikoverteilung über alle erkannten Skripte.

NOW=$(date +%s)
START=$(( NOW - 604800 ))

curl -s -X POST \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  -H "Content-Type: application/json" \
  -d "{
    \"startTime\": \"${START}\",
    \"endTime\": \"${NOW}\"
  }" \
  "xF5XC_API_URLx/api/shape/csd/namespaces/xF5XC_NAMESPACEx/scripts" \
  | jq '[.scripts[] | .risk_level] | group_by(.) | map({risk_level: .[0], count: length}) | sort_by(-.count)'

Ergebnis	Bedeutung
BESTANDEN — alle No Risk	Keine riskanten Skripte erkannt
WARNUNG — Low Risk oder High Risk vorhanden	Markierte Skripte in TEL-5 überprüfen

TEL-8: Telemetrie-Aktualität

Was es beweist: CSD-Telemetriedaten sind aktuell und bestätigen aktive Überwachung.

curl -s \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/shape/csd/namespaces/xF5XC_NAMESPACEx/detected_domains" \
  | jq '{
    total_domains: .domain_summary.totalDomains.count,
    latest_update: (.domain_summary.totalDomains.lastUpdated // "unknown"),
    most_recent_domain: (.domains_list | sort_by(.latestSeenDate) | last | {
      domain: .domain,
      latest_seen: (.latestSeenDate | tonumber | todate)
    })
  }'

Ergebnis	Bedeutung
BESTANDEN — latest_seen liegt innerhalb der letzten 24 Stunden	Telemetrie erfasst aktiv Daten
WARNUNG — latest_seen ist älter als 24 Stunden	Datenverkehr wurde möglicherweise gestoppt oder CSD-Verarbeitung ist verzögert

---

Vollständiges Stack-Dashboard

Führen Sie einen einzelnen Befehl aus, der alle kritischen Integritätsindikatoren über alle Schichten prüft und eine Übersichtstabelle erstellt:

echo "=== CSD-Verifizierungs-Dashboard ==="
echo ""

# Schicht 1: DNS
DNS_A=$(dig +short xF5XC_DOMAINNAMEx A | head -1)
DNS_ACME=$(dig +short _acme-challenge.xF5XC_DOMAINNAMEx CNAME | head -1)

# Schichten 2-3: LB + TLS
LB=$(curl -s \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/http_loadbalancers/xF5XC_LB_NAMEx-http")
LB_HTTPS=$(curl -s \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/http_loadbalancers/xF5XC_LB_NAMEx-https")

LB_STATE=$(echo "$LB" | jq -r '.spec.state // "UNKNOWN"')
CERT_STATE=$(echo "$LB_HTTPS" | jq -r '.spec.cert_state // "UNKNOWN"')
CSD_ON_LB=$(echo "$LB" | jq -r 'if .spec.client_side_defense then "ENABLED" else "DISABLED" end')
DOMAINS=$(echo "$LB" | jq -r '.spec.domains | join(", ")')
ROUTE_POOL=$(echo "$LB" | jq -r '[.spec.default_route_pools[] | .pool.name] | join(", ")')

# Schicht 6: CSD-Status
CSD=$(curl -s \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/shape/csd/namespaces/xF5XC_NAMESPACEx/status")

CSD_CONFIGURED=$(echo "$CSD" | jq -r '.isConfigured // false')
CSD_ENABLED=$(echo "$CSD" | jq -r '.isEnabled // false')

# Schicht 6: JS-Konfiguration
JS_TAG=$(curl -s \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/shape/csd/namespaces/xF5XC_NAMESPACEx/js_configuration" \
  | jq -r 'if (.scriptTag | length) > 0 then "PRESENT" else "MISSING" end')

# Schicht 7: Datenverkehr (letzte 24 Std.)
TRAFFIC=$(curl -s -X POST \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  -H "Content-Type: application/json" \
  -d "{
    \"start_time\": \"$(date -u -d '24 hours ago' +%Y-%m-%dT%H:%M:%SZ 2>/dev/null || date -u -v-24H +%Y-%m-%dT%H:%M:%SZ)\",
    \"end_time\": \"$(date -u +%Y-%m-%dT%H:%M:%SZ)\"
  }" \
  "xF5XC_API_URLx/api/data/namespaces/xF5XC_NAMESPACEx/access_logs/aggregation" \
  | jq -r '.total_hits // "0"')

printf "%-28s %s\n" "PRÜFUNG" "STATUS"
printf "%-28s %s\n" "----------------------------" "----------------------------"
printf "%-28s %s\n" "[DNS] A-Record" "${DNS_A:-NOT_FOUND}"
printf "%-28s %s\n" "[DNS] ACME CNAME" "${DNS_ACME:-NOT_FOUND}"
printf "%-28s %s\n" "[TLS] Zertifikat" "$CERT_STATE"
printf "%-28s %s\n" "[LB] Status" "$LB_STATE"
printf "%-28s %s\n" "[LB] Domains" "$DOMAINS"
printf "%-28s %s\n" "[LB] Routen-Pool" "$ROUTE_POOL"
printf "%-28s %s\n" "[LB] CSD am LB" "$CSD_ON_LB"
printf "%-28s %s\n" "[CSD] Konfiguriert (Mandant)" "$CSD_CONFIGURED"
printf "%-28s %s\n" "[CSD] Aktiviert" "$CSD_ENABLED"
printf "%-28s %s\n" "[CSD] JS-Script-Tag" "$JS_TAG"
printf "%-28s %s\n" "[Datenverkehr] Anfragen (24 Std.)" "$TRAFFIC"

---

Zugriffsprotokoll-Feldreferenz

Achtung

Jeder Eintrag im .logs[]-Array ist eine JSON-Zeichenkette, kein geparste Objekt. Sie müssen in jq durch fromjson leiten, bevor Sie auf Felder zugreifen (z. B. .logs[] | fromjson | .method).

Feld	Typ	Beschreibung
@timestamp	Zeichenkette	Anfragezeitstempel (ISO 8601). Beachten Sie das @-Präfix — Zugriff mit .["@timestamp"] in jq
method	Zeichenkette	HTTP-Methode (GET, POST usw.)
req_path	Zeichenkette	Anfrage-URI-Pfad
rsp_code	Zeichenkette	HTTP-Antwortstatuscode als Zeichenkette (z. B. "200", "404")
rsp_code_class	Zeichenkette	Statuscodegruppe (2xx, 3xx, 4xx, 5xx oder downstream_remote_disconnect)
src_ip	Zeichenkette	Client-Quell-IP-Adresse
dst_ip	Zeichenkette	Ziel-(VIP-)IP-Adresse
domain	Zeichenkette	Wert des Anfrage-Host-Headers
user_agent	Zeichenkette	Client-User-Agent-Zeichenkette
rsp_size	Zeichenkette	Größe des Antworttexts in Bytes (als Zeichenkette zurückgegeben)
req_size	Zeichenkette	Größe des Anfragetexts in Bytes (als Zeichenkette zurückgegeben)
duration_with_data_tx_delay	Zeichenkette	Gesamte Anfragedauer in Sekunden (als Zeichenkette zurückgegeben, z. B. "0.024219")
csd_js_injection	Zeichenkette	"true" wenn CSD-JavaScript injiziert wurde (nur vorhanden wenn aktiv)

CSD-Telemetrie-Feldreferenz

Feld	Endpunkt	Beschreibung
isConfigured	status	CSD auf Mandantenebene aktiviert
isEnabled	status	CSD für diesen Namespace aktiv
scripts[]	scripts	Array erkannter Skriptobjekte
.script_name	scripts	Vollständige URL der JavaScript-Datei
.risk_level	scripts	Risikostufe (No Risk, Low Risk, High Risk)
.status	scripts	AN (Handlungsbedarf) oder NA (Kein Handlungsbedarf)
.form_fields_read	scripts	Anzahl der Formularfelder, die das Skript liest
.affected_users_count	scripts	Anzahl der betroffenen eindeutigen Benutzer/Sitzungen
domain_summary	detected_domains	Zählungen nach Status: .actionNeededCount.count, .mitigatedDomains.count, .allowedDomains.count, .totalDomains.count (jedes hat .count und .lastUpdated)
domains_list[]	detected_domains	Array erkannter Domain-Objekte mit .domain, .status, .category, .firstSeenDate, .latestSeenDate (Epoch-Sekunden als Zeichenketten)
form_fields[]	formFields	Array erkannter Formularfeld-Objekte
.analysis	formFields	Sensibilitätsklassifizierung (Sensitive, Not Sensitive)

Fehlerbehebung

Keine Zugriffsprotokolle

Wenn TV-1 0 zurückgibt:

1. DNS-Auflösung prüfen — verifizieren Sie, dass die Domain zur LB-VIP aufgelöst wird:

   dig +short xF5XC_DOMAINNAMEx A

   Wenn leer, ist DNS nicht konfiguriert. Siehe API-Automatisierung — Schritt 4.

2. LB-Status prüfen — der Load Balancer muss VIRTUAL_HOST_READY sein:

   curl -s \
     -H "Authorization: APIToken xF5XC_API_TOKENx" \
     "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/http_loadbalancers/xF5XC_LB_NAMEx-http" \
     | jq '.spec.state'

3. Testanfrage senden — Datenverkehr generieren, um die Ende-zu-Ende-Konnektivität zu bestätigen:

   curl -sv "http://xF5XC_DOMAINNAMEx/" 2>&1 | head -20

   Suchen Sie nach einer erfolgreichen HTTP-Antwort. Verwenden Sie https:// nur, wenn das HTTPS-LB-Zertifikat gültig ist.

Verwaltete Records in der DNS-Zone deaktiviert

Wenn DNS-4 false zurückgibt, ist die automatische Record-Erstellung deaktiviert, obwohl F5 XC der autoritative DNS-Anbieter ist. Dies ist eine häufige Fehlkonfiguration, die dazu führt, dass sowohl der A-Record als auch der ACME-CNAME fehlen, was den Load Balancer daran hindert, VIRTUAL_HOST_READY zu erreichen, und die Zertifikatsausstellung blockiert.

Um verwaltete Records zu aktivieren, aktualisieren Sie die DNS-Zonenkonfiguration und setzen Sie allow_http_lb_managed_records: true. Den API-Aufruf finden Sie unter API-Automatisierung — Option A: F5 XC verwaltetes DNS.

LB feststeckend in VIRTUAL_HOST_PENDING_A_RECORD

Der Load Balancer wartet auf einen DNS-A-Record, der auf seine VIP zeigt. Detaillierte Lösungsschritte finden Sie unter LB feststeckend in VIRTUAL_HOST_PENDING_A_RECORD.

Zertifikat feststeckend in PreDomainChallengePending

Das automatische TLS-Zertifikat erfordert einen ACME-Challenge-Record. Die Methode hängt von Ihrem DNS-Anbieter ab:

F5 XC verwaltetes DNS: Aktivieren Sie allow_http_lb_managed_records in der DNS-Zone (DNS-4). Die Plattform erstellt automatisch einen TXT-basierten ACME-Challenge-Record in der RR-Set-Gruppe x-ves-io-managed. Wenn das Zertifikat nach der Aktivierung verwalteter Records weiterhin feststeckt, löschen Sie den Load Balancer und erstellen Sie ihn neu, um eine neue Zertifikatsanforderung auszulösen.

Externes DNS: Erstellen Sie einen CNAME-Record bei Ihrem DNS-Anbieter:

_acme-challenge.xF5XC_DOMAINNAMEx  CNAME  *.autocerts.ves.volterra.io

Verifizieren Sie, dass der Record vorhanden ist:

dig +short _acme-challenge.xF5XC_DOMAINNAMEx CNAME
dig +short _acme-challenge.xF5XC_DOMAINNAMEx TXT

Wenn beide leer sind, ist der ACME-Record nicht konfiguriert. Die Zertifikatbereitstellung dauert 5–10 Minuten, nachdem der Record vorhanden ist. Prüfen Sie den LB-Fehlerstatus auf spezifische ACME-Validierungsfehler:

curl -s \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/http_loadbalancers/xF5XC_LB_NAMEx-http" \
  | jq '[.status[]? | select(.virtual_host_status != null) | .virtual_host_status.error_description]'

CSD isConfigured ist false

CSD muss auf Mandantenebene von einem F5 XC-Administrator aktiviert werden. Dies ist eine mandantenweite Einstellung, die nicht über die Namespace-API konfiguriert werden kann. Wenden Sie sich an Ihren Administrator, um Clientseitige Abwehr zu aktivieren.

Leeres Skript-Array

Wenn TEL-1 ein leeres Array zurückgibt:

1. Geschützte Domain prüfen — CSD überwacht Skripte nur auf registrierten Domains:

   curl -s \
     -H "Authorization: APIToken xF5XC_API_TOKENx" \
     "xF5XC_API_URLx/api/shape/csd/namespaces/xF5XC_NAMESPACEx/protected_domains" \
     | jq '.items[] | {name, namespace}'

2. JS-Injektion verifizieren — bestätigen Sie, dass der CSD-Script-Tag in Seiten injiziert wird:

   curl -s "http://xF5XC_DOMAINNAMEx/" | grep -oE '(zeronaught|shape)\.com[^"]*' | head -1

   Wenn keine Übereinstimmung gefunden wird, wird CSD-JavaScript nicht injiziert. Prüfen Sie, ob der LB client_side_defense aktiviert hat.

3. Verarbeitungszeit abwarten — nach der erstmaligen Aktivierung von CSD oder der Registrierung einer neuen geschützten Domain kann die Skripterkennung 5–15 Minuten dauern. Generieren Sie Datenverkehr zur Website und warten Sie vor der erneuten Prüfung.

Kurzreferenz

Zeitbereichsvoreinstellungen

Zeitraum	Epoch-Offset	ISO 8601 (Linux)	ISO 8601 (macOS)
1 Stunde	$(( $(date +%s) - 3600 ))	date -u -d '1 hour ago' +%Y-%m-%dT%H:%M:%SZ	date -u -v-1H +%Y-%m-%dT%H:%M:%SZ
24 Stunden	$(( $(date +%s) - 86400 ))	date -u -d '24 hours ago' +%Y-%m-%dT%H:%M:%SZ	date -u -v-24H +%Y-%m-%dT%H:%M:%SZ
7 Tage	$(( $(date +%s) - 604800 ))	date -u -d '7 days ago' +%Y-%m-%dT%H:%M:%SZ	date -u -v-7d +%Y-%m-%dT%H:%M:%SZ
30 Tage	$(( $(date +%s) - 2592000 ))	date -u -d '30 days ago' +%Y-%m-%dT%H:%M:%SZ	date -u -v-30d +%Y-%m-%dT%H:%M:%SZ

Zusammenfassung der Verifizierungsschichten

Schicht	Tests	Was abgedeckt wird
1. DNS-Auflösung	DNS-1 bis DNS-4	A-Record, ACME-CNAME, Nameserver-Autorität, verwaltete Records
2. TLS-Zertifikat	TLS-1 bis TLS-4	Zertifikatsstatus, Zertifikatsdetails, Live-Handshake, ACME-Ziel
3. HTTP-Load-Balancer	LB-1 bis LB-6	Status, Domains, CSD-Flag, Routen-Pools, Bereitstellung, Zusammenfassung
4. Ursprungspool	OP-1 bis OP-4	Konfiguration, TLS-Modus, HC-Zuordnung, Ursprungskonnektivität
5. Integritätsprüfung	HC-1 bis HC-2	HC-Konfiguration, alle HCs auflisten
6. CSD-Konfiguration	CSD-1 bis CSD-5	Mandantenstatus, JS-Tag, geschützte Domains, Live-Injektion
7. Datenverkehrsverifizierung	TV-1 bis TV-5	Anfragezählung, Statuscodes, Stichproben, JS in Protokollen, E2E-Test
8. CSD-Telemetrie	TEL-1 bis TEL-8	Skripte, Domains, Richtlinie, Formularfelder, Detailanalyse, Benutzer, Risiko, Aktualität

Endpunktübersicht

Diagnose	Endpunkt	Methode	Zeitformat
Anfragezählung	/api/data/namespaces/\{ns\}/access_logs/aggregation	POST	ISO 8601
Statuscodes	/api/data/namespaces/\{ns\}/access_logs	POST	ISO 8601
Aktuelle Anfragen	/api/data/namespaces/\{ns\}/access_logs	POST	ISO 8601
LB-Status	/api/config/namespaces/\{ns\}/http_loadbalancers/\{name\}	GET	Keines
Ursprungspool	/api/config/namespaces/\{ns\}/origin_pools/\{name\}	GET	Keines
Integritätsprüfung	/api/config/namespaces/\{ns\}/healthchecks/\{name\}	GET	Keines
DNS-Zone	/api/config/dns/namespaces/system/dns_zones/\{zone\}	GET	Keines
CSD-Status	/api/shape/csd/namespaces/\{ns\}/status	GET	Keines
JS-Konfiguration	/api/shape/csd/namespaces/\{ns\}/js_configuration	GET	Keines
Geschützte Domains	/api/shape/csd/namespaces/\{ns\}/protected_domains	GET	Keines
Skriptliste	/api/shape/csd/namespaces/\{ns\}/scripts	POST	Epoch-Sekunden
Erkannte Domains	/api/shape/csd/namespaces/\{ns\}/detected_domains	GET	Keines
Formularfelder	/api/shape/csd/namespaces/\{ns\}/formFields	GET	Epoch-Sekunden (Query-Parameter)
Skriptdetails	/api/shape/csd/namespaces/\{ns\}/scripts/\{id\}/dashboard	GET	Keines
Skriptverhaltensweisen	/api/shape/csd/namespaces/\{ns\}/scripts/\{id\}/behaviors	GET	Keines
Skriptnetzwerk	/api/shape/csd/namespaces/\{ns\}/scripts/\{id\}/networkInteractions	GET	Keines
Betroffene Benutzer	/api/shape/csd/namespaces/\{ns\}/scripts/\{id\}/affectedUsers	POST	Epoch-Sekunden