Negocios: Tecnología · Lección N.tec.5

Coreografía: incident response con copiloto

La IA correlaciona logs entre servicios y arma la timeline del incidente en minutos, pero la causa raíz, el rollback y la firma del postmortem siguen siendo del incident commander humano.

Ejemplos para

Tres de la madrugada, PagerDuty dispara. El checkout está devolviendo error 500 para 12% de los pedidos, y todo el equipo despierta tratando de entender qué cambió en las últimas dos horas. Antes esto era rebuscar en Datadog, Grafana y el log del servicio de pago uno por uno, casi cuarenta minutos solo para armar la línea de tiempo antes de siquiera considerar una causa. Hoy pegas los logs de los tres servicios en la IA y, en menos de dos minutos, devuelve una timeline con el horario de cada error, el deploy que salió a las 2h48 y la versión anterior estable. También sugiere, con la misma confianza de siempre, que la causa es una migración de base de datos que corrió al mismo tiempo. Solo que esa migración ya había corrido la semana pasada sin ningún problema, y eres tú, el incident commander, quien necesita notarlo antes de decidir el rollback.

Oye, tres de la madrugada, alarma disparando, y la primera pregunta en tu cabeza nunca es "qué se ve bonito", es "qué cambió". Antes esto significaba abrir tres, cuatro paneles distintos y cruzar log a mano, media hora perdida solo para entender la escena del crimen antes de siquiera considerar una causa. La IA cambia esa parte de un modo real: lee todo eso rápido y te entrega una línea de tiempo. El problema es que también señala una causa, con la misma cara de certeza de siempre, y no siempre acertó.

La idea central de esta lección. Un incidente tiene una coreografía con pasos fijos, y la IA entra con fuerza en los pasos mecánicos: correlacionar log entre servicios, armar la timeline, redactar el borrador del postmortem. Lo que sigue siendo tuyo, siempre, es la causa raíz, la decisión de hacer rollback, corregir o esperar, la decisión de escalar, y la firma final del postmortem. La IA enciende la escena; tú lees la escena y decides qué hacer con ella. Y como en todo el resto de este módulo, la causa que propone es sospechosa hasta que la verifiques en el log real.

01La coreografía del incidente, paso a paso

Un incidente bien conducido tiene un orden, y saltarse un paso es lo que hace que un buen equipo se equivoque en una decisión simple bajo presión. Detectar, armar la timeline, levantar la causa probable, decidir la acción, comunicar, y por último escribir el postmortem. Seis pasos, roles bien definidos entre máquina y persona.

La IA entra con fuerza en los pasos dos y seis: armar la timeline a partir del log crudo, y redactar el postmortem a partir de lo que ya pasó. Tú entras con fuerza en los pasos tres, cuatro y cinco: levantar la causa de verdad, decidir la acción, y comunicar con tu propia voz a quien necesita saber. El paso uno, detectar, generalmente ya viene de una alerta automática, PagerDuty, Datadog, lo que sea; la coreografía empieza de hecho cuando alguien, tú, toma el mando.

1 Detectar alarma dispara 2 Timeline la IA arma 3 Causa tú auditas 4 Decidir rollback o no 5 Comunicar tu voz 6 Postmortem la IA redacta los pasos 3, 4 y 5 son tuyos pasos 2 y 6: la IA arma el borrador

02Dónde la IA entra con fuerza: correlacionar log y armar la timeline

Aquí la IA gana tu tiempo de verdad. Un incidente moderno cruza servicios: el frontend, la API, la base de datos, un proveedor externo, cada uno con su propio log, en herramientas distintas. Juntar esto a mano, mirando timestamp por timestamp en Datadog, Grafana y en el log crudo del servicio, es el tipo de trabajo mecánico que consume los primeros veinte, treinta minutos preciosos de cualquier incidente.

Pega los logs relevantes en la IA y pídele exactamente eso: una timeline con horario de cada evento, qué cambió cerca del inicio del problema (deploy, migración, cambio de configuración), y los servicios afectados en orden. Ella hace esto en segundos, y la ganancia de tiempo es real. Pero nota el límite: eso es lectura de eventos, no conclusión sobre la causa. La IA señala qué pasó y cuándo. Qué significa eso todavía no está decidido.

03Dónde no entra: causa raíz, rollback y escalada

Aquí vive el riesgo que le da nombre a esta lección. Después de armar la timeline, la mayoría de las herramientas de IA va un paso más allá y sugiere una causa probable. Y lo hace con el mismo tono seguro de siempre, sea la causa correcta o inventada. Puede citar la línea equivocada del diff, culpar a un servicio que solo coincidió en el tiempo, o repetir un patrón común de falla que no es tu caso.

Por eso la causa raíz de verdad es siempre una decisión tuya, verificada en el log original, no aceptada porque "suena razonable". Lo mismo vale para las tres decisiones que vienen después: hacer rollback, aplicar un hotfix o esperar; escalar a otro equipo o no; y declarar la severidad del incidente. Ninguna de esas decisiones es técnica pura, todas cargan un criterio de riesgo y de contexto que solo quien está al mando del incidente logra sopesar. La IA nunca toma el mando. Entrega munición para que el comandante decida.

IA propone causa tono seguro, correcta o no tú verificas en el log original coincide: rollback o hotfix decidido no coincide: investiga más, o escala la decisión sale solo después de la verificación, nunca antes

04El runbook vivo

Todo incidente que se resuelve carga una lección, y la mayoría de esas lecciones muere en el chat del equipo en vez de convertirse en conocimiento reutilizable. El runbook vivo es lo opuesto: cada incidente real que pasa por tu mesa se convierte en una actualización concreta del runbook, no en una revisión trimestral que nadie recuerda hacer.

Después de cerrar el incidente, pídele a la IA que compare lo que pasó con el runbook actual: ¿ese escenario ya estaba cubierto? ¿El paso que funcionó necesita entrar como nuevo procedimiento? Este es el mismo principio del sistema que mejora solo que ya viste en el módulo de Finanzas, aplicado aquí: el runbook no es un documento que se escribe una vez, es una pieza que crece con cada entrega real. Ya viste, en la lección 6.1, la IA operando un proceso entero con portones de calidad; el runbook vivo es el portón de conocimiento de ese mismo proceso, volviéndose más fuerte en cada ronda.

Sabe más: por qué el postmortem sin culpa protege la calidad de la causa raíz

La práctica de postmortem sin culpa (blameless postmortem) existe porque, cuando alguien teme ser señalado como el error, la tendencia es simplificar la causa raíz para cerrar el asunto rápido, "fue un error de configuración" en vez de investigar por qué el proceso permitió que ese error llegara a producción. Esto importa el doble cuando la IA está en el medio: si el equipo acepta la primera causa que ella sugiere solo para cerrar el caso más rápido, la causa real, generalmente una falla de proceso, sigue escondida y el mismo incidente vuelve a ocurrir. Un postmortem sin culpa, auditado con cuidado, es lo que impide que tanto la persona como la máquina se conviertan en chivo expiatorio barato de una causa que nadie investigó bien.

05Auditoría del postmortem antes de publicar

El borrador de postmortem que la IA escribe suele ser bueno: organiza la timeline, describe el impacto, sugiere acciones de prevención. El riesgo vive exactamente en la sección de causa raíz, porque ahí es donde puede inventar una explicación plausible que no coincide con el log real.

Antes de publicar, quien firma el postmortem verifica la causa raíz línea por línea contra el log original, el mismo principio de auditoría que atraviesa todo este módulo desde la primera lección. Si la causa no coincide, el postmortem no sale, sin importar qué tan bien escrito esté. Un postmortem publicado con causa equivocada no es solo un error de registro, es una lección equivocada que todo el equipo va a cargar para el próximo incidente parecido.

Hazlo ahora

Hazlo tú

Toma un incidente real reciente de tu equipo, tu tarea real u otro, o simula un escenario parecido si no tienes uno a mano.

  1. Reúne los logs relevantes (del servicio afectado y de al menos un servicio vecino) y pídele a la IA que arme la timeline: qué pasó, en qué orden, qué cambió cerca del inicio del problema.
  1. Pídele que sugiera una causa probable y redacte el borrador del postmortem a partir de esa timeline.
  1. Ahora haz la parte que es tuya: abre el log original y verifica, línea por línea, si la causa que sugirió realmente coincide con lo que pasó. Anota si coincidió o no.
  1. Si no coincidió, escribe la causa real y ajusta el postmortem antes de considerarlo listo para que cualquier persona lo lea.

Acabas de correr la coreografía entera, y la parte que separó un postmortem confiable de uno bonito y equivocado fue exactamente la verificación que hiciste en el paso tres.

Practica

1. En la coreografía de incident response con IA copiloto, ¿qué hace bien y con fuerza?

2. La IA sugirió, durante un incidente, que la causa raíz fue una migración de base de datos que ya había corrido sin problema la semana anterior. ¿Cuál es la actitud correcta?

3. ¿Qué hace que un runbook sea 'vivo', en el sentido de esta lección?

Para la pizarra

Sobre la primera preguntaa las tres de la mañana nadie pregunta qué se ve bonito. Pregunta qué cambió.
Sobre la divisiónarmar la línea de tiempo es de ella. Causa raíz, rollback y escalamiento siguen siendo del equipo.
Sobre el runbookcrece con cada incidente real, incorporando lo que funcionó y lo que faltaba.
¿Qué te pareció esta página?
¿Recomendarías esta página a alguien de tu equipo?