Diagnósticos e Verificação

Esta página fornece uma matriz de verificação UAT em camadas para validar sua implantação do Client-Side Defense de ponta a ponta. Cada caso de teste segue a cadeia de dependências de infraestrutura — da resolução DNS até a telemetria do CSD — para que você possa provar sistematicamente que cada componente está funcionando corretamente.

Estes comandos são o equivalente via API do Guia do Console CSD — utilize-os quando precisar verificar pelo terminal, automatizar o monitoramento ou demonstrar as capacidades do CSD sem a interface gráfica.

Pré-requisitos

Configure suas variáveis de ambiente conforme descrito em Automação via API — Configuração do Ambiente:

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

Todos os comandos abaixo utilizam o formato de espaço reservado xTOKENx. Substitua pelas suas variáveis de ambiente ($F5XC_API_TOKEN, $F5XC_NAMESPACE, etc.) ou utilize o formulário interativo no topo da página.

Notas sobre o Comportamento da API

Nota

PUT e DELETE retornam \{\} vazio com HTTP 200 — esta é a resposta de sucesso esperada, não um erro. Apenas POST retorna o objeto criado. Endpoints de listagem (ex.: /healthchecks) e endpoints GET individuais (ex.: /healthchecks/\{name\}) retornam estruturas de resposta diferentes — consulte Referência da API — Convenções da API para detalhes sobre os caminhos jq corretos para cada um.

Auxiliares de Intervalo de Tempo

Muitos endpoints do CSD requerem timestamps em epoch (segundos desde o Unix epoch). Estes comandos de uma linha calculam os horários de início/fim para intervalos comuns.

Multiplataforma (macOS + Linux):

# Hora atual em segundos epoch
NOW=$(date +%s)

# 1 hora atrás
START_1H=$(( NOW - 3600 ))

# 24 horas atrás
START_24H=$(( NOW - 86400 ))

# 7 dias atrás
START_7D=$(( NOW - 604800 ))

# 30 dias atrás
START_30D=$(( NOW - 2592000 ))

Predefinição	Segundos	Expressão shell
1 hora	3.600	$(( $(date +%s) - 3600 ))
24 horas	86.400	$(( $(date +%s) - 86400 ))
7 dias	604.800	$(( $(date +%s) - 604800 ))
30 dias	2.592.000	$(( $(date +%s) - 2592000 ))

Nota

Os endpoints do CSD (/api/shape/csd/) utilizam segundos epoch (ex.: 1710000000). Os endpoints de log de acesso (/api/data/) utilizam timestamps no formato ISO 8601 (ex.: 2024-03-10T00:00:00Z). Os comandos em cada seção utilizam o formato correto para aquele endpoint.

Formato dos Casos de Teste

Cada teste abaixo segue esta estrutura:

Campo	Descrição
ID do Teste	Número da camada + ID sequencial (ex.: DNS-1, TLS-2)
O que comprova	O fato específico de infraestrutura sendo verificado
Comando	Comando curl ou dig pronto para execução
PASSOU / FALHOU	Saída esperada para estado saudável vs. não saudável
Correção	Link para a seção de configuração ou solução de problemas relevante

---

Camada 1: Resolução DNS

O DNS é a base — se o domínio não resolver para o VIP do balanceador de carga, nada mais funciona.

DNS-1: Resolução do Registro A

O que comprova: O domínio resolve para o endereço IP do VIP do balanceador de carga.

dig +short xF5XC_DOMAINNAMEx A

Resultado	Significado
PASSOU — IP do VIP retornado (ex.: 72.19.3.185)	Domínio resolve para o IP virtual do LB
FALHOU — resposta vazia	Registro A do DNS não configurado

Correção: Automação via API — Passo 4: Configurar DNS

Dica

Cache DNS negativo: Se o domínio retornou NXDOMAIN anteriormente, os resolvedores recursivos podem ter armazenado esse resultado em cache. Verifique contra o servidor de nomes autoritativo para descartar cache obsoleto: dig +short xF5XC_DOMAINNAMEx A @ns1.f5clouddns.com ou utilize um resolvedor público como @8.8.8.8.

DNS-2: Registro de Desafio ACME

O que comprova: O registro de desafio ACME existe para o provisionamento automático do certificado TLS.

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

Resultado	Significado
PASSOU — CNAME para *.autocerts.ves.volterra.io. (DNS externo)	CNAME de desafio ACME está configurado
PASSOU — registro TXT com valor do domínio (DNS gerenciado pelo F5 Distributed Cloud (F5 XC))	Desafio ACME gerenciado pela plataforma via registro TXT
FALHOU — ambos vazios	Registro ACME não configurado; o certificado permanecerá em PreDomainChallengePending

Nota

Ao utilizar o DNS gerenciado pelo F5 XC com allow_http_lb_managed_records habilitado, a plataforma cria automaticamente um registro TXT (não um CNAME) no grupo de conjuntos de registros x-ves-io-managed. Essa validação ACME baseada em TXT é tratada internamente. Ao utilizar DNS externo, você deve criar manualmente um CNAME para *.autocerts.ves.volterra.io.

Correção: Para DNS externo, crie o CNAME: _acme-challenge.xF5XC_DOMAINNAMEx → *.autocerts.ves.volterra.io. Para DNS gerenciado pelo F5 XC, habilite allow_http_lb_managed_records na zona DNS — consulte DNS-4. Veja Automação via API — Passo 4.

DNS-3: Autoridade dos Servidores de Nomes

O que comprova: Se o F5 XC é o provedor DNS autoritativo para o domínio raiz.

dig +short NS xF5XC_ROOT_DOMAINx

Resultado	Significado
Inclui ns1.f5clouddns.com e ns2.f5clouddns.com	DNS gerenciado pelo F5 XC — registros podem ser criados automaticamente
Outros servidores de nomes	DNS externo — registros devem ser criados manualmente

Correção: Automação via API — Detectar Autoridade DNS

DNS-4: Registros Gerenciados pelo F5 XC Habilitados

O que comprova: A zona DNS do F5 XC permite a criação automática de registros para balanceadores de carga (somente DNS gerenciado pelo 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
PASSOU — true	A plataforma criará automaticamente registros A e ACME para LBs
FALHOU — false ou null	Registros gerenciados desabilitados; habilite via atualização da zona

Cuidado

Um resultado false é uma configuração incorreta comum ao utilizar o DNS gerenciado pelo F5 XC. Sem os registros gerenciados habilitados, a plataforma não consegue criar automaticamente o registro A (apontando para o VIP) nem o CNAME de desafio ACME (necessário para o provisionamento do certificado TLS). Isso faz com que o balanceador de carga permaneça preso em VIRTUAL_HOST_PENDING_A_RECORD e o certificado fique em PreDomainChallengePending. Habilite os registros gerenciados na zona DNS ou crie os registros manualmente.

Correção: Automação via API — Opção A: DNS Gerenciado pelo F5 XC

---

Camada 2: Certificado TLS

Após a resolução do DNS, o balanceador de carga deve ter um certificado TLS válido.

TLS-1: Estado do Certificado

Nota

Este teste se aplica somente ao LB HTTPS (${F5XC_LB_NAME}-https). O LB HTTP não possui certificado. Em ambientes de demonstração, TLS-1 é informativo — se exibir AutoCertDomainRateLimited, a demonstração prossegue normalmente utilizando URLs http:// via LB HTTP.

O que comprova: O certificado TLS automático foi emitido no 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
PASSOU — "CertificateValid" ou "AutoCertRenewing"	Certificado é válido e ativo
AVISO — "DomainChallengePending" ou "DomainChallengeStarted"	Desafio ACME em andamento — aguarde 5–10 minutos
INFO — "AutoCertDomainRateLimited"	Limite de taxa do Let’s Encrypt atingido — esperado em ambientes de demonstração, não afeta o LB HTTP
FALHOU — "PreDomainChallengePending"	Registro de desafio ACME ausente — consulte DNS-2

Correção: Certifique-se de que o registro de desafio ACME está configurado (CNAME para DNS externo, ou habilite registros gerenciados para DNS do F5 XC). O provisionamento do certificado leva 5–10 minutos após o registro ser configurado. Se ficar preso por mais de 15 minutos, consulte Certificado Preso — Recriação Limpa. Se houver limite de taxa, o LB HTTP não é afetado.

TLS-2: Detalhes do Certificado

O que comprova: O certificado cobre o domínio esperado e exibe informações de expiração. Aplicável somente ao 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
PASSOU — auto_cert_info contém dns_records e metadados do certificado	Detalhes do provisionamento do certificado disponíveis
FALHOU — auto_cert_info é null ou vazio	Certificado ainda não provisionado

TLS-3: Handshake TLS ao Vivo

O que comprova: O certificado TLS é válido e o handshake é concluído do lado do cliente. Aplicável somente quando o LB HTTPS possui um certificado válido.

Nota

Em ambientes de demonstração, utilize curl http://xF5XC_DOMAINNAMEx/ (HTTP, não HTTPS) como caminho de verificação principal. O teste de handshake TLS é opcional — funciona somente quando o certificado do LB HTTPS está com CertificateValid.

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

Resultado	Significado
PASSOU — exibe SSL connection using TLSv1.3, subject e expiração válidos	TLS de ponta a ponta está funcionando
FALHOU — conexão recusada ou erro de certificado	Verifique a resolução DNS e o estado do certificado; se houver limite de taxa, utilize HTTP

TLS-4: Destino do Registro ACME a partir do LB

O que comprova: O balanceador de carga HTTPS informa o destino ACME correto para validação do 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
PASSOU — vip_ip e acme_target preenchidos	Registros DNS podem ser verificados em relação a esses valores
FALHOU — valores null	O LB pode não ter https_auto_cert configurado

---

Camada 3: Balanceador de Carga HTTP

O balanceador de carga deve estar em estado pronto e corretamente configurado.

LB-1: Estado Operacional

O que comprova: O balanceador de carga HTTP (principal) está totalmente operacional e aceitando tráfego.

Nota

O LB HTTP é o alvo principal de verificação. Em ambientes de demonstração, verifique o LB HTTP (${F5XC_LB_NAME}-http) primeiro — ele atinge VIRTUAL_HOST_READY assim que o DNS resolver, sem dependência de certificado. Utilize curl http://xF5XC_DOMAINNAMEx/ para a verificação primária baseada em 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
PASSOU — "VIRTUAL_HOST_READY"	LB está operacional
FALHOU — "VIRTUAL_HOST_PENDING_A_RECORD"	Registro A do DNS não configurado — consulte DNS-1

Correção: LB Preso em VIRTUAL_HOST_PENDING_A_RECORD

LB-2: Configuração de Domínio

O que comprova: O balanceador de carga HTTP está configurado para os domínios corretos.

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
PASSOU — array contém seu FQDN (ex.: ["app.example.com"])	LB está configurado para o domínio esperado
FALHOU — domínio ausente ou incorreto	Atualize a especificação do LB com o domínio correto

LB-3: CSD Habilitado no LB

O que comprova: O Client-Side Defense está habilitado no balanceador de carga com a política de injeção de JS correta.

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
PASSOU — csd_enabled: true com js_insert_all_pages na política	CSD ativo com injeção de JS em todas as páginas
FALHOU — csd_enabled: false	CSD não configurado no LB

Correção: Referência da API — Habilitar CSD em um Balanceador de Carga

LB-4: Pool de Rota Padrão

O que comprova: O balanceador de carga referencia o pool de origem correto com peso e prioridade 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
PASSOU — exibe o nome do seu pool de origem com peso/prioridade	LB está roteando para o backend correto
FALHOU — pool vazio ou incorreto	Atualize a configuração default_route_pools do LB

LB-5: Status de Implantação (Condições por Site)

O que comprova: O balanceador de carga está implantado e reporta condições saudáveis em todos os 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
  }'

Resultado	Significado
PASSOU — state é VIRTUAL_HOST_READY, dns_info preenchido	LB totalmente implantado com VIP atribuído
FALHOU — estado pendente ou dns_info vazio	Problema de DNS ou certificado bloqueando a implantação

Dica

Quando o LB não está no estado VIRTUAL_HOST_READY, verifique .status[].virtual_host_status.error_description para obter os mesmos detalhes de erro exibidos na interface do console do 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: Resumo Completo do LB

O que comprova: Instantâneo abrangente de ambas as configurações de LB para depuração.

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 (secundário — inclui estado do 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]
  }'

---

Camada 4: Pool de Origem

O pool de origem define os servidores backend para os quais o balanceador de carga roteia o tráfego.

OP-1: Configuração do Pool de Origem

O que comprova: O pool de origem existe com o servidor backend correto, porta e 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
PASSOU — exibe IP, porta e algoritmo corretos	Pool de origem configurado corretamente
FALHOU — 404 ou valores incorretos	Pool de origem ausente ou mal configurado

Correção: Automação via API — Passo 2: Criar Pool de Origem

OP-2: TLS para a Origem

O que comprova: Se o TLS está configurado para a conexão entre o LB e o servidor de origem.

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)	LB conecta-se à origem via HTTP (esperado para demonstração do Juice Shop)
use_tls (encrypted)	LB conecta-se à origem via HTTPS

OP-3: Associação de Verificação de Integridade

O que comprova: O pool de origem possui a verificação de integridade correta vinculada (se aplicável).

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
PASSOU — array com referência de verificação de integridade (name, namespace, kind)	Verificação de integridade está vinculada
OK — array vazio []	Sem verificação de integridade (aceitável — o CSD não requer uma)
FALHOU — era esperada uma verificação de integridade, mas o array está vazio	Verificação de integridade não encontrada no momento da criação — consulte Verificação de Integridade Não Vinculada

OP-4: Conectividade com a Origem

O que comprova: O servidor de origem é acessível a partir do lado do cliente (não testa o caminho LB para a origem).

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

Resultado	Significado
PASSOU — 200 (ou outro código HTTP válido)	Servidor de origem está respondendo
FALHOU — 000 ou conexão recusada	Servidor de origem inacessível a partir desta rede

Nota

Este teste verifica a conectividade direta do cliente para a origem. O caminho do LB para a origem pode utilizar um caminho de rede diferente. Uma falha aqui não significa necessariamente que o LB não consegue alcançar a origem.

---

Camada 5: Verificação de Integridade

As verificações de integridade monitoram a disponibilidade do backend. São opcionais para o CSD, mas úteis para implantações em produção.

HC-1: Configuração da Verificação de Integridade

O que comprova: A verificação de integridade existe com o tipo, caminho, temporização e limites corretos.

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
PASSOU — exibe tipo HTTP com caminho / e resposta esperada 200	Verificação de integridade configurada corretamente
FALHOU — resposta 404	Verificação de integridade não existe (pode ter sido ignorada — consulte Fase 1 Passo 1)

HC-2: Listar Todas as Verificações de Integridade

O que comprova: Enumera todas as verificações de integridade no namespace para verificar nomenclatura e contagem.

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

O endpoint de listagem retorna apenas dados resumidos (name, namespace, description). Para ver detalhes completos de configuração (tipo, caminho, intervalo, timeout), consulte uma verificação de integridade individual usando HC-1.

---

Camada 6: Configuração do CSD

O CSD deve estar habilitado no nível do tenant e ter a tag de injeção de JavaScript configurada.

CSD-1: Status do CSD no Tenant

O que comprova: O CSD está configurado e habilitado para o tenant.

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

Resultado	Significado
PASSOU — ambos true	CSD está ativo para este tenant
FALHOU — isConfigured: false	CSD não habilitado no nível do tenant — contate o administrador do F5 XC
FALHOU — isEnabled: false	CSD configurado, mas não ativo

CSD-2: Tag de Injeção de JS

O que comprova: A tag de injeção de JavaScript do CSD está gerada e pronta para injeção.

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
PASSOU — has_script_tag: true	Tag de injeção de JS está configurada
FALHOU — has_script_tag: false	Sem tag de script — verifique se o CSD está habilitado e se um domínio protegido está registrado

CSD-3: Conteúdo da Tag JS

O que comprova: Exibe a tag de script completa para verificação ou injeção 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 Domínio Protegido

O que comprova: O domínio raiz está registrado como domínio protegido pelo CSD no 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
PASSOU — exibe um item com name não vazio	Domínio está protegido
FALHOU — itens com campos name e namespace vazios	Nenhum domínio protegido registrado — consulte Fase 1 Passo 6

Nota

O endpoint de listagem de domínios protegidos retorna dados resumidos. Itens com todos os campos vazios indicam que nenhum domínio protegido está configurado. A tag JavaScript do CSD (CSD-2) é um indicador mais confiável de que a proteção de domínio está ativa.

CSD-5: Verificação de Injeção de JS ao Vivo

O que comprova: O JavaScript do CSD está sendo efetivamente injetado nas respostas de página servidas pelo balanceador de carga.

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

Resultado	Significado
PASSOU — retorna um fragmento de URL zeronaught.com ou shape.com (ex.: zeronaught.com/__imp_apg__/js/...)	O JavaScript do CSD está sendo injetado nas páginas
FALHOU — saída vazia	JS não injetado — verifique LB-3 e CSD-1

---

Camada 7: Verificação de Tráfego

Verifique se o tráfego ao vivo está chegando ao balanceador de carga e sendo processado corretamente.

TV-1: Contagem de Requisições (Últimas 24 Horas)

O que comprova: O tráfego está chegando ao balanceador de carga. Resultados zerados significam que nenhum tráfego está chegando.

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
PASSOU — total_requests é uma string não zero (ex.: "380")	Tráfego está fluindo pelo LB
FALHOU — "0" ou sem dados	Nenhum tráfego chegando ao LB — verifique DNS-1 e LB-1

Nota

O valor total_hits é retornado como uma string (ex.: "380"), não como um inteiro. O namespace é inferido a partir do caminho da URL — não o inclua no corpo da requisição.

TV-2: Distribuição de Códigos de Status

O que comprova: A distribuição dos códigos de status de resposta revela padrões de erro.

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

O endpoint de agregação não suporta agrupamento por terms — aggs sempre retorna vazio. Este comando busca as 100 entradas de log mais recentes e calcula a distribuição no lado do cliente. Cada entrada de log é uma string JSON que deve ser analisada com fromjson.

Saída esperada para um site saudável:

STATUS_CLASS                  COUNT
2xx                           82
downstream_remote_disconnect  18

Resultado	Significado
PASSOU — maioria 2xx	Site está servindo respostas com sucesso
AVISO — alta contagem 4xx	Erros do cliente (URLs incorretas, recursos ausentes)
FALHOU — alta contagem 5xx	Erros do servidor — verifique a integridade do servidor de origem

A classe downstream_remote_disconnect indica que o cliente encerrou a conexão antes da resposta ser concluída (comum para requisições de long-polling ou de upgrade para WebSocket).

TV-3: Amostras de Requisições Recentes

O que comprova: Requisições individuais estão sendo registradas com os campos corretos.

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

Cuidado

Cada entrada no array .logs[] é uma string JSON, não um objeto analisado. Você deve usar fromjson no jq antes de acessar os campos (ex.: .logs[] | fromjson | .method).

TV-4: Injeção de JS do CSD nos Logs de Acesso

O que comprova: Os logs de acesso confirmam que o JavaScript do CSD está sendo injetado nas respostas.

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
PASSOU — injected_count > 0	JS do CSD está sendo injetado nas respostas de página
FALHOU — injected_count: 0	JS não injetado — verifique CSD-1 e LB-3

Nota

O campo csd_js_injection está presente apenas nas entradas de log onde a injeção ocorreu. Em testes, 40% das entradas de log amostradas tinham csd_js_injection: "true" (requisições de páginas HTML), enquanto 60% não tinham o campo (ativos estáticos como arquivos .ico, .js, .css e conexões WebSocket). Requisições de páginas HTML devem mostrar injeção; chamadas de API e requisições de ativos estáticos geralmente não terão.

TV-5: Teste de Conectividade de Ponta a Ponta

O que comprova: Uma requisição completa flui do cliente através do DNS, LB e origem e retorna uma resposta válida.

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

Resultado	Significado
PASSOU — exibe conexão, HTTP 200 e content-type	Toda a pilha está operacional
FALHOU — conexão recusada ou erro de DNS	Inicie a depuração na Camada 1: DNS

Dica

Para testes de ponta a ponta com HTTPS (somente quando o certificado do LB HTTPS é válido), utilize curl -sv "https://xF5XC_DOMAINNAMEx/" e verifique SSL connection na saída.

---

Camada 8: Telemetria do CSD & Política de Domínio

Estes comandos consultam os mesmos dados exibidos no painel do Console CSD, lista de scripts, campos de formulário e visualizações de rede.

TEL-1: Inventário de Scripts

O que comprova: O CSD está detectando e catalogando scripts em execução no domínio 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
PASSOU — scripts listados com níveis de risco	CSD está monitorando scripts ativamente
FALHOU — array vazio	Consulte Solução de Problemas: Array de Scripts Vazio

Dica

Os nomes dos scripts são URLs completas e podem ser muito longas. O comando acima trunca os nomes para 50 caracteres para facilitar a leitura no terminal. Remova o filtro de truncamento para ver as URLs completas.

TEL-2: Domínios Detectados

O que comprova: O CSD detectou domínios de origem de scripts e os classificou por status.

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
PASSOU — total > 0 com domínios listados	CSD está rastreando domínios de scripts
AVISO — action_needed > 0	Alguns domínios precisam de revisão
FALHOU — resposta vazia	Sem dados de telemetria — verifique CSD-5

TEL-3: Estado da Política de Domínio

O que comprova: Exibe a distribuição de domínios permitidos vs. mitigados e se a política é 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
PASSOU — action_needed: 0	Todos os domínios foram revisados e classificados
AVISO — action_needed > 0	Domínios listados em domains_needing_action requerem revisão

TEL-4: Inventário de Campos de Formulário

O que comprova: O CSD detectou campos de formulário que os scripts estão lendo, com classificação de sensibilidade.

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
PASSOU — campos de formulário listados com sensibilidade	CSD está rastreando o acesso a campos de formulário
INFO — array vazio	Nenhum campo de formulário detectado (esperado se não há formulários no site)

TEL-5: Análise Detalhada de Script

O que comprova: Informações detalhadas sobre um script específico, incluindo risco, comportamentos e interações de rede.

Primeiro, obtenha um ID de script em TEL-1, depois consulte seus detalhes:

SCRIPT_ID="your-script-id"

# Visão geral (nível de risco, tipo, domínio de origem)
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}'

# Comportamentos ao longo do tempo
curl -s \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/shape/csd/namespaces/xF5XC_NAMESPACEx/scripts/${SCRIPT_ID}/behaviors" \
  | jq '.behaviors'

# Interações de rede (domínios com os quais o script se comunica)
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: Usuários Afetados

O que comprova: Lista os usuários impactados por um script específico, mostrando o escopo da exposição.

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: Contagem de Scripts por Nível de Risco

O que comprova: Distribuição agregada de risco em todos os 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
PASSOU — todos No Risk	Nenhum script de risco detectado
AVISO — Low Risk ou High Risk presentes	Revise os scripts sinalizados em TEL-5

TEL-8: Atualidade da Telemetria

O que comprova: Os dados de telemetria do CSD são recentes, confirmando monitoramento ativo.

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
PASSOU — latest_seen está dentro das últimas 24 horas	Telemetria está coletando dados ativamente
AVISO — latest_seen é anterior a 24 horas	O tráfego pode ter parado ou o processamento do CSD está atrasado

---

Painel de Toda a Pilha

Execute um único comando que verifica todos os indicadores críticos de integridade em cada camada e produz uma tabela de resumo:

echo "=== CSD Verification Dashboard ==="
echo ""

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

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

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

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

# Layer 6: JS config
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')

# Layer 7: Traffic (last 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" "CHECK" "STATUS"
printf "%-28s %s\n" "----------------------------" "----------------------------"
printf "%-28s %s\n" "[DNS] A Record" "${DNS_A:-NOT_FOUND}"
printf "%-28s %s\n" "[DNS] ACME CNAME" "${DNS_ACME:-NOT_FOUND}"
printf "%-28s %s\n" "[TLS] Certificate" "$CERT_STATE"
printf "%-28s %s\n" "[LB] State" "$LB_STATE"
printf "%-28s %s\n" "[LB] Domains" "$DOMAINS"
printf "%-28s %s\n" "[LB] Route Pool" "$ROUTE_POOL"
printf "%-28s %s\n" "[LB] CSD on LB" "$CSD_ON_LB"
printf "%-28s %s\n" "[CSD] Configured (tenant)" "$CSD_CONFIGURED"
printf "%-28s %s\n" "[CSD] Enabled" "$CSD_ENABLED"
printf "%-28s %s\n" "[CSD] JS Script Tag" "$JS_TAG"
printf "%-28s %s\n" "[Traffic] Requests (24h)" "$TRAFFIC"

---

Referência de Campos do Log de Acesso

Cuidado

Cada entrada no array .logs[] é uma string JSON, não um objeto analisado. Você deve usar fromjson no jq antes de acessar os campos (ex.: .logs[] | fromjson | .method).

Campo	Tipo	Descrição
@timestamp	string	Timestamp da requisição (ISO 8601). Observe o prefixo @ — acesse com .["@timestamp"] no jq
method	string	Método HTTP (GET, POST, etc.)
req_path	string	Caminho da URI da requisição
rsp_code	string	Código de status HTTP da resposta como string (ex.: "200", "404")
rsp_code_class	string	Classe do código de status (2xx, 3xx, 4xx, 5xx ou downstream_remote_disconnect)
src_ip	string	Endereço IP de origem do cliente
dst_ip	string	Endereço IP de destino (VIP)
domain	string	Valor do cabeçalho Host da requisição
user_agent	string	String User-Agent do cliente
rsp_size	string	Tamanho do corpo da resposta em bytes (retornado como string)
req_size	string	Tamanho do corpo da requisição em bytes (retornado como string)
duration_with_data_tx_delay	string	Duração total da requisição em segundos (retornado como string, ex.: "0.024219")
csd_js_injection	string	"true" quando o JavaScript do CSD foi injetado (presente somente quando ativo)

Referência de Campos da Telemetria do CSD

Campo	Endpoint	Descrição
isConfigured	status	CSD habilitado no nível do tenant
isEnabled	status	CSD ativo para este namespace
scripts[]	scripts	Array de objetos de script detectados
.script_name	scripts	URL completa do arquivo JavaScript
.risk_level	scripts	Nível de risco (No Risk, Low Risk, High Risk)
.status	scripts	AN (Action Needed) ou NA (No Action Needed)
.form_fields_read	scripts	Número de campos de formulário que o script lê
.affected_users_count	scripts	Número de usuários/sessões únicos afetados
domain_summary	detected_domains	Contagens por status: .actionNeededCount.count, .mitigatedDomains.count, .allowedDomains.count, .totalDomains.count (cada um possui .count e .lastUpdated)
domains_list[]	detected_domains	Array de objetos de domínio detectados com .domain, .status, .category, .firstSeenDate, .latestSeenDate (segundos epoch como strings)
form_fields[]	formFields	Array de objetos de campo de formulário detectados
.analysis	formFields	Classificação de sensibilidade (Sensitive, Not Sensitive)

Solução de Problemas

Zero Logs de Acesso

Se TV-1 retornar 0:

1. Verifique a resolução DNS — confirme que o domínio resolve para o VIP do LB:

   dig +short xF5XC_DOMAINNAMEx A

   Se vazio, o DNS não está configurado. Consulte Automação via API — Passo 4.

2. Verifique o estado do LB — o balanceador de carga deve estar em 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. Envie uma requisição de teste — gere tráfego para confirmar a conectividade de ponta a ponta:

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

   Procure por uma resposta HTTP bem-sucedida. Utilize https:// somente se o certificado do LB HTTPS for válido.

Registros Gerenciados Desabilitados na Zona DNS

Se DNS-4 retornar false, a criação automática de registros está desabilitada mesmo que o F5 XC seja o provedor DNS autoritativo. Esta é uma configuração incorreta comum que faz com que tanto o registro A quanto o CNAME ACME estejam ausentes, impedindo o balanceador de carga de atingir VIRTUAL_HOST_READY e o certificado de ser emitido.

Para habilitar os registros gerenciados, atualize a configuração da zona DNS para definir allow_http_lb_managed_records: true. Consulte Automação via API — Opção A: DNS Gerenciado pelo F5 XC para a chamada de API.

LB Preso em VIRTUAL_HOST_PENDING_A_RECORD

O balanceador de carga está aguardando um registro A do DNS apontando para seu VIP. Consulte LB Preso em VIRTUAL_HOST_PENDING_A_RECORD para etapas detalhadas de resolução.

Certificado Preso em PreDomainChallengePending

O certificado TLS automático requer um registro de desafio ACME. O método depende do seu provedor DNS:

DNS Gerenciado pelo F5 XC: Habilite allow_http_lb_managed_records na zona DNS (DNS-4). A plataforma cria automaticamente um registro de desafio ACME baseado em TXT no grupo de conjuntos de registros x-ves-io-managed. Se o certificado permanecer preso após habilitar os registros gerenciados, exclua e recrie o balanceador de carga para acionar uma nova solicitação de certificado.

DNS Externo: Crie um registro CNAME no seu provedor DNS:

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

Verifique se o registro existe:

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

Se ambos estiverem vazios, o registro ACME não está configurado. O provisionamento do certificado leva 5–10 minutos após o registro estar configurado. Verifique o status de erro do LB para erros específicos de validação ACME:

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

O CSD deve ser habilitado no nível do tenant por um administrador do F5 XC. Esta é uma configuração que abrange todo o tenant e não pode ser configurada via API do namespace. Contate seu administrador para habilitar o Client-Side Defense.

Array de Scripts Vazio

Se TEL-1 retornar um array vazio:

1. Verifique o domínio protegido — o CSD monitora scripts apenas em domínios 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 a injeção de JS — confirme que a tag de script do CSD está sendo injetada nas páginas:

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

   Se não houver correspondência, o JavaScript do CSD não está sendo injetado. Verifique se o LB tem client_side_defense habilitado.

3. Aguarde o tempo de processamento — após habilitar o CSD pela primeira vez ou registrar um novo domínio protegido, a detecção de scripts pode levar de 5 a 15 minutos. Gere tráfego para o site e aguarde antes de verificar novamente.

Referência Rápida

Predefinições de Intervalo de Tempo

Período	Deslocamento 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 dias	$(( $(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 dias	$(( $(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

Resumo das Camadas de Verificação

Camada	Testes	O que cobre
1. Resolução DNS	DNS-1 a DNS-4	Registro A, CNAME ACME, autoridade dos servidores de nomes, registros gerenciados
2. Certificado TLS	TLS-1 a TLS-4	Estado do cert, detalhes do cert, handshake ao vivo, destino ACME
3. Balanceador de Carga HTTP	LB-1 a LB-6	Estado, domínios, flag CSD, pools de rota, implantação, resumo
4. Pool de Origem	OP-1 a OP-4	Configuração, modo TLS, associação de HC, conectividade com a origem
5. Verificação de Integridade	HC-1 a HC-2	Configuração de HC, listar todos os HCs
6. Configuração do CSD	CSD-1 a CSD-5	Status do tenant, tag JS, domínios protegidos, injeção ao vivo
7. Verificação de Tráfego	TV-1 a TV-5	Contagem de requisições, códigos de status, amostras, JS nos logs, teste E2E
8. Telemetria do CSD	TEL-1 a TEL-8	Scripts, domínios, política, campos de formulário, análise detalhada, usuários, risco, atualidade

Resumo dos Endpoints

Diagnóstico	Endpoint	Método	Formato de Tempo
Contagem de requisições	/api/data/namespaces/\{ns\}/access_logs/aggregation	POST	ISO 8601
Códigos de status	/api/data/namespaces/\{ns\}/access_logs	POST	ISO 8601
Requisições recentes	/api/data/namespaces/\{ns\}/access_logs	POST	ISO 8601
Estado do LB	/api/config/namespaces/\{ns\}/http_loadbalancers/\{name\}	GET	Nenhum
Pool de origem	/api/config/namespaces/\{ns\}/origin_pools/\{name\}	GET	Nenhum
Verificação de integridade	/api/config/namespaces/\{ns\}/healthchecks/\{name\}	GET	Nenhum
Zona DNS	/api/config/dns/namespaces/system/dns_zones/\{zone\}	GET	Nenhum
Status do CSD	/api/shape/csd/namespaces/\{ns\}/status	GET	Nenhum
Configuração de JS	/api/shape/csd/namespaces/\{ns\}/js_configuration	GET	Nenhum
Domínios protegidos	/api/shape/csd/namespaces/\{ns\}/protected_domains	GET	Nenhum
Lista de scripts	/api/shape/csd/namespaces/\{ns\}/scripts	POST	Segundos epoch
Domínios detectados	/api/shape/csd/namespaces/\{ns\}/detected_domains	GET	Nenhum
Campos de formulário	/api/shape/csd/namespaces/\{ns\}/formFields	GET	Segundos epoch (parâmetros de consulta)
Detalhes do script	/api/shape/csd/namespaces/\{ns\}/scripts/\{id\}/dashboard	GET	Nenhum
Comportamentos do script	/api/shape/csd/namespaces/\{ns\}/scripts/\{id\}/behaviors	GET	Nenhum
Rede do script	/api/shape/csd/namespaces/\{ns\}/scripts/\{id\}/networkInteractions	GET	Nenhum
Usuários afetados	/api/shape/csd/namespaces/\{ns\}/scripts/\{id\}/affectedUsers	POST	Segundos epoch