Cotiza por WhatsApp en 2 min

Contacto

Ciudad de México, México
Disponible para proyectos remotos y presenciales.

Redes profesionales

LinkedIn · GitHub · Correo
Ingeniería aplicada, resultados medibles.

GTA 6 y caídas en cadena: ¿tu sitio depende de otros?

· 14 min de lectura · Samuel Torres

Por Samuel Torres — Software & Cloud Engineer. 23+ sitios en producción.

El tráfico de GTA 6 viaja por las redes de los proveedores de internet y de las plataformas de juego, no por el servidor de tu empresa. Lo que sí puede tumbar tu sitio este 19 de noviembre es una dependencia externa que se cae o se pone lenta: un CDN, el DNS, la pasarela de pago o una API. Opero 23+ sitios WordPress en producción sobre AlmaLinux + WHM/cPanel, y esta guía es la revisión que te recomiendo hacer hoy: inventario de dependencias, timeouts, caché de respaldo, failover de DNS y monitoreo externo.

No vas a encontrar aquí una lista de consejos para jugadores. Es una revisión técnica para quien administra el sitio de una empresa que no tiene nada que ver con videojuegos, pero que comparte internet con millones de descargas el mismo día.

Por qué el tráfico de GTA 6 no es tu problema (y tus dependencias sí)

Los números del lanzamiento son reales. Según Newsweek, Comcast dijo que las precargas de GTA 6 fueron el mayor evento individual en la historia de su red, y Spectrum reportó que el tráfico de descargas de juegos subió entre 40 y 50 por ciento durante la ventana de precarga. En Reino Unido, Virgin Media O2 registró su pico más alto: entre medianoche y la 1 a.m. el tráfico fue 51.6 por ciento mayor que a la misma hora una semana antes.

Nada de eso pasa por tu hosting. Los mismos expertos que cita Newsweek dicen que lo probable no es una caída general de internet, sino fallas locales o problemas en servicios concretos. Steve Uhlig, de Queen Mary University of London, señala como puntos de presión los CDNs, la infraestructura de las plataformas de juego, los sistemas de autenticación y las redes de acceso.

Ese es el punto: tu sitio usa varios de esos servicios compartidos. Polygon recordó esta semana que Outlook y Excel de Microsoft estuvieron caídos casi 24 horas porque un gateway defectuoso se saturó con la cantidad de datos, y describe los servicios en línea como sistemas interconectados frágiles. No hay evidencia de que esas caídas fueran ataques; basta con que una pieza ajena falle para que la tuya se vea rota.

La pregunta útil para hoy no es «¿aguanta mi servidor?», sino «¿qué le pasa a mi sitio si el CDN, el DNS o la pasarela tardan treinta segundos en responder?».

Mapea de qué depende tu sitio

No puedes proteger lo que no sabes que usas. Un WordPress típico de empresa carga fuentes de Google, un script de analítica, un widget de chat, un CDN para imágenes, un plugin de pagos que habla con la API de la pasarela y, a veces, un plugin que consulta tipos de cambio o inventario en otro servidor. Cada uno es un punto de falla que no controlas.

El primer paso es un inventario honesto. Hay dos lados: lo que carga el navegador del visitante y lo que llama tu servidor por PHP. El primero se ve en el HTML de la portada; el segundo está en el código de tus plugins y tema. Este script saca las dos listas, ordenadas por cuántas veces aparece cada dominio:

#!/bin/bash
# Inventario de dependencias externas de un WordPress en cPanel
sitio="https://tusitio.mx/"
raiz="/home/usuario/public_html"
echo "== Lo que carga el navegador (portada) =="
curl -s --max-time 15 "$sitio" | grep -oE '(src|href)="https://[^"/]+' \
  | sed -E 's/.*"https:\/\///' | sort | uniq -c | sort -rn
echo "== Lo que llama PHP (plugins y tema activos) =="
grep -rhoE "https://[a-z0-9.-]+\.[a-z]{2,}" "$raiz/wp-content/plugins" "$raiz/wp-content/themes" \
  --include='*.php' | sed -E 's#https://##' | sort | uniq -c | sort -rn | head -25

⚠️ El script sólo lee archivos y hace peticiones GET, pero corre primero en una copia o en staging si no conoces bien el servidor.

Con esa lista en mano, clasifica cada dependencia en tres grupos. Críticas: si fallan, el sitio no vende o no carga (pasarela de pago, DNS, CDN si sirve todo el HTML). Degradables: si fallan, el sitio debe seguir funcionando sin ellas (chat, analítica, fuentes, widgets). Ocultas: llamadas que hace PHP al cargar la página y que bloquean la respuesta mientras esperan; son las más peligrosas porque nadie las ve hasta que el sitio se congela.

Cada dependencia crítica necesita un plan B escrito. Cada degradable necesita cargarse sin bloquear (atributos async o defer en los scripts). Cada oculta necesita un timeout corto y una copia de respaldo, que es lo que veremos en las dos secciones siguientes.

Timeouts: que un tercero lento no tumbe tu sitio

Un servicio caído es fácil de detectar: responde error y ya. El problema real es el servicio lento. Si un plugin llama a una API al generar cada página y esa API tarda treinta segundos en contestar, cada visita deja un proceso PHP esperando. Los procesos de PHP-FPM de la cuenta se agotan, las visitas nuevas hacen fila y tu sitio parece caído aunque tu servidor esté sano.

La defensa tiene dos partes: medir cuánto tarda cada dependencia hoy y limitar cuánto está dispuesto a esperar tu código. Para medir, este script recibe las URLs como argumentos y reporta código HTTP, tiempo de resolución DNS y tiempo al primer byte, con un límite duro para que nunca se quede colgado:

#!/bin/bash
# Uso: ./deps.sh https://fonts.googleapis.com https://api.mercadopago.com
# Reporta código HTTP, DNS y TTFB; corta a los 5 s para no quedarse colgado
for url in "$@"; do
  salida=$(curl -s -o /dev/null --connect-timeout 3 --max-time 5 \
    -w '%{http_code} dns=%{time_namelookup}s ttfb=%{time_starttransfer}s' "$url")
  estado=$?
  if [ "$estado" -ne 0 ]; then echo "FALLA  $url (curl salió con $estado)"; continue; fi
  echo "OK     $url $salida"
done

Pásale los dominios que salieron del inventario. Si alguno tarda más de un par de segundos en un día normal, en un día de tráfico raro va a tardar más.

Para limitar la espera dentro de WordPress, la API HTTP de WordPress acepta el parámetro timeout en wp_remote_get(). El valor por defecto es de cinco segundos, y muchos plugins lo suben sin pensarlo. Si el plugin es tuyo, ponle un timeout corto a cada llamada. Si es de terceros, el filtro http_request_args te deja bajarlo para un dominio concreto sin tocar el código del plugin:

<?php
// mu-plugins/timeouts-externos.php: ninguna API externa bloquea más de 3 s
add_filter('http_request_args', function (array $args, string $url): array {
    $host = (string) wp_parse_url($url, PHP_URL_HOST);
    $lentos = ['api.mercadopago.com', 'api.stripe.com', 'api.openweathermap.org'];
    if (in_array($host, $lentos, true)) {
        $args['timeout'] = 3;
        $args['redirection'] = 2;
    }
    return $args;
}, 10, 2);

Ajusta la lista $lentos con los dominios de tu inventario. Un mu-plugin se carga siempre y no se puede desactivar por error desde el panel, por eso conviene para algo así.

⚠️ Antes de aplicarlo en producción: respalda wp-content/mu-plugins y prueba el rollback (borrar el archivo deja todo como estaba). Prueba el checkout completo en staging: un timeout demasiado corto en la pasarela puede cortar pagos legítimos.

Caché de respaldo con stale-while-revalidate y stale-if-error

El timeout evita que el sitio se congele, pero el visitante sigue viendo un hueco donde iba el dato. La segunda capa es servir la última copia buena cuando la fuente falla. Hay dos lugares para hacerlo: en las cabeceras HTTP, para que el CDN y el navegador reutilicen copias, y en PHP, para los datos que tu sitio trae de APIs.

En las cabeceras, stale-while-revalidate permite servir una copia vencida mientras se pide la nueva en segundo plano, y stale-if-error permite servir la copia vencida si el origen responde con error, por ejemplo un HTTP 503 Service Unavailable. Ojo con el alcance: estas directivas protegen cuando falla tu origen o lo que está detrás de él; si el CDN mismo se cae, ninguna cabecera te salva y necesitas poder apuntar el DNS directo a tu servidor. Y en WordPress aplícalas sólo a archivos estáticos: las páginas HTML pueden llevar sesión, carrito o datos de usuario.

# .htaccess: caché de respaldo sólo para estáticos (no para HTML con sesión)
<IfModule mod_headers.c>
  <FilesMatch "\.(css|js|woff2|webp|avif|jpg|jpeg|png|svg)$">
    Header set Cache-Control "public, max-age=600, stale-while-revalidate=600, stale-if-error=86400"
  </FilesMatch>
  <FilesMatch "\.(php|html)$">
    Header set Cache-Control "no-cache, private"
  </FilesMatch>
</IfModule>

La lectura de esos valores: max-age=600 (600 segundos) es lo que la copia se considera fresca; stale-while-revalidate=600 da otros 600 segundos en los que se puede servir la copia vencida mientras se revalida; stale-if-error=86400 permite seguir sirviéndola hasta un día completo si el origen da error. Ajusta los números a qué tan seguido cambian tus archivos. Si tu tema versiona los CSS y JS con ?ver=, puedes subir max-age sin miedo.

Para comprobarlo, pide la cabecera de un archivo estático real de tu sitio con curl -sI y busca cache-control en la respuesta. Si tu CDN sobrescribe las cabeceras, la configuración equivalente vive en su panel, no en .htaccess.

En PHP, el patrón es guardar la última respuesta buena de cada API y usarla cuando la llamada falla. Esta función devuelve el dato fresco si la API contesta, la copia de una hora si no, y la última copia buena conocida como último recurso:

<?php
// Llama a una API externa con timeout corto y cae a la última copia buena
function api_con_respaldo(string $url, string $clave): ?array {
    $resp = wp_remote_get($url, ['timeout' => 3]);
    if (!is_wp_error($resp) && wp_remote_retrieve_response_code($resp) === 200) {
        $datos = json_decode(wp_remote_retrieve_body($resp), true);
        set_transient($clave, $datos, HOUR_IN_SECONDS);
        update_option($clave . '_ultimo_bueno', $datos, false);
        return $datos;
    }
    $copia = get_transient($clave);
    return $copia !== false ? $copia : get_option($clave . '_ultimo_bueno', null);
}

El tercer argumento false de update_option evita que la copia se cargue en memoria en cada página. Si usas caché de objetos con Redis, los transients viven ahí y la copia de respaldo en la base de datos sobrevive aunque se vacíe Redis.

⚠️ Antes de cambiar .htaccess: respáldalo con cp -p .htaccess .htaccess.bak. Si el sitio da error 500, restaurar ese archivo es el rollback.

Fallback de DNS y de pasarela de pago

El DNS es la dependencia que más gente olvida. Si el registro de tu dominio apunta a un solo servidor y ese servidor no responde, no hay nada que el visitante pueda hacer. Route 53 de AWS resuelve esto con una política de failover: un health check revisa tu servidor principal y, si falla, Route 53 empieza a responder con la IP de un servidor de respaldo, que puede ser una copia estática del sitio o una página de mantenimiento con tus datos de contacto.

Es importante entender qué cubre y qué no. El failover de Route 53 cambia el destino cuando falla tu servidor; no te protege si el propio servicio DNS que usas se cae. Para eso existe el DNS secundario con otro proveedor, que es otro proyecto. Con Terraform, el failover queda declarado y versionado, y deshacerlo es un terraform apply del estado anterior:

resource "aws_route53_health_check" "origen" {
  ip_address        = var.ip_servidor
  fqdn              = "tusitio.mx"
  type              = "HTTPS"
  failure_threshold = 3
}
resource "aws_route53_record" "primario" {
  zone_id         = var.zone_id
  name            = "tusitio.mx"
  type            = "A"
  ttl             = 60
  records         = [var.ip_servidor]
  set_identifier  = "primario"
  health_check_id = aws_route53_health_check.origen.id
  failover_routing_policy { type = "PRIMARY" }
}
resource "aws_route53_record" "respaldo" {
  zone_id        = var.zone_id
  name           = "tusitio.mx"
  type           = "A"
  ttl            = 60
  records        = [var.ip_respaldo]
  set_identifier = "respaldo"
  failover_routing_policy { type = "SECONDARY" }
}

Declara var.zone_id, var.ip_servidor y var.ip_respaldo en tu variables.tf. El health check usa la IP directa para no depender del mismo registro que vigila, y el fqdn sólo sirve para que el certificado y el virtual host respondan bien; revisa la raíz del sitio por HTTPS cada 30 segundos (valor por defecto) y marca falla tras tres intentos. El TTL bajo hace que el cambio se note rápido.

⚠️ Antes de aplicarlo en producción: exporta la zona actual, corre terraform plan y revisa que sólo cree lo que esperas. Guarda el estado anterior para poder regresar.

Con la pasarela de pago la regla es otra. No programes un reintento automático con un segundo proveedor: si la primera pasarela cobró pero tardó en contestar, el reintento puede cobrar dos veces. Lo seguro es que el checkout muestre un mensaje claro cuando la pasarela no responde y ofrezca un método alterno que no dependa de esa API, como transferencia o pago en tienda, y que alguien revise los pedidos pendientes antes de reintentar nada.

Monitoreo externo: enterarte antes que tu cliente

El monitoreo que corre dentro de tu servidor te dice que el servidor está bien. No te dice que el DNS dejó de resolver, que el CDN está sirviendo errores o que la pasarela tarda veinte segundos. Para eso necesitas mirar desde fuera, desde donde están tus clientes.

La versión mínima cabe en una máquina distinta a tu servidor: otra instancia, un equipo de la oficina o un servicio de monitoreo. Corre el script de dependencias de la sección de timeouts con un cron cada pocos minutos, guarda la salida en un log y manda un aviso cuando aparezca una línea con FALLA. Agrega a la lista tu propia portada, tu página de checkout y el endpoint de la pasarela.

Mide tres cosas por dependencia: si responde, cuánto tarda en resolver el DNS y cuánto tarda el primer byte. Guarda la línea base de un día normal; el día del pico compara contra ella. Una dependencia que pasa de responder rápido a tardar varios segundos es la señal temprana de una caída en cadena, y es el momento de activar el plan B que escribiste en el inventario.

Lo más valioso del monitoreo externo no es la alerta, sino el orden: cuando el teléfono suena, ya sabes si el problema es tuyo o de un tercero, y puedes decirle al cliente qué pasa en lugar de adivinar.

El caso real

Lo que puedo contar con datos verificados es esto: opero 23+ sitios WordPress en producción sobre AlmaLinux + WHM/cPanel, y migré 61 dominios a PHP 8.3, uno por uno, con respaldo y rollback automático. También compilé Redis 6.3.0 para ea-php83 sin perder caché en producción. No tengo un caso con cifras de una caída de CDN o de DNS que pueda publicar, así que no voy a inventarlo.

[FALTA CAPTURA: salida del script de inventario de dependencias sobre un sitio real, con los dominios externos ordenados por número de apariciones]

Por qué lo menciono en un artículo sobre dependencias: la regla que hizo posible esa migración es la misma que te recomiendo aquí. Un cambio a la vez, respaldo antes de tocar nada y una forma automática de regresar si algo sale mal. Aplica igual al timeout de un plugin, a una cabecera de caché o a un registro DNS: si no sabes cómo deshacerlo en un minuto, todavía no estás listo para aplicarlo en producción.

Lo demás de esta guía es recomendación, no historia: haz el inventario, mide tus dependencias hoy, pon timeouts cortos a las llamadas ocultas, guarda la última copia buena de cada API y vigila desde fuera.

Lo que yo no haría

No dejaría un sitio con un solo registro DNS apuntando a un solo servidor sin plan B. No hace falta montar infraestructura compleja: un failover a una página estática con tu teléfono y tu correo ya evita que el visitante vea un error del navegador. Y no confundiría ese failover con tener DNS redundante: son dos problemas distintos y conviene saber cuál tienes cubierto.

No dejaría que una llamada de PHP a una API externa bloquee la generación de la página sin timeout. Es la falla más común y la más silenciosa: el sitio no da error, sólo se pone lento hasta que deja de responder. Tampoco subiría el timeout para «arreglar» una API lenta; eso sólo hace que la fila de procesos crezca más rápido.

No haría un reintento automático de cobro con otra pasarela. El riesgo de cobrar dos veces cuesta más que una venta perdida.

¿Lo revisamos juntos?

Si tu sitio depende de un CDN, una pasarela de pago o APIs externas, y no tienes claro qué pasa cuando alguna falla, puedo hacer contigo la revisión de esta guía: inventario de dependencias, timeouts, caché de respaldo, failover declarado en AWS con Terraform y monitoreo externo. Antes, revisa el checklist de auditoría de seguridad para WordPress. Agenda una auditoría de dependencias y AWS + Terraform en /contacto.

Sobre el autor

Samuel Torres es Software & Cloud Engineer en Conqr Digital Agency (CDMX). Opera 23+ sitios WordPress en producción y migró 61 dominios a PHP 8.3, uno por uno, con respaldo y rollback automático. Más en /sobre-mi. Cotiza por WhatsApp en 2 min

Samuel Torres Pichardo

Samuel Torres Pichardo
Ingeniero de software y cloud en Ciudad de México, con unos 3 años de experiencia profesional.
Sobre mí · LinkedIn · GitHub · Contacto