AWS DevOps Agent: dejar que una IA investigue el incidente por ti
Si alguna vez estuviste de guardia, conoces el ritual. Suena la alarma, abres el laptop medio dormida, y empieza la parte tediosa: revisar métricas en CloudWatch, buscar el trace en X-Ray, cruzar con CloudTrail para ver qué cambió, leer logs. Media hora después, por fin entiendes qué pasó. Y muchas veces la solución era un rollback de un minuto.
Lo que me llamó la atención de AWS DevOps Agent es justo eso: la promesa de que esa media hora de trabajo detectivesco ya esté hecha cuando tú llegas. Así que lo monté en mi cuenta, provoqué un incidente a propósito, y me senté a ver qué encontraba.
El dolor real: el MTTR se va en entender, no en arreglar
Algo que aprendí con el tiempo: el tiempo de resolución de un incidente casi nunca se va en arreglar el problema. Se va en entenderlo. La corrección suele ser rápida; lo caro es el trabajo forense previo, correlacionar métricas, logs, traces y cambios recientes, bajo presión y a veces a las 3 de la mañana.
Ahí es donde un agente autónomo cambia las cosas. No reemplaza tu criterio, pero llega con la parte aburrida ya adelantada.
¿Qué es AWS DevOps Agent?
Es un agente de IA que investiga incidentes de forma autónoma. Cuando salta una alarma, el agente entra y hace lo que harías tú:
- Revisa métricas de CloudWatch para ver qué se salió de rango.
- Correlaciona traces de X-Ray para ubicar el servicio afectado.
- Mira CloudTrail para detectar qué cambió hace poco (un deploy, un cambio de config, una regla que alguien tocó).
- Inspecciona la configuración de los recursos involucrados.
- Propone un root cause y un plan de mitigación.
Todo eso queda en un timeline que puedes revisar, y además puedes chatear con el agente para pedirle más detalle.
Alarma → DevOps Agent investiga (métricas + traces + logs + cambios) → Root cause + plan
El lab: provocar un incidente y ver al agente resolverlo
La idea del lab es simple y honestamente bastante divertida: vamos a desplegar una Lambda que falla a propósito, dejamos que sus errores disparen una alarma, y le pedimos al DevOps Agent que investigue qué pasó.
📦 Código del lab: todos los scripts y la plantilla de CloudFormation están en github.com/BnkTCh/aws-devops-labs.
Para tenerlo en tu máquina:
git clone https://github.com/BnkTCh/aws-devops-labs.git
cd aws-devops-labs/lab2-devops-agent
Todos los comandos de los pasos que siguen se corren desde esa carpeta.
Lo que necesitas
- AWS CLI v2 configurado
-
jqinstalado (brew install jq) - Permisos IAM: CloudFormation, Lambda, CloudWatch, IAM, SNS
- Un email para las notificaciones de SNS
- Región:
us-east-1(es donde mejor funciona el agente hoy)
Antes de arrancar, corre la verificación de prerrequisitos:
./scripts/00-check-prereqs.sh
Este script chequea que tengas AWS CLI, jq, credenciales válidas y que estés en us-east-1. Si algo falta, te lo dice antes de que pierdas tiempo.
Paso 1: Crear el Agent Space
El Agent Space es el espacio donde vive el agente y desde donde investiga. Y aquí viene la primera sorpresa agradable: crearlo es más simple de lo que esperaba. La consola te guía y AWS auto-crea los roles de IAM por ti, con los permisos correctos, sin que tengas que pelearte con políticas a mano.
El flujo es este:
Mi consola estaba en español, así que te dejo los nombres como aparecen ahí, con el equivalente en inglés entre paréntesis.
- Entra a la consola de Agente de DevOps de AWS (AWS DevOps Agent), en
us-east-1. - Click en Crear espacio de agente (Create Agent Space).
-
Nombre del espacio de agentes:
demo-devops-agent. - Idioma de respuesta del agente (Agent response language): este detalle me encantó y no lo esperaba, puedes elegir Spanish (Latin America). El agente te responde en español, con root cause y plan de mitigación incluidos. Para quienes trabajamos en equipos hispanohablantes, que la IA te explique el incidente en tu idioma no es un lujo: es poder pegar ese hallazgo en el canal del equipo sin traducir nada.
- En Otorgar a este espacio de agente acceso a los recursos de AWS (Give this Agent Space AWS resource access), elige Creación automática de un nuevo rol de Agente de DevOps (Auto-create a new AWS DevOps Agent role).
- En Activar la aplicación web (Enabling the Agent Space Web App), otra vez Creación automática de un nuevo rol.
- Deja Acciones del agente (Agent actions) sin activar. Más abajo te cuento por qué.
- Click en Crear (Create).
Al terminar, aparece el Agent Space en la lista, listo para usar.
Cuando terminó, me dio curiosidad qué había creado exactamente, así que fui a mirar los roles en IAM. AWS había armado dos:
-
DevOpsAgentRole-AgentSpace-xxxx→ el rol de investigación, con el que el agente mira tus recursos. -
DevOpsAgentRole-WebappAdmin-xxxx→ el rol de la Web App (el operador).
Y revisando sus políticas encontré un detalle que como DevOps me pareció útil anotar: se llaman AIDevOpsAgentAccessPolicy y AIDevOpsOperatorAppAccessPolicy. Todo el servicio vive bajo el namespace aidevops. Es de esas cositas que importan en el día a día: el día que quieras auditar quién puede hacer qué con el agente, o escribir una política de IAM más restrictiva a mano, ese es el prefijo que vas a buscar.
Lo más importante para tu tranquilidad: con esta configuración, el agente trabaja en solo lectura. Investiga, correlaciona y propone, pero no modifica ni borra nada de tu infraestructura. En un servicio al que le das acceso a toda tu cuenta para investigar, ese límite de "mira pero no toca" es justo lo que uno quiere confirmar antes de habilitarlo cerca de producción.
Ahora, ojo con un detalle del formulario que no hay que pasar por alto: la sección Acciones del agente. Si la activas, le das permiso al agente para hacer cambios en los recursos de tu cuenta (AWS las llama directed actions). No es un cheque en blanco: crea un rol aparte para escribir, cada cambio necesita que una persona lo apruebe en el momento, y cada aprobación queda registrada en CloudTrail con el nombre de quien la dio. Para este lab no hace falta, así que lo dejé apagado. Pero es bueno saber que existe, porque el "solo lectura" es la configuración por defecto, no un límite del servicio.
Paso 2: Desplegar la app que falla a propósito
Ahora necesitamos algo que se rompa. Este script despliega una Lambda diseñada para fallar de forma intermitente, más las alarmas y el topic de SNS:
./scripts/02-deploy-test-app.sh
Te va a pedir un email para las alertas de SNS. Revísalo y confirma la suscripción, porque sin confirmar no te llegan las notificaciones.
¿Qué hace la Lambda por dentro? Es una simulación bastante realista de un servicio con problemas:
# Extracto de la Lambda (test-incident-app.yaml)
roll = random.random()
if roll < 0.3:
# 30% de las veces: falla con un error que parece real
raise Exception(
"DatabaseConnectionError: Cannot connect to RDS instance "
"db-prod-001. Connection pool exhausted. "
"Active connections: 100/100"
)
elif roll < 0.5:
# 20% de las veces: responde, pero lentísima (casi timeout)
time.sleep(8)
return {"statusCode": 200, "body": "Success (but slow)"}
else:
# 50% de las veces: todo bien
return {"statusCode": 200, "body": "Success"}
Me gusta que el error no sea genérico: simula un pool de conexiones a RDS agotado, que es un clásico de producción. Eso hace que el root cause que encuentre el agente sea más interesante.
El template además crea tres alarmas de CloudWatch:
| Alarma | Se dispara cuando | Métrica |
|---|---|---|
error-simulator-high-errors |
≥ 5 errores en 1 minuto | Errors |
error-simulator-high-latency |
latencia promedio > 5 segundos | Duration |
error-simulator-throttled |
≥ 3 throttles en 1 minuto | Throttles |
Paso 3: Verificar que todo está en su sitio
Antes de romper nada, confirmamos que la Lambda responde y las alarmas existen:
./scripts/03-verify-setup.sh
Este script invoca la Lambda una vez, te muestra su respuesta, lista las alarmas y verifica que la suscripción de SNS quedó registrada.
Fíjate que justo en mi prueba la Lambda cayó en el caso lento: "Success (but slow)" con 8.000 ms.
Y lo mismo en la consola de CloudWatch: las tres alarmas en verde (CORRECTO). Así se ve el sistema sano, antes del incidente.
Paso 4: Provocar el incidente
Este es el momento de la acción. El script invoca la Lambda 60 veces para generar suficientes errores y latencia como para que las alarmas salten:
./scripts/04-trigger-incident.sh
Vas a ver los ✅ y ❌ apareciendo en la terminal, uno por cada invocación. Así terminó la mía:
En mi ejecución fallaron 17 de las 60 invocaciones (28%), muy cerca del 30% que trae programado la Lambda. En el minuto más cargado hubo 6 errores, por encima del umbral de 5, y la alarma error-simulator-high-errors pasó a ALARM:
Un detalle honesto que me pasó y vale la pena que sepas: la primera vez, al verificar el setup en el Paso 3, la Lambda cayó una vez en el caso "lento" (8 segundos) y disparó la alarma de latencia por un instante... que se auto-resolvió sola a los pocos minutos al no llegar más tráfico. Eso es normal: un pico aislado dispara y se recupera. Para tener un incidente sostenido de verdad (el que el agente puede investigar bien) necesitas la ráfaga de 60 invocaciones del Paso 4.
A partir de aquí, no toques nada. Justo eso es lo que queremos observar.
Paso 5: Iniciar la investigación y ver al agente trabajar
Aquí va otra corrección importante que descubrí ejecutando el lab. Yo esperaba que, al saltar la alarma, el agente arrancara una investigación solo. Fui a la Web App del Agent Space (botón Iniciar a través de IAM, Operator access en la consola en inglés). Y el dashboard decía: "No investigations Create an investigation above to get started".
O sea: una alarma de CloudWatch en ALARM no dispara sola una investigación. No es un fallo, es cómo está diseñado: el agente arranca cuando se lo pides tú o cuando le llega el aviso de algún sistema conectado. Para automatizarlo tienes varios caminos: conectar tu herramienta de incidentes (PagerDuty o ServiceNow), o mandar la alarma a un webhook del agente, normalmente con una regla de EventBridge y una Lambda en el medio. Para este lab, lo más simple es iniciarla a mano.
Así que la arranqué yo misma. Tienes dos formas y las dos sirven:
- Botón "Start investigation" (arriba a la derecha del dashboard de incidentes).
- El chat "Chat with DevOps Agent" (la que recomiendo, porque puedes explicarle el problema con tus palabras). Escribe algo como:
"Investiga por qué la Lambda error-simulator-demo está fallando. La alarma error-simulator-high-errors está en ALARM."
Algo que no esperaba: el agente no se lanzó a investigar de inmediato. Primero me preguntó si prefería abrir una investigación formal (que corre en segundo plano y queda registrada) o seguir revisándolo en el chat. Le dije que abriera la investigación, y en segundos apareció como incidente con prioridad alta.
Y ahí empezó lo bueno. El agente organizó su investigación en cuatro pestañas: Summary, Investigation timeline, Root cause y Mitigation plan. En unos cinco minutos me entregó esto:
Lo que observó: vio que la tasa de error se mantuvo constante en ~25-29%, proporcional al tráfico. Y descartó causas con evidencia: throttling = 0, duración máxima ~8 segundos por debajo del timeout de 10s, sin fallos de entrega. No solo dijo "es esto", dijo "NO es aquello" y por qué. Ese razonamiento es lo que separa a un agente serio de un chatbot.
El root cause que encontró: aquí me sorprendió. Concluyó que el pico de errores era comportamiento intencional por diseño de la app, que el código falla ~30% de forma determinista (hardcodeada). Y lo mejor: detectó que el DatabaseConnectionError de RDS era texto simulado. No se dejó engañar por el mensaje de error; leyó el código, entendió el truco y lo dijo. Literalmente cazó el diseño de mi propio lab.
Así se ve el resumen que te deja al final: qué pasó, la causa y la mitigación propuesta, ya marcado como resolved.
Y en la pestaña de hallazgos, cada pieza de evidencia viene etiquetada: root cause, cause, symptom, observation y hasta gap (lo que no pudo ver; vuelvo a eso en las limitaciones).
La lección de oro: el agente clasificó el incidente como una falsa alarma impulsada por el volumen. La alarma usaba un umbral de conteo absoluto (≥5 errores/min), que es sensible al tráfico: una ráfaga hace que la fracción fija de fallos cruce el umbral. Su recomendación fue cambiarla a tasa de error (Errors/Invocations %) para que no salte por picos de volumen. Es decir, no solo resolvió el incidente: me enseñó que la alarma estaba mal diseñada. Y ese aprendizaje sirve mucho más allá de este lab.
Y no se quedó en el consejo: armó un plan de mitigación paso a paso, con respaldo de la configuración actual, validaciones antes y después, el cambio en sí y cómo volver atrás si algo sale mal. Incluso sugirió llevar el cambio a la plantilla de CloudFormation, para que el próximo despliegue no lo pise.
Puedes revisar el estado desde la terminal mientras tanto:
./scripts/05-check-investigation.sh
Este script te muestra el estado de las alarmas y los últimos errores en CloudWatch Logs, además de los links directos a las consolas.
Paso 6: Conversar con el agente
Todo lo anterior lo hiciste desde el chat, así que ya estás conversando con él. Puedes seguir pidiéndole cosas en lenguaje natural, como a un compañero:
- "¿Qué cambió en los últimos 30 minutos?"
- "Genera un runbook para prevenir esto."
Paso 7: Destruir todo
Cuando termines, borra todo para no dejar recursos corriendo:
./scripts/99-cleanup.sh
Aquí me llevé una lección de higiene que vale la pena contar. El script borra bien lo que creó por CloudFormation (Lambda, alarmas, SNS), pero lo que creaste desde la consola queda a tu cargo. Y no es solo el Agent Space: cuando lo borré, descubrí que los dos roles de IAM que AWS auto-creó no se van con él, quedan sueltos, junto con sus políticas AIDevOps.... No cuestan nada por existir, pero son exactamente el tipo de recurso huérfano que se acumula en una cuenta con el tiempo y que un buen DevOps limpia. Así que, además del Agent Space (Settings → Delete), acuérdate de borrar esos roles y políticas a mano.
Tiempo estimado: 30-45 minutos.
Costo: hay dos partes. Los recursos del lab (Lambda, CloudWatch, SNS) son centavos, menos de $1. El agente se cobra aparte: según la página de precios, $0.0083 por segundo mientras está trabajando (unos $30 por hora), y nada mientras está quieto. Una investigación como la mía, de unos 5 a 8 minutos, sale entre $2.50 y $4.
Las cuentas nuevas tienen una prueba gratuita de 2 meses, que incluye hasta 20 horas de investigación al mes. En mi caso, el contador del dashboard decía "Investigation hours used: 00:00", probablemente porque estaba dentro de esa prueba. Revisa en qué situación está tu cuenta antes de lanzar varias investigaciones seguidas. Lo bueno es que no hay nada corriendo por hora (ni servidores, ni clusters), así que no hay una sangría de costos mientras piensas. Aun así, corre el cleanup por orden.
Las integraciones son las que lo hacen útil de verdad
Un agente aislado no sirve de mucho; el valor aparece cuando encaja en tu flujo de trabajo actual:
- Slack: el agente comparte los hallazgos en el canal del equipo de guardia.
- PagerDuty y ServiceNow: cuando entra un incidente, el agente puede arrancar la investigación solo, sin que nadie se lo pida. Esta es la pieza que te faltaba si querías el flujo totalmente automático.
- GitHub y GitLab: correlaciona incidentes con despliegues recientes. Algo como "esto empezó 4 minutos después del último merge a main".
- Todo lo demás, vía MCP: si tu herramienta no está en la lista (Jira, por ejemplo), puedes conectarla a través de un servidor MCP.
En este lab no probé ninguna integración, así que esto viene de la documentación de AWS, no de mi experiencia.
La integración con el repositorio es la que más me interesa, porque la mayoría de los incidentes de producción nacen de un cambio. Tener esa correlación automática te ahorra la pregunta más repetida del on-call: "¿qué se tocó justo antes de que esto empezara?".
Limitaciones
Esto no te lo digo para asustarte, sino para que sepas dónde poner el ojo. Y varias las viví en el lab:
-
Lo automático hay que armarlo. Una alarma en
ALARMno dispara sola la investigación: la inicias tú desde el chat, o conectas PagerDuty, ServiceNow o un webhook. Ojo con esto si esperabas un agente totalmente hands-off desde el primer día. -
Ve solo lo que sus permisos le dejan ver. En mi investigación, el agente reportó un hallazgo etiquetado como
gap: "Acceso lambda:GetFunction denegado". Le faltaba un permiso para inspeccionar la Lambda a fondo. Investigó igual con otras fuentes, pero fue transparente sobre su límite. La lección: el agente rinde tanto como la telemetría y los permisos que le des. - No decide por ti en cambios. Propone la mitigación (en mi caso, hasta con pasos de prepare → apply → rollback), pero ejecutarla sigue siendo decisión humana. Incluso si activas las acciones del agente, cada cambio necesita tu aprobación. Y así debe ser.
- Depende de tu telemetría. Si no instrumentaste bien o no tienes métricas relevantes, el agente ve menos. Basura entra, basura sale.
Entonces, ¿reemplaza al SRE de guardia?
No. Y quien te diga lo contrario probablemente no ha estado de guardia. Lo que hace es quitarte esos primeros treinta o cuarenta minutos de trabajo forense para que llegues a decidir, no a buscar. El humano deja de ser quien encuentra la aguja en el pajar y pasa a ser quien valida el hallazgo y elige la acción. En un rol donde la fatiga de guardia es muy real, eso no es poca cosa.
Para cerrar
AWS DevOps Agent no promete un sistema que nunca falle. Promete que cuando falle, la investigación no empiece de cero. Mi recomendación: clona el repositorio del lab, móntalo en una cuenta de pruebas, provoca el incidente con la Lambda y compara cuánto tardarías tú en llegar al root cause frente a lo que el agente te entrega servido.















Top comments (0)