Diagnostics & Vérification

Cette page fournit une matrice de vérification UAT en couches pour valider votre déploiement de Défense côté client de bout en bout. Chaque cas de test suit la chaîne de dépendances de l’infrastructure — de la résolution DNS à la télémétrie CSD — afin que vous puissiez prouver systématiquement que chaque composant fonctionne correctement.

Ces commandes sont l’équivalent API du Guide de la console CSD — utilisez-les lorsque vous avez besoin d’effectuer des vérifications depuis le terminal, d’automatiser la surveillance ou de démontrer les capacités CSD sans l’interface utilisateur.

Prérequis

Configurez vos variables d’environnement comme décrit dans Automatisation API — Configuration de l’environnement :

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

Toutes les commandes ci-dessous utilisent le format de substitution xTOKENx. Remplacez par vos variables d’environnement ($F5XC_API_TOKEN, $F5XC_NAMESPACE, etc.) ou utilisez le formulaire interactif en haut de la page.

Notes sur le comportement de l’API

Note

PUT et DELETE renvoient \{\} vide sur HTTP 200 — c’est la réponse de succès attendue, pas une erreur. Seul POST renvoie l’objet créé. Les points de terminaison de liste (ex. /healthchecks) et les points de terminaison GET individuels (ex. /healthchecks/\{name\}) renvoient des structures de réponse différentes — consultez Référence API — Conventions API pour les détails sur les chemins jq corrects pour chacun.

Aides pour les plages de temps

De nombreux points de terminaison CSD nécessitent des horodatages epoch (secondes depuis l’epoch Unix). Ces commandes d’une ligne calculent les heures de début/fin pour les plages courantes.

Multiplateforme (macOS + Linux) :

# Heure actuelle en secondes epoch
NOW=$(date +%s)

# Il y a 1 heure
START_1H=$(( NOW - 3600 ))

# Il y a 24 heures
START_24H=$(( NOW - 86400 ))

# Il y a 7 jours
START_7D=$(( NOW - 604800 ))

# Il y a 30 jours
START_30D=$(( NOW - 2592000 ))

Préréglage	Secondes	Expression shell
1 heure	3 600	$(( $(date +%s) - 3600 ))
24 heures	86 400	$(( $(date +%s) - 86400 ))
7 jours	604 800	$(( $(date +%s) - 604800 ))
30 jours	2 592 000	$(( $(date +%s) - 2592000 ))

Note

Les points de terminaison CSD (/api/shape/csd/) utilisent des secondes epoch (ex. 1710000000). Les points de terminaison des journaux d’accès (/api/data/) utilisent des horodatages ISO 8601 (ex. 2024-03-10T00:00:00Z). Les commandes de chaque section utilisent le format correct pour ce point de terminaison.

Format des cas de test

Chaque test ci-dessous suit cette structure :

Champ	Description
ID du test	Numéro de couche + ID séquentiel (ex. DNS-1, TLS-2)
Ce qu’il prouve	Le fait d’infrastructure spécifique vérifié
Commande	Commande curl ou dig prête à l’emploi
RÉUSSITE / ÉCHEC	Sortie attendue pour un état sain ou non
Correction	Lien vers la section de configuration ou de dépannage concernée

---

Couche 1 : Résolution DNS

Le DNS est la fondation — si le domaine ne résout pas vers l’IP VIP de l’équilibreur de charge, rien d’autre ne fonctionne.

DNS-1 : Résolution de l’enregistrement A

Ce qu’il prouve : Le domaine résout vers l’adresse IP VIP de l’équilibreur de charge.

dig +short xF5XC_DOMAINNAMEx A

Résultat	Signification
RÉUSSITE — IP VIP retournée (ex. 72.19.3.185)	Le domaine résout vers l’IP virtuelle du LB
ÉCHEC — réponse vide	Enregistrement A DNS non configuré

Correction : Automatisation API — Étape 4 : Configurer le DNS

Astuce

Cache DNS négatif : Si le domaine a précédemment retourné NXDOMAIN, les résolveurs récursifs peuvent mettre en cache ce résultat. Vérifiez auprès du serveur de noms faisant autorité pour exclure un cache périmé : dig +short xF5XC_DOMAINNAMEx A @ns1.f5clouddns.com ou utilisez un résolveur public comme @8.8.8.8.

DNS-2 : Enregistrement de défi ACME

Ce qu’il prouve : L’enregistrement de défi ACME existe pour le provisionnement automatique des certificats TLS.

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

Résultat	Signification
RÉUSSITE — CNAME vers *.autocerts.ves.volterra.io. (DNS externe)	Le CNAME de défi ACME est en place
RÉUSSITE — enregistrement TXT avec la valeur du domaine (DNS géré par F5 Distributed Cloud (F5 XC))	Défi ACME géré par la Plateforme via enregistrement TXT
ÉCHEC — les deux vides	Enregistrement ACME non configuré ; le certificat restera en PreDomainChallengePending

Note

Lors de l’utilisation du DNS géré par F5 XC avec allow_http_lb_managed_records activé, la Plateforme crée automatiquement un enregistrement TXT (pas un CNAME) dans le groupe d’enregistrements RR x-ves-io-managed. Cette validation ACME basée sur TXT est gérée en interne. Lors de l’utilisation d’un DNS externe, vous devez créer manuellement un CNAME vers *.autocerts.ves.volterra.io.

Correction : Pour le DNS externe, créez le CNAME : _acme-challenge.xF5XC_DOMAINNAMEx → *.autocerts.ves.volterra.io. Pour le DNS géré par F5 XC, activez allow_http_lb_managed_records sur la zone DNS — voir DNS-4. Voir Automatisation API — Étape 4.

DNS-3 : Autorité des serveurs de noms

Ce qu’il prouve : Si F5 XC est le fournisseur DNS faisant autorité pour le domaine racine.

dig +short NS xF5XC_ROOT_DOMAINx

Résultat	Signification
Inclut ns1.f5clouddns.com et ns2.f5clouddns.com	DNS géré par F5 XC — les enregistrements peuvent être créés automatiquement
Autres serveurs de noms	DNS externe — les enregistrements doivent être créés manuellement

Correction : Automatisation API — Détecter l’autorité DNS

DNS-4 : Enregistrements gérés par F5 XC activés

Ce qu’il prouve : La zone DNS F5 XC permet la création automatique d’enregistrements pour les équilibreurs de charge (DNS géré par F5 XC uniquement).

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'

Résultat	Signification
RÉUSSITE — true	La Plateforme créera automatiquement les enregistrements A et ACME pour les LBs
ÉCHEC — false ou null	Les enregistrements gérés sont désactivés ; activez-les via la mise à jour de la zone

Attention

Un résultat false est une mauvaise configuration courante lors de l’utilisation du DNS géré par F5 XC. Sans les enregistrements gérés activés, la Plateforme ne peut pas créer automatiquement l’enregistrement A (pointant vers le VIP) ni le CNAME de défi ACME (requis pour le provisionnement des certificats TLS). Cela entraîne le blocage de l’équilibreur de charge dans l’état VIRTUAL_HOST_PENDING_A_RECORD et du certificat dans PreDomainChallengePending. Activez les enregistrements gérés sur la zone DNS ou créez les enregistrements manuellement.

Correction : Automatisation API — Option A : DNS géré par F5 XC

---

Couche 2 : Certificat TLS

Après la résolution DNS, l’équilibreur de charge doit avoir un certificat TLS valide.

TLS-1 : État du certificat

Note

Ce test s’applique uniquement au LB HTTPS (${F5XC_LB_NAME}-https). Le LB HTTP n’a pas de certificat. Dans les environnements de démonstration, TLS-1 est informatif — s’il affiche AutoCertDomainRateLimited, la démonstration se poursuit normalement en utilisant des URL http:// via le LB HTTP.

Ce qu’il prouve : Le certificat TLS automatique a été émis sur le LB HTTPS.

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'

Résultat	Signification
RÉUSSITE — "CertificateValid" ou "AutoCertRenewing"	Le certificat est valide et actif
AVERTISSEMENT — "DomainChallengePending" ou "DomainChallengeStarted"	Défi ACME en cours — attendez 5–10 minutes
INFO — "AutoCertDomainRateLimited"	Limite de débit Let’s Encrypt atteinte — attendu dans les environnements de démonstration, n’affecte pas le LB HTTP
ÉCHEC — "PreDomainChallengePending"	Enregistrement de défi ACME manquant — voir DNS-2

Correction : Assurez-vous que l’enregistrement de défi ACME est en place (CNAME pour le DNS externe, ou activez les enregistrements gérés pour le DNS F5 XC). Le provisionnement du certificat prend 5–10 minutes après la configuration de l’enregistrement. Si bloqué au-delà de 15 minutes, voir Certificat bloqué — Recréation propre. En cas de limite de débit, le LB HTTP n’est pas affecté.

TLS-2 : Détails du certificat

Ce qu’il prouve : Le certificat couvre le domaine attendu et affiche les informations d’expiration. Applicable uniquement au LB HTTPS.

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
  }'

Résultat	Signification
RÉUSSITE — auto_cert_info contient dns_records et les métadonnées du certificat	Les détails du provisionnement du certificat sont disponibles
ÉCHEC — auto_cert_info est null ou vide	Certificat pas encore provisionné

TLS-3 : Établissement TLS en direct

Ce qu’il prouve : Le certificat TLS est valide et l’établissement de connexion s’effectue du côté client. Applicable uniquement lorsque le LB HTTPS a un certificat valide.

Note

Dans les environnements de démonstration, utilisez curl http://xF5XC_DOMAINNAMEx/ (HTTP, pas HTTPS) comme chemin de vérification principal. Le test d’établissement TLS est optionnel — il ne fonctionne que lorsque le certificat du LB HTTPS est CertificateValid.

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

Résultat	Signification
RÉUSSITE — affiche SSL connection using TLSv1.3, sujet et expiration valides	TLS de bout en bout fonctionne
ÉCHEC — connexion refusée ou erreur de certificat	Vérifiez la résolution DNS et l’état du certificat ; si limite de débit atteinte, utilisez HTTP

TLS-4 : Cible de l’enregistrement ACME depuis le LB

Ce qu’il prouve : L’équilibreur de charge HTTPS rapporte la cible ACME correcte pour la validation du certificat.

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
  }'

Résultat	Signification
RÉUSSITE — vip_ip et acme_target renseignés	Les enregistrements DNS peuvent être vérifiés par rapport à ces valeurs
ÉCHEC — valeurs null	Le LB peut ne pas avoir https_auto_cert configuré

---

Couche 3 : Équilibreur de charge HTTP

L’équilibreur de charge doit être dans un état prêt et correctement configuré.

LB-1 : État opérationnel

Ce qu’il prouve : L’équilibreur de charge HTTP (principal) est entièrement opérationnel et accepte le trafic.

Note

Le LB HTTP est la cible de vérification principale. Dans les environnements de démonstration, vérifiez d’abord le LB HTTP (${F5XC_LB_NAME}-http) — il atteint VIRTUAL_HOST_READY dès que le DNS est résolu, sans dépendance au certificat. Utilisez curl http://xF5XC_DOMAINNAMEx/ pour la vérification principale basée sur HTTP.

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'

Résultat	Signification
RÉUSSITE — "VIRTUAL_HOST_READY"	Le LB est opérationnel
ÉCHEC — "VIRTUAL_HOST_PENDING_A_RECORD"	Enregistrement A DNS non configuré — voir DNS-1

Correction : LB bloqué dans VIRTUAL_HOST_PENDING_A_RECORD

LB-2 : Configuration du domaine

Ce qu’il prouve : L’équilibreur de charge HTTP est configuré pour le(s) domaine(s) correct(s).

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'

Résultat	Signification
RÉUSSITE — le tableau contient votre FQDN (ex. ["app.example.com"])	Le LB est configuré pour le domaine attendu
ÉCHEC — domaine manquant ou incorrect	Mettez à jour la spécification du LB avec le bon domaine

LB-3 : CSD activé sur le LB

Ce qu’il prouve : La Défense côté client est activée sur l’équilibreur de charge avec la politique d’injection JS correcte.

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
  }'

Résultat	Signification
RÉUSSITE — csd_enabled: true avec js_insert_all_pages dans la politique	CSD actif avec injection JS sur toutes les pages
ÉCHEC — csd_enabled: false	CSD non configuré sur le LB

Correction : Référence API — Activer CSD sur un équilibreur de charge

LB-4 : Pool de routes par défaut

Ce qu’il prouve : L’équilibreur de charge référence le pool d’origine correct avec le poids et la priorité attendus.

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
  }'

Résultat	Signification
RÉUSSITE — affiche le nom de votre pool d’origine avec poids/priorité	Le LB route vers le backend correct
ÉCHEC — pool vide ou incorrect	Mettez à jour la configuration default_route_pools du LB

LB-5 : Statut de déploiement (conditions par site)

Ce qu’il prouve : L’équilibreur de charge est déployé et rapporte des conditions saines sur tous les sites.

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
  }'

Résultat	Signification
RÉUSSITE — state est VIRTUAL_HOST_READY, dns_info renseigné	LB entièrement déployé avec VIP assigné
ÉCHEC — état en attente ou dns_info vide	Problème DNS ou de certificat bloquant le déploiement

Astuce

Lorsque le LB n’est pas dans l’état VIRTUAL_HOST_READY, vérifiez .status[].virtual_host_status.error_description pour les mêmes détails d’erreur affichés dans l’interface de la console F5 XC :

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 : Résumé complet du LB

Ce qu’il prouve : Instantané complet des deux configurations LB pour le débogage.

LB HTTP (principal) :

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)
  }'

LB HTTPS (secondaire — inclut l’état du certificat) :

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]
  }'

---

Couche 4 : Pool d’origine

Le pool d’origine définit les serveurs backend vers lesquels l’équilibreur de charge achemine le trafic.

OP-1 : Configuration du pool d’origine

Ce qu’il prouve : Le pool d’origine existe avec le serveur backend, le port et l’algorithme LB corrects.

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
  }'

Résultat	Signification
RÉUSSITE — affiche l’IP, le port et l’algorithme corrects	Pool d’origine configuré correctement
ÉCHEC — 404 ou valeurs incorrectes	Pool d’origine manquant ou mal configuré

Correction : Automatisation API — Étape 2 : Créer le pool d’origine

OP-2 : TLS vers l’origine

Ce qu’il prouve : Si TLS est configuré pour la connexion entre le LB et le serveur d’origine.

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)
  }'

Résultat	Signification
no_tls (plaintext)	Le LB se connecte à l’origine via HTTP (attendu pour la démo Juice Shop)
use_tls (encrypted)	Le LB se connecte à l’origine via HTTPS

OP-3 : Association du bilan de santé

Ce qu’il prouve : Le pool d’origine a le bilan de santé correct lié (le cas échéant).

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

Résultat	Signification
RÉUSSITE — tableau avec référence au bilan de santé (nom, namespace, type)	Le bilan de santé est lié
OK — tableau vide []	Pas de bilan de santé (acceptable — CSD n’en requiert pas)
ÉCHEC — un bilan de santé était attendu mais le tableau est vide	Le bilan de santé n’a pas été trouvé lors de la création — voir Bilan de santé non lié

OP-4 : Connectivité vers l’origine

Ce qu’il prouve : Le serveur d’origine est accessible depuis le client (ne teste pas le chemin LB-vers-origine).

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

Résultat	Signification
RÉUSSITE — 200 (ou autre code HTTP valide)	Le serveur d’origine répond
ÉCHEC — 000 ou connexion refusée	Serveur d’origine inaccessible depuis ce réseau

Note

Ce test vérifie la connectivité directe client-vers-origine. Le chemin LB-vers-origine peut utiliser un chemin réseau différent. Un échec ici ne signifie pas nécessairement que le LB ne peut pas atteindre l’origine.

---

Couche 5 : Bilan de santé

Les bilans de santé surveillent la disponibilité du backend. Ils sont optionnels pour CSD mais utiles pour les déploiements en production.

HC-1 : Configuration du bilan de santé

Ce qu’il prouve : Le bilan de santé existe avec le type, le chemin, les délais et les seuils corrects.

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
  }'

Résultat	Signification
RÉUSSITE — affiche le type HTTP avec le chemin / et le statut attendu 200	Bilan de santé configuré correctement
ÉCHEC — réponse 404	Le bilan de santé n’existe pas (peut avoir été ignoré — voir Phase 1 Étape 1)

HC-2 : Lister tous les bilans de santé

Ce qu’il prouve : Énumère tous les bilans de santé dans le namespace pour vérifier les noms et le nombre.

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

Note

Le point de terminaison de liste renvoie uniquement des données de résumé (nom, namespace, description). Pour voir les détails de configuration complets (type, chemin, intervalle, délai), interrogez un bilan de santé individuel en utilisant HC-1.

---

Couche 6 : Configuration CSD

CSD doit être activé au niveau du tenant et avoir la balise d’injection JavaScript configurée.

CSD-1 : Statut CSD du tenant

Ce qu’il prouve : CSD est configuré et activé pour le tenant.

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

Résultat	Signification
RÉUSSITE — les deux à true	CSD est actif pour ce tenant
ÉCHEC — isConfigured: false	CSD non activé au niveau du tenant — contactez l’administrateur F5 XC
ÉCHEC — isEnabled: false	CSD configuré mais non actif

CSD-2 : Balise d’injection JS

Ce qu’il prouve : La balise d’injection JavaScript CSD est générée et prête pour l’injection.

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)}'

Résultat	Signification
RÉUSSITE — has_script_tag: true	La balise d’injection JS est configurée
ÉCHEC — has_script_tag: false	Pas de balise de script — vérifiez que CSD est activé et qu’un domaine protégé est enregistré

CSD-3 : Contenu de la balise JS

Ce qu’il prouve : Affiche la balise de script complète pour vérification ou injection manuelle.

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

CSD-4 : Enregistrement du domaine protégé

Ce qu’il prouve : Le domaine racine est enregistré comme domaine protégé CSD sur le tenant.

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

Résultat	Signification
RÉUSSITE — affiche un élément avec un name non vide	Le domaine est protégé
ÉCHEC — les éléments ont des champs name et namespace vides	Aucun domaine protégé enregistré — voir Phase 1 Étape 6

Note

Le point de terminaison de liste des domaines protégés renvoie des données de résumé. Les éléments avec tous les champs vides indiquent qu’aucun domaine protégé n’est configuré. La balise JavaScript CSD (CSD-2) est un indicateur plus fiable que la protection du domaine est active.

CSD-5 : Vérification de l’injection JS en direct

Ce qu’il prouve : Le JavaScript CSD est effectivement injecté dans les réponses de pages servies par l’équilibreur de charge.

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

Résultat	Signification
RÉUSSITE — retourne un fragment d’URL zeronaught.com ou shape.com (ex. zeronaught.com/__imp_apg__/js/...)	Le JavaScript CSD est injecté dans les pages
ÉCHEC — sortie vide	JS non injecté — vérifiez LB-3 et CSD-1

---

Couche 7 : Vérification du trafic

Vérifiez que le trafic en direct atteint l’équilibreur de charge et est traité correctement.

TV-1 : Nombre de requêtes (dernières 24 heures)

Ce qu’il prouve : Le trafic atteint l’équilibreur de charge. Un résultat à zéro signifie qu’aucun trafic n’arrive.

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}'

Résultat	Signification
RÉUSSITE — total_requests est une chaîne non nulle (ex. "380")	Le trafic circule à travers le LB
ÉCHEC — "0" ou pas de données	Aucun trafic n’atteint le LB — vérifiez DNS-1 et LB-1

Note

La valeur total_hits est retournée sous forme de chaîne (ex. "380"), pas d’entier. Le namespace est déduit du chemin de l’URL — ne l’incluez pas dans le corps de la requête.

TV-2 : Distribution des codes de statut

Ce qu’il prouve : La répartition des codes de statut de réponse révèle des modèles d’erreur.

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

Note

Le point de terminaison d’agrégation ne prend pas en charge le regroupement par terms — aggs renvoie toujours vide. Cette commande récupère les 100 entrées de journal les plus récentes et calcule la distribution côté client. Chaque entrée de journal est une chaîne JSON qui doit être analysée avec fromjson.

Sortie attendue pour un site sain :

STATUS_CLASS                  COUNT
2xx                           82
downstream_remote_disconnect  18

Résultat	Signification
RÉUSSITE — majorité 2xx	Le site sert des réponses réussies
AVERTISSEMENT — nombre 4xx élevé	Erreurs client (mauvaises URL, ressources manquantes)
ÉCHEC — nombre 5xx élevé	Erreurs serveur — vérifiez la santé du serveur d’origine

La classe downstream_remote_disconnect indique que le client a fermé la connexion avant que la réponse ne soit complète (courant pour les requêtes de long-polling ou de mise à niveau WebSocket).

TV-3 : Échantillons de requêtes récentes

Ce qu’il prouve : Les requêtes individuelles sont journalisées avec les champs corrects.

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

Attention

Chaque entrée dans le tableau .logs[] est une chaîne JSON, pas un objet analysé. Vous devez passer par fromjson dans jq avant d’accéder aux champs (ex. .logs[] | fromjson | .method).

TV-4 : Injection JS CSD dans les journaux d’accès

Ce qu’il prouve : Les journaux d’accès confirment que le JavaScript CSD est injecté dans les réponses.

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}'

Résultat	Signification
RÉUSSITE — injected_count > 0	Le JS CSD est injecté dans les réponses de pages
ÉCHEC — injected_count: 0	JS non injecté — vérifiez CSD-1 et LB-3

Note

Le champ csd_js_injection n’est présent que dans les entrées de journal où l’injection a eu lieu. Lors des tests, 40 % des entrées de journal échantillonnées avaient csd_js_injection: "true" (requêtes de pages HTML), tandis que 60 % n’avaient pas ce champ (ressources statiques comme les fichiers .ico, .js, .css et les connexions WebSocket). Les requêtes de pages HTML devraient afficher l’injection ; les appels API et les requêtes de ressources statiques généralement non.

TV-5 : Test de connectivité de bout en bout

Ce qu’il prouve : Une requête complète passe du client via DNS, LB et origine et retourne une réponse valide.

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

Résultat	Signification
RÉUSSITE — affiche la connexion, HTTP 200 et content-type	La pile complète est opérationnelle
ÉCHEC — connexion refusée ou erreur DNS	Commencez le débogage à Couche 1 : DNS

Astuce

Pour les tests de bout en bout HTTPS (uniquement lorsque le certificat du LB HTTPS est valide), utilisez curl -sv "https://xF5XC_DOMAINNAMEx/" et vérifiez la présence de SSL connection dans la sortie.

---

Couche 8 : Télémétrie CSD & Politique de domaine

Ces commandes interrogent les mêmes données affichées dans le tableau de bord de la Console CSD, la liste des scripts, les champs de formulaire et les vues réseau.

TEL-1 : Inventaire des scripts

Ce qu’il prouve : CSD détecte et catalogue les scripts s’exécutant sur le domaine protégé.

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

Résultat	Signification
RÉUSSITE — scripts listés avec niveaux de risque	CSD surveille activement les scripts
ÉCHEC — tableau vide	Voir Dépannage : Tableau de scripts vide

Astuce

Les noms de scripts sont des URL complètes et peuvent être très longs. La commande ci-dessus tronque les noms à 50 caractères pour la lisibilité dans le terminal. Supprimez le filtre de troncature pour voir les URL complètes.

TEL-2 : Domaines détectés

Ce qu’il prouve : CSD a détecté les domaines sources des scripts et les a classifiés par statut.

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)
    }]
  }'

Résultat	Signification
RÉUSSITE — total > 0 avec des domaines listés	CSD suit les domaines des scripts
AVERTISSEMENT — action_needed > 0	Certains domaines nécessitent une révision
ÉCHEC — réponse vide	Pas de données de télémétrie — vérifiez CSD-5

TEL-3 : État de la politique de domaine

Ce qu’il prouve : Affiche la distribution des domaines autorisés vs. atténués et si la politique est cohérente.

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]
  }'

Résultat	Signification
RÉUSSITE — action_needed: 0	Tous les domaines ont été examinés et classifiés
AVERTISSEMENT — action_needed > 0	Les domaines listés dans domains_needing_action nécessitent une révision

TEL-4 : Inventaire des champs de formulaire

Ce qu’il prouve : CSD a détecté les champs de formulaire que les scripts lisent, avec une classification de sensibilité.

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

Résultat	Signification
RÉUSSITE — champs de formulaire listés avec sensibilité	CSD suit l’accès aux champs de formulaire
INFO — tableau vide	Aucun champ de formulaire détecté (attendu si le site n’a pas de formulaires)

TEL-5 : Analyse approfondie d’un script

Ce qu’il prouve : Informations détaillées sur un script spécifique, y compris le risque, les comportements et les interactions réseau.

Obtenez d’abord un ID de script depuis TEL-1, puis interrogez ses détails :

SCRIPT_ID="your-script-id"

# Vue d'ensemble (niveau de risque, type, domaine source)
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}'

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

# Interactions réseau (domaines avec lesquels le script communique)
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 : Utilisateurs affectés

Ce qu’il prouve : Liste les utilisateurs impactés par un script spécifique, montrant l’étendue de l’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 : Nombre de scripts par niveau de risque

Ce qu’il prouve : Distribution agrégée des risques sur tous les scripts détectés.

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)'

Résultat	Signification
RÉUSSITE — tout No Risk	Aucun script risqué détecté
AVERTISSEMENT — Low Risk ou High Risk présent	Examinez les scripts signalés dans TEL-5

TEL-8 : Fraîcheur de la télémétrie

Ce qu’il prouve : Les données de télémétrie CSD sont récentes, confirmant une surveillance active.

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)
    })
  }'

Résultat	Signification
RÉUSSITE — latest_seen est dans les dernières 24 heures	La télémétrie collecte activement des données
AVERTISSEMENT — latest_seen est antérieur à 24 heures	Le trafic peut avoir cessé ou le traitement CSD est retardé

---

Tableau de bord de la pile complète

Exécutez une seule commande qui vérifie tous les indicateurs de santé critiques sur chaque couche et produit un tableau récapitulatif :

echo "=== Tableau de bord de vérification CSD ==="
echo ""

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

# Couches 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(", ")')

# Couche 6 : Statut CSD
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')

# Couche 6 : Configuration JS
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')

# Couche 7 : Trafic (dernières 24h)
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" "VÉRIFICATION" "STATUT"
printf "%-28s %s\n" "----------------------------" "----------------------------"
printf "%-28s %s\n" "[DNS] Enregistrement A" "${DNS_A:-NOT_FOUND}"
printf "%-28s %s\n" "[DNS] CNAME ACME" "${DNS_ACME:-NOT_FOUND}"
printf "%-28s %s\n" "[TLS] Certificat" "$CERT_STATE"
printf "%-28s %s\n" "[LB] État" "$LB_STATE"
printf "%-28s %s\n" "[LB] Domaines" "$DOMAINS"
printf "%-28s %s\n" "[LB] Pool de routes" "$ROUTE_POOL"
printf "%-28s %s\n" "[LB] CSD sur LB" "$CSD_ON_LB"
printf "%-28s %s\n" "[CSD] Configuré (tenant)" "$CSD_CONFIGURED"
printf "%-28s %s\n" "[CSD] Activé" "$CSD_ENABLED"
printf "%-28s %s\n" "[CSD] Balise de script JS" "$JS_TAG"
printf "%-28s %s\n" "[Trafic] Requêtes (24h)" "$TRAFFIC"

---

Référence des champs du journal d’accès

Attention

Chaque entrée dans le tableau .logs[] est une chaîne JSON, pas un objet analysé. Vous devez passer par fromjson dans jq avant d’accéder aux champs (ex. .logs[] | fromjson | .method).

Champ	Type	Description
@timestamp	chaîne	Horodatage de la requête (ISO 8601). Notez le préfixe @ — accédez-y avec .["@timestamp"] dans jq
method	chaîne	Méthode HTTP (GET, POST, etc.)
req_path	chaîne	Chemin de l’URI de la requête
rsp_code	chaîne	Code de statut HTTP de la réponse sous forme de chaîne (ex. "200", "404")
rsp_code_class	chaîne	Classe du code de statut (2xx, 3xx, 4xx, 5xx, ou downstream_remote_disconnect)
src_ip	chaîne	Adresse IP source du client
dst_ip	chaîne	Adresse IP de destination (VIP)
domain	chaîne	Valeur de l’en-tête Host de la requête
user_agent	chaîne	Chaîne User-Agent du client
rsp_size	chaîne	Taille du corps de la réponse en octets (retournée sous forme de chaîne)
req_size	chaîne	Taille du corps de la requête en octets (retournée sous forme de chaîne)
duration_with_data_tx_delay	chaîne	Durée totale de la requête en secondes (retournée sous forme de chaîne, ex. "0.024219")
csd_js_injection	chaîne	"true" lorsque le JavaScript CSD a été injecté (uniquement présent lorsqu’actif)

Référence des champs de télémétrie CSD

Champ	Point de terminaison	Description
isConfigured	status	CSD activé au niveau du tenant
isEnabled	status	CSD actif pour ce namespace
scripts[]	scripts	Tableau des objets de scripts détectés
.script_name	scripts	URL complète du fichier JavaScript
.risk_level	scripts	Niveau de risque (No Risk, Low Risk, High Risk)
.status	scripts	AN (Action Needed) ou NA (No Action Needed)
.form_fields_read	scripts	Nombre de champs de formulaire que le script lit
.affected_users_count	scripts	Nombre d’utilisateurs/sessions uniques affectés
domain_summary	detected_domains	Comptages par statut : .actionNeededCount.count, .mitigatedDomains.count, .allowedDomains.count, .totalDomains.count (chacun a .count et .lastUpdated)
domains_list[]	detected_domains	Tableau d’objets de domaines détectés avec .domain, .status, .category, .firstSeenDate, .latestSeenDate (secondes epoch sous forme de chaînes)
form_fields[]	formFields	Tableau d’objets de champs de formulaire détectés
.analysis	formFields	Classification de sensibilité (Sensitive, Not Sensitive)

Dépannage

Journaux d’accès à zéro

Si TV-1 retourne 0 :

1. Vérifiez la résolution DNS — vérifiez que le domaine résout vers le VIP du LB :

   dig +short xF5XC_DOMAINNAMEx A

   Si vide, le DNS n’est pas configuré. Voir Automatisation API — Étape 4.

2. Vérifiez l’état du LB — l’équilibreur de charge doit être en état VIRTUAL_HOST_READY :

   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. Envoyez une requête de test — générez du trafic pour confirmer la connectivité de bout en bout :

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

   Recherchez une réponse HTTP réussie. Utilisez https:// uniquement si le certificat du LB HTTPS est valide.

Enregistrements gérés désactivés sur la zone DNS

Si DNS-4 retourne false, la création automatique d’enregistrements est désactivée même si F5 XC est le fournisseur DNS faisant autorité. Il s’agit d’une mauvaise configuration courante qui entraîne l’absence de l’enregistrement A et du CNAME ACME, ce qui empêche l’équilibreur de charge d’atteindre l’état VIRTUAL_HOST_READY et le certificat d’être émis.

Pour activer les enregistrements gérés, mettez à jour la configuration de la zone DNS pour définir allow_http_lb_managed_records: true. Voir Automatisation API — Option A : DNS géré par F5 XC pour l’appel API.

LB bloqué dans VIRTUAL_HOST_PENDING_A_RECORD

L’équilibreur de charge attend un enregistrement DNS A pointant vers son VIP. Voir LB bloqué dans VIRTUAL_HOST_PENDING_A_RECORD pour les étapes de résolution détaillées.

Certificat bloqué dans PreDomainChallengePending

Le certificat TLS automatique nécessite un enregistrement de défi ACME. La méthode dépend de votre fournisseur DNS :

DNS géré par F5 XC : Activez allow_http_lb_managed_records sur la zone DNS (DNS-4). La Plateforme crée automatiquement un enregistrement de défi ACME basé sur TXT dans le groupe d’enregistrements RR x-ves-io-managed. Si le certificat reste bloqué après l’activation des enregistrements gérés, supprimez et recréez l’équilibreur de charge pour déclencher une nouvelle demande de certificat.

DNS externe : Créez un enregistrement CNAME chez votre fournisseur DNS :

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

Vérifiez que l’enregistrement existe :

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

Si les deux sont vides, l’enregistrement ACME n’est pas configuré. Le provisionnement du certificat prend 5–10 minutes après la mise en place de l’enregistrement. Vérifiez le statut d’erreur du LB pour les erreurs de validation ACME spécifiques :

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 est false

CSD doit être activé au niveau du tenant par un administrateur F5 XC. Il s’agit d’un paramètre à l’échelle du tenant qui ne peut pas être configuré via l’API du namespace. Contactez votre administrateur pour activer la Défense côté client.

Tableau de scripts vide

Si TEL-1 retourne un tableau vide :

1. Vérifiez le domaine protégé — CSD surveille les scripts uniquement sur les domaines enregistrés :

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

2. Vérifiez l’injection JS — confirmez que la balise de script CSD est injectée dans les pages :

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

   Si aucune correspondance, le JavaScript CSD n’est pas injecté. Vérifiez que le LB a client_side_defense activé.

3. Accordez du temps de traitement — après avoir activé CSD ou enregistré un nouveau domaine protégé, la détection des scripts peut prendre 5–15 minutes. Générez du trafic vers le site et attendez avant de vérifier à nouveau.

Référence rapide

Préréglages de plages de temps

Période	Décalage epoch	ISO 8601 (Linux)	ISO 8601 (macOS)
1 heure	$(( $(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 heures	$(( $(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 jours	$(( $(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 jours	$(( $(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

Résumé des couches de vérification

Couche	Tests	Ce qu’elle couvre
1. Résolution DNS	DNS-1 à DNS-4	Enregistrement A, CNAME ACME, autorité des serveurs de noms, enregistrements gérés
2. Certificat TLS	TLS-1 à TLS-4	État du certificat, détails du certificat, établissement en direct, cible ACME
3. Équilibreur de charge HTTP	LB-1 à LB-6	État, domaines, indicateur CSD, pools de routes, déploiement, résumé
4. Pool d’origine	OP-1 à OP-4	Configuration, mode TLS, association HC, connectivité vers l’origine
5. Bilan de santé	HC-1 à HC-2	Configuration HC, liste de tous les HC
6. Configuration CSD	CSD-1 à CSD-5	Statut du tenant, balise JS, domaines protégés, injection en direct
7. Vérification du trafic	TV-1 à TV-5	Nombre de requêtes, codes de statut, échantillons, JS dans les journaux, test E2E
8. Télémétrie CSD	TEL-1 à TEL-8	Scripts, domaines, politique, champs de formulaire, analyse approfondie, utilisateurs, risque, fraîcheur

Résumé des points de terminaison

Diagnostic	Point de terminaison	Méthode	Format de temps
Nombre de requêtes	/api/data/namespaces/\{ns\}/access_logs/aggregation	POST	ISO 8601
Codes de statut	/api/data/namespaces/\{ns\}/access_logs	POST	ISO 8601
Requêtes récentes	/api/data/namespaces/\{ns\}/access_logs	POST	ISO 8601
État du LB	/api/config/namespaces/\{ns\}/http_loadbalancers/\{name\}	GET	Aucun
Pool d’origine	/api/config/namespaces/\{ns\}/origin_pools/\{name\}	GET	Aucun
Bilan de santé	/api/config/namespaces/\{ns\}/healthchecks/\{name\}	GET	Aucun
Zone DNS	/api/config/dns/namespaces/system/dns_zones/\{zone\}	GET	Aucun
Statut CSD	/api/shape/csd/namespaces/\{ns\}/status	GET	Aucun
Configuration JS	/api/shape/csd/namespaces/\{ns\}/js_configuration	GET	Aucun
Domaines protégés	/api/shape/csd/namespaces/\{ns\}/protected_domains	GET	Aucun
Liste des scripts	/api/shape/csd/namespaces/\{ns\}/scripts	POST	Secondes epoch
Domaines détectés	/api/shape/csd/namespaces/\{ns\}/detected_domains	GET	Aucun
Champs de formulaire	/api/shape/csd/namespaces/\{ns\}/formFields	GET	Secondes epoch (paramètres de requête)
Détails du script	/api/shape/csd/namespaces/\{ns\}/scripts/\{id\}/dashboard	GET	Aucun
Comportements du script	/api/shape/csd/namespaces/\{ns\}/scripts/\{id\}/behaviors	GET	Aucun
Réseau du script	/api/shape/csd/namespaces/\{ns\}/scripts/\{id\}/networkInteractions	GET	Aucun
Utilisateurs affectés	/api/shape/csd/namespaces/\{ns\}/scripts/\{id\}/affectedUsers	POST	Secondes epoch