cURL - Receitas e medição de Tempo de Carregamento de Páginas

Guia completo com curl, jq, bash scripts e interpretação de resultados.

PROPÓSITO

Separar onde o tempo de uma requisição é gasto — DNS, conexão, TLS, primeiro byte e transferência — em vez de tratar lentidão como um número único.

Quando usar: Ao investigar uma página lenta, comparar antes e depois de uma mudança, ou validar a resposta de um serviço a partir de fora.

Pré-requisitos: curl e jq instalados.

1. Variáveis do cURL

Todas as variáveis abaixo são passadas via -w (write-out). Os valores são acumulados desde o início da requisição — não são incrementais.

Variável	O que mede	Unidade
%	Código de retorno HTTP	—
%	Resolução DNS	segundos
%	TCP handshake completo	segundos (acumulado)
%	TLS/SSL handshake completo	segundos (acumulado)
%	Pronto para enviar a requisição	segundos (acumulado)
%	TTFB — primeiro byte recebido	segundos (acumulado)
%	Tempo total da requisição	segundos (acumulado)
%	Tamanho do corpo da resposta	bytes
%	Velocidade de download	bytes/s
%	IP do servidor	—
%	Número de redirecionamentos	—

Atenção: como os valores são acumulados, para calcular o tempo isolado de cada fase:

Tempo TCP = time_connect - time_namelookup
Tempo TLS = time_appconnect - time_connect
Tempo servidor = time_starttransfer - time_pretransfer
Tempo transferência = time_total - time_starttransfer

2. Comandos Básicos

Verificar apenas o código HTTP

bash

curl -o /dev/null -s -w "%{http_code}\n" "https://exemplo.com"

Medição completa — saída legível

bash

curl -o /dev/null -s -w \
  "Código HTTP:    %{http_code}\n\
DNS lookup:     %{time_namelookup}s\n\
Conexão TCP:    %{time_connect}s\n\
TLS handshake:  %{time_appconnect}s\n\
TTFB:           %{time_starttransfer}s\n\
Tempo total:    %{time_total}s\n\
Tamanho:        %{size_download} bytes\n\
IP remoto:      %{remote_ip}\n" \
  "https://exemplo.com"

Medição completa — saída em JSON (para parsing com jq)

bash

curl -o /dev/null -s -w \
  '{"http_code":%{http_code},"dns":%{time_namelookup},"tcp":%{time_connect},"tls":%{time_appconnect},"ttfb":%{time_starttransfer},"total":%{time_total},"size":%{size_download},"ip":"%{remote_ip}"}' \
  "https://exemplo.com"

Seguir redirecionamentos automaticamente

bash

curl -o /dev/null -s -L -w \
  "HTTP: %{http_code} | Redirects: %{num_redirects} | Total: %{time_total}s\n" \
  "https://exemplo.com"

Forçar HTTP/2

bash

curl -o /dev/null -s --http2 -w \
  "HTTP: %{http_code} | Total: %{time_total}s\n" \
  "https://exemplo.com"

Ignorar verificação SSL (ambientes internos)

bash

curl -o /dev/null -s -k -w \
  "HTTP: %{http_code} | TTFB: %{time_starttransfer}s | Total: %{time_total}s\n" \
  "https://servico-interno"

3. Scripts de Múltiplas Iterações

Script básico — N repetições com média

bash

#!/bin/bash
# usage: ./medir.sh https://exemplo.com 5

URL="${1:-https://exemplo.com}"
REPS="${2:-5}"

echo "URL: $URL"
echo "Repetições: $REPS"
echo "---"

total_dns=0
total_ttfb=0
total_time=0

for i in $(seq 1 "$REPS"); do
  result=$(curl -o /dev/null -s -w "%{http_code} %{time_namelookup} %{time_starttransfer} %{time_total}" "$URL")
  
  http=$(echo "$result" | awk '{print $1}')
  dns=$(echo "$result" | awk '{print $2}')
  ttfb=$(echo "$result" | awk '{print $3}')
  total=$(echo "$result" | awk '{print $4}')

  echo "[$i] HTTP: $http | DNS: ${dns}s | TTFB: ${ttfb}s | Total: ${total}s"

  total_dns=$(echo "$total_dns + $dns" | bc)
  total_ttfb=$(echo "$total_ttfb + $ttfb" | bc)
  total_time=$(echo "$total_time + $total" | bc)

  sleep 1
done

echo "---"
echo "Média DNS:   $(echo "scale=4; $total_dns / $REPS" | bc)s"
echo "Média TTFB:  $(echo "scale=4; $total_ttfb / $REPS" | bc)s"
echo "Média Total: $(echo "scale=4; $total_time / $REPS" | bc)s"

Script com saída JSON por iteração

bash

#!/bin/bash
URL="${1:-https://exemplo.com}"
REPS="${2:-3}"

echo "["
for i in $(seq 1 "$REPS"); do
  json=$(curl -o /dev/null -s -w \
    '{"rodada":'$i',"http_code":%{http_code},"dns":%{time_namelookup},"ttfb":%{time_starttransfer},"total":%{time_total}}' \
    "$URL")
  
  # Adiciona vírgula entre itens, exceto no último
  if [ "$i" -lt "$REPS" ]; then
    echo "  $json,"
  else
    echo "  $json"
  fi
  sleep 1
done
echo "]"

4. Parsing com jq

Extrair campos específicos

bash

curl -o /dev/null -s -w \
  '{"http_code":%{http_code},"dns":%{time_namelookup},"ttfb":%{time_starttransfer},"total":%{time_total}}' \
  "https://exemplo.com" | jq '{status: .http_code, ttfb_ms: (.ttfb * 1000 | round), total_ms: (.total * 1000 | round)}'

Calcular fases isoladas (não acumuladas)

bash

curl -o /dev/null -s -w \
  '{"dns":%{time_namelookup},"tcp":%{time_connect},"tls":%{time_appconnect},"pretransfer":%{time_pretransfer},"ttfb":%{time_starttransfer},"total":%{time_total}}' \
  "https://exemplo.com" | jq '{
    dns_ms:      (.dns * 1000 | round),
    tcp_ms:      ((.tcp - .dns) * 1000 | round),
    tls_ms:      ((.tls - .tcp) * 1000 | round),
    server_ms:   ((.ttfb - .pretransfer) * 1000 | round),
    transfer_ms: ((.total - .ttfb) * 1000 | round),
    total_ms:    (.total * 1000 | round)
  }'

Calcular média de múltiplas rodadas com jq

bash

# Coletar N resultados em JSON
for i in $(seq 1 5); do
  curl -o /dev/null -s -w \
    '{"dns":%{time_namelookup},"ttfb":%{time_starttransfer},"total":%{time_total}}\n' \
    "https://exemplo.com"
  sleep 1
done | jq -s '{
  amostras: length,
  media_dns_ms:   (map(.dns) | add / length * 1000 | round),
  media_ttfb_ms:  (map(.ttfb) | add / length * 1000 | round),
  media_total_ms: (map(.total) | add / length * 1000 | round),
  min_total_ms:   (map(.total) | min * 1000 | round),
  max_total_ms:   (map(.total) | max * 1000 | round)
}'

Verificar se o HTTP code é 200 e alertar

bash

resultado=$(curl -o /dev/null -s -w \
  '{"http_code":%{http_code},"total":%{time_total}}' \
  "https://exemplo.com")

http=$(echo "$resultado" | jq '.http_code')
total=$(echo "$resultado" | jq '.total * 1000 | round')

if [ "$http" -eq 200 ]; then
  echo "✓ OK — HTTP $http | Total: ${total}ms"
else
  echo "✗ ERRO — HTTP $http | Total: ${total}ms"
  exit 1
fi

Filtrar respostas lentas (acima de threshold)

bash

THRESHOLD_MS=500

for i in $(seq 1 10); do
  curl -o /dev/null -s -w \
    '{"rodada":'$i',"http_code":%{http_code},"total":%{time_total}}\n' \
    "https://exemplo.com"
  sleep 1
done | jq --argjson t "$THRESHOLD_MS" \
  '[.[] | select(.total * 1000 > $t) | {rodada, http_code, total_ms: (.total * 1000 | round)}]'

5. Requisição dentro de Container / Pod

Docker

bash

docker exec -it <container_name> \
  curl -o /dev/null -s -w \
  "HTTP: %{http_code} | DNS: %{time_namelookup}s | TTFB: %{time_starttransfer}s | Total: %{time_total}s\n" \
  "https://exemplo.com"

Kubernetes — pod existente

bash

kubectl exec -it <POD_NAME> -n <NAMESPACE> -- \
  curl -o /dev/null -s -w \
  "HTTP: %{http_code} | DNS: %{time_namelookup}s | TTFB: %{time_starttransfer}s | Total: %{time_total}s\n" \
  "https://exemplo.com"

Kubernetes — pod temporário (sem curl no container)

bash

kubectl run curl-test --image=curlimages/curl --rm -it --restart=Never -- \
  curl -o /dev/null -s -w \
  "HTTP: %{http_code} | DNS: %{time_namelookup}s | TTFB: %{time_starttransfer}s | Total: %{time_total}s\n" \
  "https://exemplo.com"

Comparar externo vs interno (latência de rede)

bash

# De fora do cluster
echo "=== EXTERNO ==="
curl -o /dev/null -s -w "Total: %{time_total}s\n" "https://minha-api.com/health"

# De dentro do pod
echo "=== INTERNO ==="
kubectl exec -it <POD> -n <NS> -- \
  curl -o /dev/null -s -w "Total: %{time_total}s\n" "http://minha-api.svc.cluster.local/health"

6. Benchmarks de Referência

Métrica	✅ Bom	⚠️ Atenção	❌ Crítico
DNS lookup	< 50ms	50–200ms	> 200ms
Conexão TCP	< 100ms	100–300ms	> 300ms
TLS handshake	< 150ms	150–400ms	> 400ms
TTFB	< 200ms	200–500ms	> 500ms
Tempo total	< 500ms	500ms–2s	> 2s
HTTP Status	2xx	3xx	4xx / 5xx / 0

HTTP code 000 significa falha de conexão antes mesmo de chegar ao servidor (DNS inválido, timeout, porta fechada).

7. Diagnóstico por Métrica

DNS alto → problema no resolvedor

bash

# Testar resolução isolada
dig +stats exemplo.com

# Forçar DNS alternativo no curl
curl --dns-servers 8.8.8.8 -o /dev/null -s -w \
  "DNS: %{time_namelookup}s | Total: %{time_total}s\n" \
  "https://exemplo.com"

TCP alto → latência de rede ou firewall

bash

# Testar conectividade TCP pura (sem HTTP)
nc -zv exemplo.com 443

# Traceroute para encontrar gargalo
traceroute exemplo.com

TLS alto → negociação de certificado lenta

bash

# Ver detalhes do handshake TLS
curl -v --tls-max 1.2 "https://exemplo.com" 2>&1 | grep -E "SSL|TLS|cipher|certificate"

# Forçar TLS 1.3
curl -o /dev/null -s --tlsv1.3 -w "TLS: %{time_appconnect}s\n" "https://exemplo.com"

TTFB alto → lentidão no servidor / backend

bash

# Medir apenas TTFB em loop para confirmar consistência
for i in $(seq 1 5); do
  curl -o /dev/null -s -w "TTFB: %{time_starttransfer}s\n" "https://exemplo.com"
  sleep 2
done

Total alto mas TTFB ok → transferência de payload grande

bash

# Ver tamanho e velocidade de download
curl -o /dev/null -s -w \
  "Tamanho: %{size_download} bytes | Velocidade: %{speed_download} bytes/s | Total: %{time_total}s\n" \
  "https://exemplo.com"

8. Exemplos Completos

Health check com saída estruturada

bash

#!/bin/bash
# health-check.sh — verifica URL e emite JSON com status

URL="${1:?Informe a URL como argumento}"

resultado=$(curl -o /dev/null -s -w \
  '{"url":"%{url_effective}","http_code":%{http_code},"dns":%{time_namelookup},"tcp":%{time_connect},"tls":%{time_appconnect},"ttfb":%{time_starttransfer},"total":%{time_total},"bytes":%{size_download},"ip":"%{remote_ip}"}' \
  -L "$URL")

echo "$resultado" | jq '{
  url,
  ip,
  http_code,
  status: (if .http_code == 200 then "OK" elif .http_code == 0 then "FALHA_CONEXAO" else "ERRO" end),
  fases: {
    dns_ms:      (.dns * 1000 | round),
    tcp_ms:      ((.tcp - .dns) * 1000 | round),
    tls_ms:      ((.tls - .tcp) * 1000 | round),
    server_ms:   ((.ttfb - .tls) * 1000 | round),
    transfer_ms: ((.total - .ttfb) * 1000 | round)
  },
  total_ms: (.total * 1000 | round),
  bytes
}'

Monitoramento contínuo com alerta

bash

#!/bin/bash
# monitor.sh — roda em loop e alerta quando lento ou com erro

URL="${1:?Informe a URL}"
THRESHOLD="${2:-1000}"   # ms
INTERVALO="${3:-30}"     # segundos entre testes

echo "Monitorando: $URL"
echo "Threshold: ${THRESHOLD}ms | Intervalo: ${INTERVALO}s"
echo "---"

while true; do
  ts=$(date '+%Y-%m-%d %H:%M:%S')
  resultado=$(curl -o /dev/null -s -w "%{http_code} %{time_total}" "$URL")
  
  http=$(echo "$resultado" | awk '{print $1}')
  total_s=$(echo "$resultado" | awk '{print $2}')
  total_ms=$(echo "$total_s * 1000 / 1" | bc)

  if [ "$http" -ne 200 ]; then
    echo "[$ts] ❌ ERRO HTTP $http | ${total_ms}ms"
  elif [ "$total_ms" -gt "$THRESHOLD" ]; then
    echo "[$ts] ⚠️  LENTO HTTP $http | ${total_ms}ms (threshold: ${THRESHOLD}ms)"
  else
    echo "[$ts] ✅ OK HTTP $http | ${total_ms}ms"
  fi

  sleep "$INTERVALO"
done

Testar múltiplas URLs de uma lista

bash

#!/bin/bash
# medir-lista.sh — lê URLs de um arquivo e mede cada uma

ARQUIVO="${1:-urls.txt}"

echo "URL,HTTP,DNS_ms,TTFB_ms,Total_ms,Status"

while IFS= read -r url; do
  [ -z "$url" ] && continue
  [ "${url:0:1}" = "#" ] && continue  # ignora comentários

  resultado=$(curl -o /dev/null -s -w \
    "%{http_code} %{time_namelookup} %{time_starttransfer} %{time_total}" \
    "$url")

  http=$(echo "$resultado" | awk '{print $1}')
  dns_ms=$(echo "$(echo "$resultado" | awk '{print $2}') * 1000 / 1" | bc)
  ttfb_ms=$(echo "$(echo "$resultado" | awk '{print $3}') * 1000 / 1" | bc)
  total_ms=$(echo "$(echo "$resultado" | awk '{print $4}') * 1000 / 1" | bc)

  if [ "$http" -eq 200 ] && [ "$total_ms" -lt 500 ]; then
    status="OK"
  elif [ "$http" -eq 200 ]; then
    status="LENTO"
  else
    status="ERRO"
  fi

  echo "$url,$http,${dns_ms},${ttfb_ms},${total_ms},$status"
done < "$ARQUIVO"

Exemplo de urls.txt:

text

# APIs de produção
https://api.meusite.com/health
https://api.meusite.com/v2/status
https://cdn.meusite.com/assets/main.js

9. Receitas cURL de Uso Geral

9.1 Cabeçalhos e Inspeção de Resposta

bash

# Ver apenas os cabeçalhos de resposta (HEAD request)
curl -I "https://exemplo.com"

# Ver cabeçalhos de resposta + corpo na mesma saída
curl -i "https://exemplo.com"

# Ver cabeçalhos de resposta sem corpo (descarta body em /dev/null)
curl -D - -o /dev/null -s "https://exemplo.com"

# Ver TODO o fluxo: cabeçalhos enviados e recebidos
curl -v "https://exemplo.com" 2>&1

# Filtrar cabeçalhos específicos da resposta
curl -sI "https://exemplo.com" | grep -i "content-type\|cache-control\|x-cache\|server"

# Ver cabeçalhos de resposta em formato JSON limpo
# Usa capture() do jq para evitar problemas com \r, números e valores com ": " no meio
curl -sI "https://exemplo.com" | tr -d '\r' | grep ": " | \
  jq -Rn '[inputs | capture("(?<k>[^:]+): (?<v>.+)") | {(.k): .v}] | add'

9.2 Download de Arquivos

bash

# Baixar arquivo com nome customizado
curl -o meu-arquivo.zip "https://exemplo.com/arquivo.zip"

# Baixar mantendo o nome original da URL
curl -O "https://exemplo.com/arquivo.zip"

# Baixar com barra de progresso
curl -# -o arquivo.zip "https://exemplo.com/arquivo.zip"

# Baixar múltiplos arquivos de uma vez
curl -O "https://exemplo.com/foto1.jpg" \
     -O "https://exemplo.com/foto2.jpg" \
     -O "https://exemplo.com/foto3.jpg"

# Retomar download interrompido
curl -C - -O "https://exemplo.com/arquivo-grande.zip"

# Baixar faixa de bytes específica (partial content)
curl -r 0-1023 -o primeiros-1kb.bin "https://exemplo.com/arquivo.zip"

# Baixar e descompactar gzip em pipeline
curl -s "https://exemplo.com/dados.json.gz" | gunzip | jq '.'

# Baixar com limite de velocidade (ex: 500KB/s)
curl --limit-rate 500K -O "https://exemplo.com/arquivo.zip"

# Baixar somente se o arquivo remoto for mais novo que o local
curl -z arquivo.zip -O "https://exemplo.com/arquivo.zip"

9.3 Envio de Dados (POST / PUT / PATCH)

bash

# POST com JSON
curl -s -X POST "https://api.exemplo.com/usuarios" \
  -H "Content-Type: application/json" \
  -d '{"nome": "João", "email": "[email protected]"}'

# POST com JSON lido de arquivo
curl -s -X POST "https://api.exemplo.com/usuarios" \
  -H "Content-Type: application/json" \
  -d @payload.json

# POST com form-data (simulando formulário HTML)
# Content-Type padrão do -d é application/x-www-form-urlencoded
curl -s -X POST "https://exemplo.com/login" \
  -d "usuario=admin&senha=1234"

# PUT — substituição completa de recurso
curl -s -X PUT "https://api.exemplo.com/usuarios/42" \
  -H "Content-Type: application/json" \
  -d '{"nome": "João Silva", "email": "[email protected]"}'

# PATCH — atualização parcial
curl -s -X PATCH "https://api.exemplo.com/usuarios/42" \
  -H "Content-Type: application/json" \
  -d '{"email": "[email protected]"}'

# DELETE
curl -s -X DELETE "https://api.exemplo.com/usuarios/42"

# Upload de arquivo (multipart/form-data)
curl -s -X POST "https://api.exemplo.com/upload" \
  -F "arquivo=@/caminho/para/foto.jpg" \
  -F "descricao=Foto de perfil"

# Upload de arquivo binário raw
curl -s -X PUT "https://api.exemplo.com/imagem/42" \
  -H "Content-Type: image/jpeg" \
  --data-binary @foto.jpg

9.4 Autenticação

bash

# Basic Auth
curl -s -u "usuario:senha" "https://api.exemplo.com/dados"

# Bearer Token (JWT)
curl -s -H "Authorization: Bearer eyJhbGciOi..." "https://api.exemplo.com/dados"

# API Key via header
curl -s -H "X-API-Key: minha-chave-aqui" "https://api.exemplo.com/dados"

# API Key via query string
curl -s "https://api.exemplo.com/dados?api_key=minha-chave-aqui"

# OAuth2 — obter token e usar em seguida
TOKEN=$(curl -s -X POST "https://auth.exemplo.com/token" \
  -d "grant_type=client_credentials&client_id=ID&client_secret=SECRET" \
  | jq -r '.access_token')

curl -s -H "Authorization: Bearer $TOKEN" "https://api.exemplo.com/dados"

# Autenticação com certificado mTLS
curl -s \
  --cert cliente.crt \
  --key cliente.key \
  --cacert ca.crt \
  "https://api-interna.exemplo.com/dados"

9.5 Cookies e Sessões

bash

# Salvar cookies em arquivo
curl -s -c cookies.txt "https://exemplo.com/login" \
  -d "usuario=admin&senha=1234"

# Usar cookies salvos em requisição seguinte
curl -s -b cookies.txt "https://exemplo.com/painel"

# Salvar e enviar cookies no mesmo comando (sessão persistente)
curl -s -c cookies.txt -b cookies.txt "https://exemplo.com/pagina"

# Enviar cookie manualmente
curl -s -H "Cookie: sessao=abc123; preferencia=dark" "https://exemplo.com"

# Ver cookies que o servidor está definindo
curl -sI "https://exemplo.com" | grep -i "set-cookie"

9.6 Proxies e Tunelamento

bash

# Usar proxy HTTP
curl -s -x "http://proxy.empresa.com:3128" "https://exemplo.com"

# Proxy com autenticação
curl -s -x "http://usuario:[email protected]:3128" "https://exemplo.com"

# Bypass de proxy para hosts específicos
curl -s --noproxy "interno.empresa.com,*.local" \
  -x "http://proxy:3128" "https://externo.com"

# Usar SOCKS5
curl -s --socks5 "127.0.0.1:1080" "https://exemplo.com"

# Tunelar via SSH (combinar com SSH local port forward)
# Primeiro: ssh -D 1080 usuario@bastion
curl -s --socks5 "127.0.0.1:1080" "https://servico-interno.com"

9.7 TLS / SSL

bash

# Ver detalhes do certificado SSL
curl -vI "https://exemplo.com" 2>&1 | grep -A 20 "Server certificate"

# Verificar data de expiração do certificado
curl -vI "https://exemplo.com" 2>&1 | grep "expire date"

# Testar com versão específica de TLS
curl -s --tlsv1.2 --tls-max 1.2 -o /dev/null -w "%{http_code}\n" "https://exemplo.com"
curl -s --tlsv1.3 -o /dev/null -w "%{http_code}\n" "https://exemplo.com"

# Ignorar erros de certificado (ambientes de dev/staging)
curl -sk "https://staging.interno.com"

# Testar com CA bundle customizada
curl -s --cacert /caminho/para/ca-bundle.crt "https://servico-interno.com"

# Listar cifras suportadas pelo servidor
curl -v --ciphers 'ALL' "https://exemplo.com" 2>&1 | grep "SSL connection"

9.8 Redirecionamentos e DNS

bash

# Seguir redirecionamentos automaticamente (até 30 saltos)
curl -sL "https://encurtador.com/xYz"

# Limitar número de redirecionamentos
curl -sL --max-redirs 3 "https://exemplo.com"

# Ver todos os redirecionamentos sem seguir
curl -sI "https://exemplo.com" | grep -i "location"

# Forçar resolução de DNS (sobrescrever /etc/hosts)
curl -s --resolve "exemplo.com:443:192.168.1.10" "https://exemplo.com"

# Testar com DNS específico
curl -s --dns-servers "1.1.1.1" "https://exemplo.com"

# Ver qual IP foi usado na conexão
curl -s -w "IP: %{remote_ip}\n" -o /dev/null "https://exemplo.com"

9.9 Debugging e Verbose

O -v imprime todo o fluxo da requisição. Cada linha tem um prefixo que indica a direção:

text

> GET / HTTP/1.1          ← você → servidor  (cabeçalhos enviados)
> Host: exemplo.com
> User-Agent: curl/7.88
>
< HTTP/1.1 200 OK         ← servidor → você  (cabeçalhos recebidos)
< content-type: text/html
< server: nginx
<
* Connection #0 left intact   ← mensagem interna do curl (TLS, DNS, redirect...)

Prefixo	Significa
>	Cabeçalhos que você enviou ao servidor
<	Cabeçalhos que o servidor retornou
*	Metadados internos do curl (TLS, DNS, conexão, redirecionamentos)

Atenção: o -v escreve em stderr, não em stdout. Por isso é necessário 2>&1 para capturar com grep ou redirecionar para arquivo.

bash

# Verbose completo (cabeçalhos enviados e recebidos, TLS, etc.)
curl -v "https://exemplo.com"

# Verbose completo redirecionando stderr para arquivo
curl -v "https://exemplo.com" 2> debug.log

# Trace completo em hex (nível mais baixo)
curl --trace trace.txt "https://exemplo.com"
curl --trace-ascii trace.txt "https://exemplo.com"  # sem hex, só ASCII

# Só o que você enviou (request headers)
curl -sv "https://exemplo.com" 2>&1 | grep "^>"

# Só o que o servidor retornou (response headers)
curl -sv "https://exemplo.com" 2>&1 | grep "^<"

# Só os metadados internos do curl (TLS, DNS, redirects...)
curl -sv "https://exemplo.com" 2>&1 | grep "^\*"

# Medir tempo sem nenhuma saída de corpo
curl -o /dev/null -s -w \
  "DNS: %{time_namelookup}s | TCP: %{time_connect}s | TTFB: %{time_starttransfer}s | Total: %{time_total}s\n" \
  "https://exemplo.com"

# Simular user-agent de navegador
curl -s -A "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36" "https://exemplo.com"

# Enviar cabeçalhos customizados
curl -s \
  -H "X-Request-ID: abc-123" \
  -H "Accept-Language: pt-BR" \
  -H "Cache-Control: no-cache" \
  "https://exemplo.com"

9.10 Flags Essenciais — Resumo Rápido

Flag	Descrição
-s	Silencioso — sem barra de progresso nem erros
-S	Mostra erros mesmo com -s (use -sS juntos)
-o arquivo	Salva corpo em arquivo
-O	Salva com nome do arquivo remoto
-D -	Imprime cabeçalhos de resposta no stdout
-I	HEAD request (só cabeçalhos)
-L	Segue redirecionamentos
-v	Verbose — mostra todo o fluxo
-k	Ignora erros de SSL
-u user:pass	Basic auth
-H "Header: val"	Cabeçalho customizado
-d "dados"	Corpo do POST
-F "campo=@arq"	Upload multipart
-X MÉTODO	Define método HTTP (GET, POST, PUT...)
-C -	Retoma download interrompido
-#	Barra de progresso simples
--limit-rate 500K	Limita velocidade de download
--max-time 10	Timeout total em segundos
--connect-timeout 5	Timeout só da conexão TCP
--retry 3	Tenta novamente N vezes em falha
--retry-delay 2	Espera N segundos entre tentativas
-w "formato"	Saída customizada pós-requisição

Documentação gerada para uso interno — medição de performance via cURL.

cURL - Receitas e medição de Tempo de Carregamento de Páginas ​

1. Variáveis do cURL ​

2. Comandos Básicos ​

Verificar apenas o código HTTP ​

Medição completa — saída legível ​

Medição completa — saída em JSON (para parsing com jq) ​

Seguir redirecionamentos automaticamente ​

Forçar HTTP/2 ​

Ignorar verificação SSL (ambientes internos) ​

3. Scripts de Múltiplas Iterações ​

Script básico — N repetições com média ​

Script com saída JSON por iteração ​

4. Parsing com jq ​

Extrair campos específicos ​

Calcular fases isoladas (não acumuladas) ​

Calcular média de múltiplas rodadas com jq ​

Verificar se o HTTP code é 200 e alertar ​

Filtrar respostas lentas (acima de threshold) ​

5. Requisição dentro de Container / Pod ​

Docker ​

Kubernetes — pod existente ​

Kubernetes — pod temporário (sem curl no container) ​

Comparar externo vs interno (latência de rede) ​

6. Benchmarks de Referência ​

7. Diagnóstico por Métrica ​

DNS alto → problema no resolvedor ​

TCP alto → latência de rede ou firewall ​

TLS alto → negociação de certificado lenta ​

TTFB alto → lentidão no servidor / backend ​

Total alto mas TTFB ok → transferência de payload grande ​

8. Exemplos Completos ​

Health check com saída estruturada ​

Monitoramento contínuo com alerta ​

Testar múltiplas URLs de uma lista ​

9. Receitas cURL de Uso Geral ​

9.1 Cabeçalhos e Inspeção de Resposta ​

9.2 Download de Arquivos ​

9.3 Envio de Dados (POST / PUT / PATCH) ​

9.4 Autenticação ​

9.5 Cookies e Sessões ​

9.6 Proxies e Tunelamento ​

9.7 TLS / SSL ​

9.8 Redirecionamentos e DNS ​

9.9 Debugging e Verbose ​

9.10 Flags Essenciais — Resumo Rápido ​

cURL - Receitas e medição de Tempo de Carregamento de Páginas

1. Variáveis do cURL

2. Comandos Básicos

Verificar apenas o código HTTP

Medição completa — saída legível

Medição completa — saída em JSON (para parsing com jq)

Seguir redirecionamentos automaticamente

Forçar HTTP/2

Ignorar verificação SSL (ambientes internos)

3. Scripts de Múltiplas Iterações

Script básico — N repetições com média

Script com saída JSON por iteração

4. Parsing com jq

Extrair campos específicos

Calcular fases isoladas (não acumuladas)

Calcular média de múltiplas rodadas com jq

Verificar se o HTTP code é 200 e alertar

Filtrar respostas lentas (acima de threshold)

5. Requisição dentro de Container / Pod

Docker

Kubernetes — pod existente

Kubernetes — pod temporário (sem curl no container)

Comparar externo vs interno (latência de rede)

6. Benchmarks de Referência

7. Diagnóstico por Métrica

DNS alto → problema no resolvedor

TCP alto → latência de rede ou firewall

TLS alto → negociação de certificado lenta

TTFB alto → lentidão no servidor / backend

Total alto mas TTFB ok → transferência de payload grande

8. Exemplos Completos

Health check com saída estruturada

Monitoramento contínuo com alerta

Testar múltiplas URLs de uma lista

9. Receitas cURL de Uso Geral

9.1 Cabeçalhos e Inspeção de Resposta

9.2 Download de Arquivos

9.3 Envio de Dados (POST / PUT / PATCH)

9.4 Autenticação

9.5 Cookies e Sessões

9.6 Proxies e Tunelamento

9.7 TLS / SSL

9.8 Redirecionamentos e DNS

9.9 Debugging e Verbose

9.10 Flags Essenciais — Resumo Rápido