Updo: guía rápida (y útil) para monitorizar webs desde la terminal

X (Twitter) Facebook Pinterest LinkedIn Email WhatsApp

¿Qué es Updo?

Updo es una herramienta CLI (licencia MIT) para monitorizar uptime y rendimiento de sitios y APIs HTTP/HTTPS. Puede verificar varios destinos a la vez, hacer peticiones con cabeceras/POST/JSON, comprobar certificados SSL (caducidad), emitir alertas (webhooks/desktop), exportar métricas a Prometheus y, si quieres cobertura mundial, ejecutarse en Lambdas de AWS en 13 regiones para medir desde cerca de tus usuarios.

Puntos fuertes

Todo desde la terminal (TUI interactivo o salida simple/JSON).
Alertas por webhook (Slack, Discord, tu endpoint) o notificaciones locales.
Prometheus/Grafana: exporta métricas y usa dashboards preconfigurados.
Multirregión con AWS Lambda: latencia real por zona geográfica.
Flexible: headers, métodos HTTP, cuerpo de petición, aserciones de texto, seguir redirecciones, saltar verificación SSL (si sabes lo que haces).

Instalación

macOS (Homebrew), Linux (gestores), Windows (descarga directa) o Docker. También puedes compilar desde fuente (Go).

Consejo: si vas a usar Prometheus y Lambdas, instala Updo en una máquina/VM con Docker para levantar el stack de ejemplo de Grafana rápidamente.

Primeros pasos

Monitorización básica

./updo monitor https://example.com
Lenguaje del código: JavaScript (javascript)

Por defecto refresca cada 5 s, timeout 10 s.
Interfaz TUI con latencia, estado HTTP, uptime, etc.

Ajustando intervalos y salidas

# Intervalo y timeout
./updo monitor --refresh 10 --timeout 5 https://example.com

# Modo simple (texto) y número de iteraciones (ej. 10)
./updo monitor --simple --count 10 https://example.com

# Logs estructurados JSON (ideal para piping)
./updo monitor --log --count 10 https://example.com > output.json
Lenguaje del código: PHP (php)

Peticiones personalizadas

# GET con cabecera + aserción de contenido
./updo monitor \
  --header "Authorization: Bearer token" \
  --assert-text "Welcome" \
  https://example.com

# POST JSON a una API
./updo monitor \
  --request POST \
  --header "Content-Type: application/json" \
  --data '{"test":"data"}' \
  https://api.example.com/health
Lenguaje del código: PHP (php)

Aserciones: si --assert-text no aparece en la respuesta, el target se considera “down” (útil para detectar errores lógicos: 200 OK pero contenido incorrecto).

Múltiples destinos

Por línea de comandos

./updo monitor https://google.com https://github.com https://cloudflare.com
Lenguaje del código: JavaScript (javascript)

Con archivo de configuración (TOML)

Para configuraciones complejas, usa TOML y mezcla globales con overrides por objetivo.

example-config.toml

[global]
refresh_interval = 5
timeout = 10
webhook_url = "https://hooks.slack.com/services/YOUR/WEBHOOK"
only = ["Google", "API"]  # filtra por nombre

[[targets]]
url = "https://www.google.com"
name = "Google"
refresh_interval = 3
assert_text = "Google"

[[targets]]
url = "https://api.example.com/health"
name = "API"
method = "POST"
headers = ["Authorization: Bearer token"]
Lenguaje del código: PHP (php)

Ejecuta:

./updo monitor --config example-config.toml

Opciones útiles por target

method, headers, body
assert_text, should_fail (esperar fallo)
skip_ssl, follow_redirects, accept_redirects
webhook_url, webhook_headers
regions (para multirregión AWS)

Alertas por webhook

Recibirás un JSON con cambios de estado (up/down). Ejemplo de payload:

{
  "event": "target_down",
  "target": "Critical API",
  "url": "https://api.example.com",
  "timestamp": "2024-01-01T12:00:00Z",
  "response_time_ms": 1500,
  "status_code": 500,
  "error": "Internal Server Error"
}
Lenguaje del código: JSON / JSON con comentarios (json)

Slack (por target)

[[targets]]
url = "https://api.example.com"
name = "Production API"
webhook_url = "https://hooks.slack.com/services/YOUR/WEBHOOK/URL"
Lenguaje del código: JavaScript (javascript)

Webhook propio con cabeceras

[[targets]]
url = "https://critical-service.example.com"
name = "Critical Service"
webhook_url = "https://alerts.internal.com/webhook"
webhook_headers = [
  "Authorization: Bearer YOUR_TOKEN",
  "X-Service: updo-monitor"
]
Lenguaje del código: JavaScript (javascript)

Sugerencia: implementa filtros/plantillas en tu receptor para no saturar canales con flapping.

Métricas con Prometheus & Grafana

Updo puede enviar métricas a Prometheus Remote Write y visualizarse en Grafana.

Rápido con Docker (stack de ejemplo)

git clone https://github.com/Owloops/updo.git
cd updo/examples/prometheus-grafana
docker compose up -d

# Grafana -> http://localhost:3000 (dashboard incluido)
Lenguaje del código: PHP (php)

Enviar métricas desde Updo

./updo monitor \
  --prometheus-url http://localhost:9090/api/v1/write \
  https://example.com
Lenguaje del código: JavaScript (javascript)

O vía variables de entorno:

export UPDO_PROMETHEUS_RW_SERVER_URL="https://prometheus.example.com/api/v1/write"
export UPDO_PROMETHEUS_USERNAME="admin"
export UPDO_PROMETHEUS_PASSWORD="secret"

./updo monitor https://example.com
Lenguaje del código: JavaScript (javascript)

Métricas típicas

Uptime por target
Latencias (DNS, TCP, TTFB, descarga)
Códigos HTTP y ratios de éxito
Caducidad de certificados SSL
Resultados de aserciones

Con estas series podrás crear SLO/SLI sencillos (ej. uptime mensual ≥ 99,9 %, p95 de respuesta ≤ 800 ms).

Monitorización multirregión (AWS Lambda)

Para medir “desde donde están tus usuarios”, despliega ejecutores remotos en Lambdas de varias regiones y deja que Updo coordine.

Despliegue

# Requiere AWS CLI con credenciales y permisos (Lambda, IAM, STS)
updo aws deploy --regions us-east-1,eu-west-1
Lenguaje del código: PHP (php)

Uso

# Ejecuta checks desde esas regiones (latencias comparables por zona)
./updo monitor --regions us-east-1,eu-west-1 https://example.com
Lenguaje del código: PHP (php)

Limpieza

updo aws destroy --regions all

Regiones soportadas (13): us-east-1, us-west-1, us-west-2, eu-west-1, eu-central-1, eu-west-2, ap-southeast-1, ap-southeast-2, ap-northeast-1, ap-northeast-2, ap-south-1, sa-east-1, ca-central-1

Tips

Si ves errores de credenciales: aws sso login --profile tu-perfil.

Etiqueta recursos y limita roles/políticas de IAM (principio de menor privilegio).

Logging y automatización

Logs JSON

# Todo a un archivo
./updo monitor --log https://example.com > all.json 2>&1

# Métricas por stdout, errores por stderr
./updo monitor --log https://example.com > metrics.json 2> errors.json

# Ejemplo con jq
./updo monitor --log https://example.com | jq 'select(.type=="check") | .response_time_ms'
Lenguaje del código: PHP (php)

CI/CD (idea)

Un job nocturno ejecuta checks cortos en modo JSON.
Carga a S3/Blob o Loki (si usas grafana/loki) para auditoría.
Si event == target_down, dispara workflow (crear issue, notificar on-call).

Teclas rápidas (TUI)

↑/↓: Navegar targets
Enter: Expandir/plegar target
Tab: Expandir/plegar todos
/: Buscar (ESC para salir)
l: Alternar logs por target
q / Ctrl+C: Salir

Buenas prácticas

Aserciones en endpoints críticos (ej. “status”: “ok”) para detectar degradaciones lógicas.
Caducidad SSL: alerta con antelación (30/15/7 días).
Evita falso positivo: ajusta timeout, refresh_interval y retries (vía count o diseñando tu pipeline).
Rateguards: cuidado con --refresh bajos en APIs de terceros.
Multirregión: compara latencias y errores por región antes de pensar que “mi app está caída”.
Prometheus: define sencillos alert rules (target_down X minutos, p95 > umbral, etc.).

¿Updo o…?

Herramienta	Tipo	Multirregión (nativo)	Prometheus	Alertas	Complejidad	Notas
Updo (CLI)	CLI/TUI	✔ (AWS Lambda)	✔ (RW)	✔	Baja-Media	Muy flexible desde terminal; config TOML
Uptime Kuma	Web self-host	✖ (pero con agentes)	Exporter	✔	Baja	UI bonita, panel web completo
Blackbox Exporter	Exporter	✖ (despliegas tú)	✔	Via Prom	Media	Sonda HTTP/ICMP/TCP desde Prometheus
Healthchecks	SaaS/self	✖	✔ (webhook)	✔	Baja	Más “cron/heartbeat” que HTTP sintético
SaaS (StatusCake, UptimeRobot, etc.)	Servicio	✔ (puntos de presencia)	APIs	✔	Muy baja	Pagas por simplicidad, menos control

Si quieres mínimo fricción y dashboard siempre a la vista, Kuma.
Si ya vives en Prometheus/Grafana, Blackbox.
Si te gusta CLI + flexibilidad y multirregión sin pagar SaaS, Updo encaja muy bien.

Troubleshooting rápido

Certificados: evita --skip-ssl salvo test controlados.
Proxy corporativo: exporta variables HTTP_PROXY/HTTPS_PROXY.
Flapping de alertas: sube --timeout, añade aserciones estables, agrega debounce en tu receptor webhook.
AWS credenciales: renueva sesión aws sso login --profile X.
Prometheus RW: revisa URL correcta (/api/v1/write), auth y cortafuegos.

Plantilla TOML “pro” (ejemplo)

[global]
refresh_interval = 10
timeout = 8
webhook_url = "https://hooks.slack.com/services/YOUR/WEBHOOK"
follow_redirects = true
accept_redirects = true
regions = ["us-east-1","eu-west-1"]   # checks remotos

[[targets]]
name = "Front"
url = "https://www.tusitio.com"
assert_text = "Bienvenido"
webhook_headers = ["X-Env: prod"]
# override de intervalos
refresh_interval = 5

[[targets]]
name = "API Login"
url = "https://api.tusitio.com/login"
method = "POST"
headers = ["Content-Type: application/json","Authorization: Bearer ${TOKEN}"]
body = '{"ping":"pong"}'
assert_text = "\"status\":\"ok\""

[[targets]]
name = "Docs"
url = "https://docs.tusitio.com"
skip_ssl = false
Lenguaje del código: PHP (php)

Puedes inyectar secretos vía variables de entorno en tu CI/CD y plantillas TOML.

Conclusión

Updo es una forma directa, extensible y “dev-friendly” de levantar monitorización real en minutos: desde la terminal, con alertas y métricas, y la posibilidad de probar desde el mundo con Lambdas. Es perfecto para equipos que quieren control, código y portabilidad, sin renunciar a gráficos y alertas de verdad.

Si quieres, te preparo un docker-compose con Updo como sidecar, Prometheus RW Gateway y Grafana, más un ejemplo de Alertmanager con reglas básicas de SLO. ¿Te lo dejo listo para copiar/pegar?