Diagnóstico y verificación

Esta página proporciona una matriz de verificación UAT por capas para validar el despliegue de Defensa del lado del cliente de extremo a extremo. Cada caso de prueba sigue la cadena de dependencias de infraestructura — desde la resolución DNS hasta la telemetría de CSD — para que pueda demostrar sistemáticamente que cada componente funciona correctamente.

Estos comandos son el equivalente de API del Recorrido por la consola de CSD — utilícelos cuando necesite verificar desde el terminal, automatizar la supervisión o demostrar las capacidades de CSD sin la interfaz de usuario.

Prerrequisitos

Configure las variables de entorno tal como se describe en Automatización de API — Configuración del entorno:

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

Todos los comandos a continuación utilizan el formato de marcador de posición xTOKENx. Sustitúyalo con sus variables de entorno ($F5XC_API_TOKEN, $F5XC_NAMESPACE, etc.) o use el formulario interactivo en la parte superior de la página.

Notas sobre el comportamiento de la API

Nota

PUT y DELETE devuelven \{\} vacío con HTTP 200 — esta es la respuesta de éxito esperada, no un error. Solo POST devuelve el objeto creado. Los endpoints de listado (p. ej., /healthchecks) y los endpoints GET individuales (p. ej., /healthchecks/\{name\}) devuelven estructuras de respuesta diferentes — consulte Referencia de API — Convenciones de API para obtener detalles sobre las rutas jq correctas para cada uno.

Auxiliares de rango de tiempo

Muchos endpoints de CSD requieren marcas de tiempo en formato epoch (segundos desde el epoch Unix). Estas instrucciones de una línea calculan los tiempos de inicio/fin para rangos comunes.

Multiplataforma (macOS + Linux):

# Hora actual como segundos epoch
NOW=$(date +%s)

# Hace 1 hora
START_1H=$(( NOW - 3600 ))

# Hace 24 horas
START_24H=$(( NOW - 86400 ))

# Hace 7 días
START_7D=$(( NOW - 604800 ))

# Hace 30 días
START_30D=$(( NOW - 2592000 ))

Preajuste	Segundos	Expresión en shell
1 hora	3.600	$(( $(date +%s) - 3600 ))
24 horas	86.400	$(( $(date +%s) - 86400 ))
7 días	604.800	$(( $(date +%s) - 604800 ))
30 días	2.592.000	$(( $(date +%s) - 2592000 ))

Nota

Los endpoints de CSD (/api/shape/csd/) utilizan segundos epoch (p. ej., 1710000000). Los endpoints de registros de acceso (/api/data/) utilizan marcas de tiempo en ISO 8601 (p. ej., 2024-03-10T00:00:00Z). Los comandos de cada sección utilizan el formato correcto para ese endpoint.

Formato de caso de prueba

Cada prueba a continuación sigue esta estructura:

Campo	Descripción
ID de prueba	Número de capa + ID secuencial (p. ej., DNS-1, TLS-2)
Qué demuestra	El hecho específico de infraestructura que se verifica
Comando	Comando curl o dig listo para ejecutar
CORRECTO / INCORRECTO	Salida esperada para estado saludable vs. no saludable
Solución	Enlace a la sección de configuración o resolución de problemas correspondiente

---

Capa 1: Resolución DNS

El DNS es la base — si el dominio no resuelve a la VIP del balanceador de carga, nada más funcionará.

DNS-1: Resolución de registro A

Qué demuestra: El dominio resuelve a la dirección IP VIP del balanceador de carga.

dig +short xF5XC_DOMAINNAMEx A

Resultado	Significado
CORRECTO — IP VIP devuelta (p. ej., 72.19.3.185)	El dominio resuelve a la IP virtual del LB
INCORRECTO — respuesta vacía	Registro A de DNS no configurado

Solución: Automatización de API — Paso 4: Configurar DNS

Consejo

Caché DNS negativa: Si el dominio devolvió previamente NXDOMAIN, los resolvedores recursivos pueden almacenar en caché ese resultado. Verifique contra el servidor de nombres autoritativo para descartar caché obsoleta: dig +short xF5XC_DOMAINNAMEx A @ns1.f5clouddns.com o use un resolvedor público como @8.8.8.8.

DNS-2: Registro de desafío ACME

Qué demuestra: El registro de desafío ACME existe para el aprovisionamiento automático de certificados TLS.

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

Resultado	Significado
CORRECTO — CNAME a *.autocerts.ves.volterra.io. (DNS externo)	El CNAME de desafío ACME está en su lugar
CORRECTO — registro TXT con valor de dominio (DNS administrado por F5 Distributed Cloud (F5 XC))	Desafío ACME gestionado por la plataforma mediante registro TXT
INCORRECTO — ambos vacíos	Registro ACME no configurado; el certificado permanecerá en PreDomainChallengePending

Nota

Al usar DNS administrado por F5 XC con allow_http_lb_managed_records habilitado, la plataforma crea automáticamente un registro TXT (no un CNAME) en el grupo de conjuntos de registros (RR set group) x-ves-io-managed. Esta validación ACME basada en TXT se gestiona internamente. Al usar DNS externo, debe crear manualmente un CNAME a *.autocerts.ves.volterra.io.

Solución: Para DNS externo, cree el CNAME: _acme-challenge.xF5XC_DOMAINNAMEx → *.autocerts.ves.volterra.io. Para DNS administrado por F5 XC, habilite allow_http_lb_managed_records en la zona DNS — consulte DNS-4. Consulte Automatización de API — Paso 4.

DNS-3: Autoridad de servidores de nombres

Qué demuestra: Si F5 XC es el proveedor DNS autoritativo para el dominio raíz.

dig +short NS xF5XC_ROOT_DOMAINx

Resultado	Significado
Incluye ns1.f5clouddns.com y ns2.f5clouddns.com	DNS administrado por F5 XC — los registros pueden crearse automáticamente
Otros servidores de nombres	DNS externo — los registros deben crearse manualmente

Solución: Automatización de API — Detectar autoridad DNS

DNS-4: Registros administrados por F5 XC habilitados

Qué demuestra: La zona DNS de F5 XC permite la creación automática de registros para balanceadores de carga (solo para DNS administrado por F5 XC).

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'

Resultado	Significado
CORRECTO — true	La plataforma creará automáticamente registros A y ACME para los LB
INCORRECTO — false o null	Registros administrados deshabilitados; habilítelos mediante actualización de la zona

Precaución

Un resultado false es una mala configuración común al usar DNS administrado por F5 XC. Sin los registros administrados habilitados, la plataforma no puede crear automáticamente el registro A (que apunta a la VIP) ni el CNAME de desafío ACME (requerido para el aprovisionamiento del certificado TLS). Esto provoca que el balanceador de carga permanezca bloqueado en VIRTUAL_HOST_PENDING_A_RECORD y el certificado en PreDomainChallengePending. Habilite los registros administrados en la zona DNS o créelos manualmente.

Solución: Automatización de API — Opción A: DNS administrado por F5 XC

---

Capa 2: Certificado TLS

Una vez que el DNS resuelve, el balanceador de carga debe tener un certificado TLS válido.

TLS-1: Estado del certificado

Nota

Esta prueba aplica únicamente al LB HTTPS (${F5XC_LB_NAME}-https). El LB HTTP no tiene certificado. En entornos de demostración, TLS-1 es informativo — si muestra AutoCertDomainRateLimited, la demostración continúa normalmente usando URLs http:// a través del LB HTTP.

Qué demuestra: El certificado TLS automático ha sido emitido en el 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'

Resultado	Significado
CORRECTO — "CertificateValid" o "AutoCertRenewing"	El certificado es válido y está activo
ADVERTENCIA — "DomainChallengePending" o "DomainChallengeStarted"	Desafío ACME en curso — espere entre 5 y 10 minutos
INFO — "AutoCertDomainRateLimited"	Límite de tasa de Let’s Encrypt alcanzado — esperado en entornos de demostración, no afecta al LB HTTP
INCORRECTO — "PreDomainChallengePending"	Registro de desafío ACME faltante — consulte DNS-2

Solución: Asegúrese de que el registro de desafío ACME esté en su lugar (CNAME para DNS externo, o habilite los registros administrados para DNS de F5 XC). El aprovisionamiento del certificado tarda 5 a 10 minutos después de configurar el registro. Si sigue bloqueado después de 15 minutos, consulte Certificado bloqueado — Recreación limpia. Si se alcanzó el límite de tasa, el LB HTTP no se ve afectado.

TLS-2: Detalles del certificado

Qué demuestra: El certificado cubre el dominio esperado y muestra información de vencimiento. Solo aplica al 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
  }'

Resultado	Significado
CORRECTO — auto_cert_info contiene dns_records y metadatos del certificado	Detalles de aprovisionamiento del certificado disponibles
INCORRECTO — auto_cert_info es null o está vacío	Certificado aún no aprovisionado

TLS-3: Conexión TLS en vivo

Qué demuestra: El certificado TLS es válido y el protocolo de enlace (handshake) se completa desde el lado del cliente. Solo aplica cuando el LB HTTPS tiene un certificado válido.

Nota

En entornos de demostración, use curl http://xF5XC_DOMAINNAMEx/ (HTTP, no HTTPS) como ruta de verificación principal. La prueba del protocolo de enlace TLS es opcional — solo funciona cuando el certificado del LB HTTPS es CertificateValid.

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

Resultado	Significado
CORRECTO — muestra SSL connection using TLSv1.3, asunto y fecha de vencimiento válidos	TLS de extremo a extremo funciona correctamente
INCORRECTO — conexión rechazada o error de certificado	Compruebe la resolución DNS y el estado del certificado; si se alcanzó el límite de tasa, use HTTP

TLS-4: Destino del registro ACME desde el LB

Qué demuestra: El balanceador de carga HTTPS reporta el destino ACME correcto para la validación del certificado.

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

Resultado	Significado
CORRECTO — vip_ip y acme_target con valores	Los registros DNS pueden verificarse contra estos valores
INCORRECTO — valores null	Es posible que el LB no tenga configurado https_auto_cert

---

Capa 3: Balanceador de carga HTTP

El balanceador de carga debe estar en un estado listo y correctamente configurado.

LB-1: Estado operacional

Qué demuestra: El balanceador de carga HTTP (principal) está completamente operativo y acepta tráfico.

Nota

El LB HTTP es el objetivo principal de verificación. En entornos de demostración, compruebe primero el LB HTTP (${F5XC_LB_NAME}-http) — alcanza VIRTUAL_HOST_READY tan pronto como el DNS resuelve, sin dependencia de certificados. Use curl http://xF5XC_DOMAINNAMEx/ para la verificación primaria basada en 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'

Resultado	Significado
CORRECTO — "VIRTUAL_HOST_READY"	El LB está operativo
INCORRECTO — "VIRTUAL_HOST_PENDING_A_RECORD"	Registro A de DNS no configurado — consulte DNS-1

Solución: LB bloqueado en VIRTUAL_HOST_PENDING_A_RECORD

LB-2: Configuración de dominio

Qué demuestra: El balanceador de carga HTTP está configurado para el dominio (o dominios) correcto.

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'

Resultado	Significado
CORRECTO — el array contiene su FQDN (p. ej., ["app.example.com"])	El LB está configurado para el dominio esperado
INCORRECTO — dominio ausente o incorrecto	Actualice la especificación del LB con el dominio correcto

LB-3: CSD habilitado en el LB

Qué demuestra: La Defensa del lado del cliente está habilitada en el balanceador de carga con la política de inyección de JS correcta.

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

Resultado	Significado
CORRECTO — csd_enabled: true con js_insert_all_pages en la política	CSD activo con inyección de JS en todas las páginas
INCORRECTO — csd_enabled: false	CSD no configurado en el LB

Solución: Referencia de API — Habilitar CSD en un balanceador de carga

LB-4: Pool de ruta predeterminada

Qué demuestra: El balanceador de carga referencia el pool de origen correcto con el peso y la prioridad esperados.

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

Resultado	Significado
CORRECTO — muestra el nombre del pool de origen con peso/prioridad	El LB está enrutando al backend correcto
INCORRECTO — pool vacío o incorrecto	Actualice la configuración default_route_pools del LB

LB-5: Estado de despliegue (condiciones por sitio)

Qué demuestra: El balanceador de carga está desplegado e informa condiciones saludables en todos los sitios.

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

Resultado	Significado
CORRECTO — state es VIRTUAL_HOST_READY, dns_info con valores	LB completamente desplegado con VIP asignada
INCORRECTO — estado pendiente o dns_info vacío	Problema de DNS o certificado bloqueando el despliegue

Consejo

Cuando el LB no está en estado VIRTUAL_HOST_READY, compruebe .status[].virtual_host_status.error_description para obtener los mismos detalles de error que se muestran en la interfaz de la consola de 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: Resumen completo del LB

Qué demuestra: Instantánea completa de ambas configuraciones de LB para depuración.

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 (secundario — incluye estado del certificado):

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

---

Capa 4: Pool de origen

El pool de origen define los servidores backend a los que el balanceador de carga dirige el tráfico.

OP-1: Configuración del pool de origen

Qué demuestra: El pool de origen existe con el servidor backend correcto, el puerto y el algoritmo de LB.

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

Resultado	Significado
CORRECTO — muestra la IP, el puerto y el algoritmo correctos	Pool de origen configurado correctamente
INCORRECTO — 404 o valores incorrectos	Pool de origen faltante o mal configurado

Solución: Automatización de API — Paso 2: Crear pool de origen

OP-2: TLS hacia el origen

Qué demuestra: Si TLS está configurado para la conexión entre el LB y el Servidor de origen.

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

Resultado	Significado
no_tls (plaintext)	El LB se conecta al origen por HTTP (esperado para la demo de Juice Shop)
use_tls (encrypted)	El LB se conecta al origen por HTTPS

OP-3: Asociación de comprobación de estado

Qué demuestra: El pool de origen tiene la comprobación de estado correcta vinculada (si aplica).

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

Resultado	Significado
CORRECTO — array con referencia de comprobación de estado (name, namespace, kind)	La comprobación de estado está vinculada
ACEPTABLE — array vacío []	Sin comprobación de estado (aceptable — CSD no requiere una)
INCORRECTO — se esperaba una comprobación de estado pero el array está vacío	La comprobación de estado no se encontró en el momento de la creación — consulte Comprobación de estado no vinculada

OP-4: Conectividad al origen

Qué demuestra: El servidor de origen es accesible desde el lado del cliente (no prueba la ruta del LB al origen).

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

Resultado	Significado
CORRECTO — 200 (u otro código HTTP válido)	El servidor de origen está respondiendo
INCORRECTO — 000 o conexión rechazada	Servidor de origen inaccesible desde esta red

Nota

Esto prueba la conectividad directa del cliente al origen. La ruta del LB al origen puede utilizar una ruta de red diferente. Un fallo aquí no necesariamente significa que el LB no pueda alcanzar el origen.

---

Capa 5: Comprobación de estado

Las comprobaciones de estado supervisan la disponibilidad del backend. Son opcionales para CSD pero útiles para despliegues en producción.

HC-1: Configuración de comprobación de estado

Qué demuestra: La comprobación de estado existe con el tipo, la ruta, los tiempos y los umbrales correctos.

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

Resultado	Significado
CORRECTO — muestra tipo HTTP con ruta / y código esperado 200	Comprobación de estado configurada correctamente
INCORRECTO — respuesta 404	La comprobación de estado no existe (puede haberse omitido — consulte Fase 1 Paso 1)

HC-2: Listar todas las comprobaciones de estado

Qué demuestra: Enumera todas las comprobaciones de estado en el namespace para verificar la nomenclatura y la cantidad.

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

Nota

El endpoint de listado devuelve solo datos de resumen (nombre, namespace, descripción). Para ver los detalles completos de configuración (tipo, ruta, intervalo, tiempo de espera), consulte una comprobación de estado individual usando HC-1.

---

Capa 6: Configuración de CSD

CSD debe estar habilitado a nivel de tenant y tener configurada la etiqueta de inyección de JavaScript.

CSD-1: Estado de CSD del tenant

Qué demuestra: CSD está configurado y habilitado para el tenant.

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

Resultado	Significado
CORRECTO — ambos true	CSD está activo para este tenant
INCORRECTO — isConfigured: false	CSD no habilitado a nivel de tenant — contacte al administrador de F5 XC
INCORRECTO — isEnabled: false	CSD configurado pero no activo

CSD-2: Etiqueta de inyección de JS

Qué demuestra: La etiqueta de inyección de JavaScript de CSD está generada y lista para la inyección.

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

Resultado	Significado
CORRECTO — has_script_tag: true	La etiqueta de inyección de JS está configurada
INCORRECTO — has_script_tag: false	Sin etiqueta de script — verifique que CSD esté habilitado y que haya un dominio protegido registrado

CSD-3: Contenido de la etiqueta JS

Qué demuestra: Muestra la etiqueta de script completa para verificación o inyección manual.

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

CSD-4: Registro de dominio protegido

Qué demuestra: El dominio raíz está registrado como dominio protegido de CSD en el 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}'

Resultado	Significado
CORRECTO — muestra un elemento con name no vacío	El dominio está protegido
INCORRECTO — los elementos tienen campos name y namespace vacíos	No hay dominios protegidos registrados — consulte Fase 1 Paso 6

Nota

El endpoint de listado de dominios protegidos devuelve datos de resumen. Los elementos con todos los campos vacíos indican que no hay dominios protegidos configurados. La etiqueta de JavaScript de CSD (CSD-2) es un indicador más confiable de que la protección del dominio está activa.

CSD-5: Verificación de inyección de JS en vivo

Qué demuestra: El JavaScript de CSD se está inyectando efectivamente en las respuestas de página servidas por el balanceador de carga.

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

Resultado	Significado
CORRECTO — devuelve un fragmento de URL de zeronaught.com o shape.com (p. ej., zeronaught.com/__imp_apg__/js/...)	El JavaScript de CSD se está inyectando en las páginas
INCORRECTO — salida vacía	JS no inyectado — compruebe LB-3 y CSD-1

---

Capa 7: Verificación de tráfico

Verifique que el tráfico en vivo está llegando al balanceador de carga y siendo procesado correctamente.

TV-1: Recuento de solicitudes (últimas 24 horas)

Qué demuestra: El tráfico está llegando al balanceador de carga. Un resultado de cero significa que no llega ningún tráfico.

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

Resultado	Significado
CORRECTO — total_requests es una cadena no nula (p. ej., "380")	El tráfico fluye a través del LB
INCORRECTO — "0" o sin datos	Sin tráfico llegando al LB — compruebe DNS-1 y LB-1

Nota

El valor total_hits se devuelve como una cadena (p. ej., "380"), no como un entero. El namespace se infiere de la ruta de URL — no lo incluya en el cuerpo de la solicitud.

TV-2: Distribución de códigos de estado

Qué demuestra: El desglose de códigos de estado de respuesta revela patrones de error.

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

Nota

El endpoint de agregación no admite agrupación por terms — aggs siempre devuelve vacío. Este comando obtiene las 100 entradas de registro más recientes y calcula la distribución en el lado del cliente. Cada entrada de registro es una cadena JSON que debe analizarse con fromjson.

Salida esperada para un sitio saludable:

STATUS_CLASS                  COUNT
2xx                           82
downstream_remote_disconnect  18

Resultado	Significado
CORRECTO — mayoría 2xx	El sitio está sirviendo respuestas exitosas
ADVERTENCIA — alto recuento de 4xx	Errores del cliente (URLs incorrectas, recursos faltantes)
INCORRECTO — alto recuento de 5xx	Errores del servidor — compruebe el estado del servidor de origen

La clase downstream_remote_disconnect indica que el cliente cerró la conexión antes de que la respuesta se completara (común para solicitudes de long-polling o de actualización WebSocket).

TV-3: Muestras de solicitudes recientes

Qué demuestra: Las solicitudes individuales se están registrando con los campos correctos.

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

Precaución

Cada entrada en el array .logs[] es una cadena JSON, no un objeto analizado. Debe pasar por fromjson en jq antes de acceder a los campos (p. ej., .logs[] | fromjson | .method).

TV-4: Inyección de JS de CSD en los registros de acceso

Qué demuestra: Los registros de acceso confirman que el JavaScript de CSD se está inyectando en las respuestas.

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

Resultado	Significado
CORRECTO — injected_count > 0	El JS de CSD se está inyectando en las respuestas de página
INCORRECTO — injected_count: 0	JS no inyectado — compruebe CSD-1 y LB-3

Nota

El campo csd_js_injection solo está presente en las entradas de registro donde ocurrió la inyección. En pruebas, el 40% de las entradas de registro muestreadas tenían csd_js_injection: "true" (solicitudes de páginas HTML), mientras que el 60% no tenía el campo (archivos estáticos como .ico, .js, .css y conexiones WebSocket). Las solicitudes de páginas HTML deberían mostrar inyección; las llamadas a API y las solicitudes de recursos estáticos típicamente no lo harán.

TV-5: Prueba de conectividad de extremo a extremo

Qué demuestra: Una solicitud completa fluye desde el cliente a través del DNS, el LB y el origen, y devuelve una respuesta válida.

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

Resultado	Significado
CORRECTO — muestra conexión, HTTP 200 y content-type	La pila completa está operativa
INCORRECTO — conexión rechazada o error de DNS	Comience la depuración en Capa 1: DNS

Consejo

Para pruebas HTTPS de extremo a extremo (solo cuando el certificado del LB HTTPS es válido), use curl -sv "https://xF5XC_DOMAINNAMEx/" y verifique que aparezca SSL connection en la salida.

---

Capa 8: Telemetría de CSD y política de dominio

Estos comandos consultan los mismos datos que se muestran en el panel de control de la consola CSD, la lista de scripts, los campos de formulario y las vistas de red.

TEL-1: Inventario de scripts

Qué demuestra: CSD está detectando y catalogando los scripts que se ejecutan en el dominio protegido.

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

Resultado	Significado
CORRECTO — scripts listados con niveles de riesgo	CSD está supervisando activamente los scripts
INCORRECTO — array vacío	Consulte Resolución de problemas: Array de scripts vacío

Consejo

Los nombres de los scripts son URLs completas y pueden ser muy largas. El comando anterior trunca los nombres a 50 caracteres para mejorar la legibilidad en el terminal. Elimine el filtro de truncamiento para ver las URLs completas.

TEL-2: Dominios detectados

Qué demuestra: CSD ha detectado dominios de origen de scripts y los ha clasificado por estado.

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

Resultado	Significado
CORRECTO — total > 0 con dominios listados	CSD está rastreando dominios de scripts
ADVERTENCIA — action_needed > 0	Algunos dominios necesitan revisión
INCORRECTO — respuesta vacía	Sin datos de telemetría — compruebe CSD-5

TEL-3: Estado de la política de dominio

Qué demuestra: Muestra la distribución de dominios permitidos vs. mitigados y si la política es consistente.

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

Resultado	Significado
CORRECTO — action_needed: 0	Todos los dominios han sido revisados y clasificados
ADVERTENCIA — action_needed > 0	Los dominios listados en domains_needing_action requieren revisión

TEL-4: Inventario de campos de formulario

Qué demuestra: CSD ha detectado campos de formulario que los scripts están leyendo, con clasificación de sensibilidad.

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

Resultado	Significado
CORRECTO — campos de formulario listados con sensibilidad	CSD está rastreando el acceso a campos de formulario
INFO — array vacío	No se detectaron campos de formulario (esperado si el sitio no tiene formularios)

TEL-5: Análisis detallado de un script

Qué demuestra: Información detallada sobre un script específico, incluyendo riesgo, comportamientos e interacciones de red.

Primero, obtenga un ID de script de TEL-1 y luego consulte sus detalles:

SCRIPT_ID="your-script-id"

# Resumen (nivel de riesgo, tipo, dominio de origen)
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}'

# Comportamientos a lo largo del tiempo
curl -s \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/shape/csd/namespaces/xF5XC_NAMESPACEx/scripts/${SCRIPT_ID}/behaviors" \
  | jq '.behaviors'

# Interacciones de red (dominios con los que se comunica el script)
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: Usuarios afectados

Qué demuestra: Lista los usuarios impactados por un script específico, mostrando el alcance de la exposición.

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: Recuento de scripts por nivel de riesgo

Qué demuestra: Distribución de riesgo agregada en todos los scripts detectados.

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

Resultado	Significado
CORRECTO — todo No Risk	No se detectaron scripts de riesgo
ADVERTENCIA — Low Risk o High Risk presentes	Revise los scripts marcados en TEL-5

TEL-8: Actualidad de la telemetría

Qué demuestra: Los datos de telemetría de CSD son recientes, confirmando que la supervisión está activa.

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

Resultado	Significado
CORRECTO — latest_seen es dentro de las últimas 24 horas	La telemetría está recopilando datos activamente
ADVERTENCIA — latest_seen tiene más de 24 horas	El tráfico puede haberse detenido o el procesamiento de CSD tiene retraso

---

Panel de control de pila completa

Ejecute un único comando que comprueba todos los indicadores de estado críticos en cada capa y produce una tabla de resumen:

echo "=== Panel de verificación de CSD ==="
echo ""

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

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

# Capa 6: Estado de 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')

# Capa 6: Configuración de 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')

# Capa 7: Tráfico (últimas 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" "COMPROBACIÓN" "ESTADO"
printf "%-28s %s\n" "----------------------------" "----------------------------"
printf "%-28s %s\n" "[DNS] Registro A" "${DNS_A:-NOT_FOUND}"
printf "%-28s %s\n" "[DNS] CNAME ACME" "${DNS_ACME:-NOT_FOUND}"
printf "%-28s %s\n" "[TLS] Certificado" "$CERT_STATE"
printf "%-28s %s\n" "[LB] Estado" "$LB_STATE"
printf "%-28s %s\n" "[LB] Dominios" "$DOMAINS"
printf "%-28s %s\n" "[LB] Pool de ruta" "$ROUTE_POOL"
printf "%-28s %s\n" "[LB] CSD en LB" "$CSD_ON_LB"
printf "%-28s %s\n" "[CSD] Configurado (tenant)" "$CSD_CONFIGURED"
printf "%-28s %s\n" "[CSD] Habilitado" "$CSD_ENABLED"
printf "%-28s %s\n" "[CSD] Etiqueta script JS" "$JS_TAG"
printf "%-28s %s\n" "[Tráfico] Solicitudes (24h)" "$TRAFFIC"

---

Referencia de campos de registros de acceso

Precaución

Cada entrada en el array .logs[] es una cadena JSON, no un objeto analizado. Debe pasar por fromjson en jq antes de acceder a los campos (p. ej., .logs[] | fromjson | .method).

Campo	Tipo	Descripción
@timestamp	string	Marca de tiempo de la solicitud (ISO 8601). Tenga en cuenta el prefijo @ — acceda con .["@timestamp"] en jq
method	string	Método HTTP (GET, POST, etc.)
req_path	string	Ruta URI de la solicitud
rsp_code	string	Código de estado HTTP de la respuesta como cadena (p. ej., "200", "404")
rsp_code_class	string	Clase del código de estado (2xx, 3xx, 4xx, 5xx o downstream_remote_disconnect)
src_ip	string	Dirección IP de origen del cliente
dst_ip	string	Dirección IP de destino (VIP)
domain	string	Valor del encabezado Host de la solicitud
user_agent	string	Cadena User-Agent del cliente
rsp_size	string	Tamaño del cuerpo de la respuesta en bytes (devuelto como cadena)
req_size	string	Tamaño del cuerpo de la solicitud en bytes (devuelto como cadena)
duration_with_data_tx_delay	string	Duración total de la solicitud en segundos (devuelto como cadena, p. ej., "0.024219")
csd_js_injection	string	"true" cuando se inyectó JavaScript de CSD (solo presente cuando está activo)

Referencia de campos de telemetría de CSD

Campo	Endpoint	Descripción
isConfigured	status	CSD habilitado a nivel de tenant
isEnabled	status	CSD activo para este namespace
scripts[]	scripts	Array de objetos de scripts detectados
.script_name	scripts	URL completa del archivo JavaScript
.risk_level	scripts	Nivel de riesgo (No Risk, Low Risk, High Risk)
.status	scripts	AN (Action Needed) o NA (No Action Needed)
.form_fields_read	scripts	Número de campos de formulario que lee el script
.affected_users_count	scripts	Número de usuarios/sesiones únicas afectadas
domain_summary	detected_domains	Recuentos por estado: .actionNeededCount.count, .mitigatedDomains.count, .allowedDomains.count, .totalDomains.count (cada uno tiene .count y .lastUpdated)
domains_list[]	detected_domains	Array de objetos de dominio detectados con .domain, .status, .category, .firstSeenDate, .latestSeenDate (segundos epoch como cadenas)
form_fields[]	formFields	Array de objetos de campos de formulario detectados
.analysis	formFields	Clasificación de sensibilidad (Sensitive, Not Sensitive)

Resolución de problemas

Sin registros de acceso

Si TV-1 devuelve 0:

1. Compruebe la resolución DNS — verifique que el dominio resuelve a la VIP del LB:

   dig +short xF5XC_DOMAINNAMEx A

   Si está vacío, el DNS no está configurado. Consulte Automatización de API — Paso 4.

2. Compruebe el estado del LB — el balanceador de carga debe estar en 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. Envíe una solicitud de prueba — genere tráfico para confirmar la conectividad de extremo a extremo:

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

   Busque una respuesta HTTP exitosa. Use https:// solo si el certificado del LB HTTPS es válido.

Registros administrados deshabilitados en la zona DNS

Si DNS-4 devuelve false, la creación automática de registros está deshabilitada aunque F5 XC sea el proveedor DNS autoritativo. Esta es una mala configuración común que provoca que falten tanto el registro A como el CNAME ACME, lo que impide que el balanceador de carga alcance VIRTUAL_HOST_READY y que se emita el certificado.

Para habilitar los registros administrados, actualice la configuración de la zona DNS para establecer allow_http_lb_managed_records: true. Consulte Automatización de API — Opción A: DNS administrado por F5 XC para la llamada de API.

LB bloqueado en VIRTUAL_HOST_PENDING_A_RECORD

El balanceador de carga está esperando un registro A de DNS que apunte a su VIP. Consulte LB bloqueado en VIRTUAL_HOST_PENDING_A_RECORD para ver los pasos detallados de resolución.

Certificado bloqueado en PreDomainChallengePending

El certificado TLS automático requiere un registro de desafío ACME. El método depende de su proveedor DNS:

DNS administrado por F5 XC: Habilite allow_http_lb_managed_records en la zona DNS (DNS-4). La plataforma crea automáticamente un registro de desafío ACME basado en TXT en el grupo de conjuntos de registros x-ves-io-managed. Si el certificado permanece bloqueado después de habilitar los registros administrados, elimine y vuelva a crear el balanceador de carga para activar una nueva solicitud de certificado.

DNS externo: Cree un registro CNAME en su proveedor DNS:

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

Verifique que el registro existe:

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

Si ambos están vacíos, el registro ACME no está configurado. El aprovisionamiento del certificado tarda entre 5 y 10 minutos después de que el registro esté en su lugar. Compruebe el estado de error del LB para ver errores de validación ACME específicos:

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

CSD debe ser habilitado a nivel de tenant por un administrador de F5 XC. Esta es una configuración de todo el tenant que no puede configurarse a través de la API del namespace. Contacte a su administrador para habilitar la Defensa del lado del cliente.

Array de scripts vacío

Si TEL-1 devuelve un array vacío:

1. Compruebe el dominio protegido — CSD supervisa los scripts solo en los dominios registrados:

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

2. Verifique la inyección de JS — confirme que la etiqueta de script de CSD se está inyectando en las páginas:

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

   Si no hay coincidencia, el JavaScript de CSD no se está inyectando. Compruebe que el LB tenga client_side_defense habilitado.

3. Espere el tiempo de procesamiento — después de habilitar CSD por primera vez o registrar un nuevo dominio protegido, la detección de scripts puede tardar entre 5 y 15 minutos. Genere tráfico hacia el sitio y espere antes de volver a comprobar.

Referencia rápida

Preajustes de rango de tiempo

Período	Desplazamiento epoch	ISO 8601 (Linux)	ISO 8601 (macOS)
1 hora	$(( $(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 horas	$(( $(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 días	$(( $(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 días	$(( $(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

Resumen de capas de verificación

Capa	Pruebas	Qué cubre
1. Resolución DNS	DNS-1 a DNS-4	Registro A, CNAME ACME, autoridad de servidores de nombres, registros administrados
2. Certificado TLS	TLS-1 a TLS-4	Estado del certificado, detalles, handshake en vivo, destino ACME
3. Balanceador de carga HTTP	LB-1 a LB-6	Estado, dominios, indicador CSD, pools de rutas, despliegue, resumen
4. Pool de origen	OP-1 a OP-4	Configuración, modo TLS, asociación de HC, conectividad al origen
5. Comprobación de estado	HC-1 a HC-2	Configuración de HC, listar todos los HC
6. Configuración de CSD	CSD-1 a CSD-5	Estado del tenant, etiqueta JS, dominios protegidos, inyección en vivo
7. Verificación de tráfico	TV-1 a TV-5	Recuento de solicitudes, códigos de estado, muestras, JS en registros, prueba E2E
8. Telemetría de CSD	TEL-1 a TEL-8	Scripts, dominios, política, campos de formulario, análisis detallado, usuarios, riesgo, actualidad

Resumen de endpoints

Diagnóstico	Endpoint	Método	Formato de tiempo
Recuento de solicitudes	/api/data/namespaces/\{ns\}/access_logs/aggregation	POST	ISO 8601
Códigos de estado	/api/data/namespaces/\{ns\}/access_logs	POST	ISO 8601
Solicitudes recientes	/api/data/namespaces/\{ns\}/access_logs	POST	ISO 8601
Estado del LB	/api/config/namespaces/\{ns\}/http_loadbalancers/\{name\}	GET	Ninguno
Pool de origen	/api/config/namespaces/\{ns\}/origin_pools/\{name\}	GET	Ninguno
Comprobación de estado	/api/config/namespaces/\{ns\}/healthchecks/\{name\}	GET	Ninguno
Zona DNS	/api/config/dns/namespaces/system/dns_zones/\{zone\}	GET	Ninguno
Estado de CSD	/api/shape/csd/namespaces/\{ns\}/status	GET	Ninguno
Configuración de JS	/api/shape/csd/namespaces/\{ns\}/js_configuration	GET	Ninguno
Dominios protegidos	/api/shape/csd/namespaces/\{ns\}/protected_domains	GET	Ninguno
Lista de scripts	/api/shape/csd/namespaces/\{ns\}/scripts	POST	Segundos epoch
Dominios detectados	/api/shape/csd/namespaces/\{ns\}/detected_domains	GET	Ninguno
Campos de formulario	/api/shape/csd/namespaces/\{ns\}/formFields	GET	Segundos epoch (parámetros de consulta)
Detalles del script	/api/shape/csd/namespaces/\{ns\}/scripts/\{id\}/dashboard	GET	Ninguno
Comportamientos del script	/api/shape/csd/namespaces/\{ns\}/scripts/\{id\}/behaviors	GET	Ninguno
Red del script	/api/shape/csd/namespaces/\{ns\}/scripts/\{id\}/networkInteractions	GET	Ninguno
Usuarios afectados	/api/shape/csd/namespaces/\{ns\}/scripts/\{id\}/affectedUsers	POST	Segundos epoch