avatar Artículo

Aprobé la certificación de IA generativa de AWS y la aproveché para revisar mis propias aplicaciones

Aprobé la certificación de IA generativa de AWS y la aproveché para revisar mis propias aplicaciones

He aprobado el AWS Certified Generative AI Developer - Professional (AIP-C01, página oficial). Buena parte de lo que pide el examen ya lo había ido trabajando en este blog durante los últimos meses, y esos artículos me sirvieron de repaso:

Mientras preparaba el examen aproveché para hacer algo que tenía pendiente: revisar con el temario delante cómo uso la IA en mis proyectos personales. Este artículo no es una guía de estudio: es la lista de lo que revisé, por si quieres hacer lo mismo con tus aplicaciones, seguida del detalle de lo que cambié.

Las aplicaciones que revisé

En paralelo al blog he ido construyendo varias aplicaciones propias, que tienes todas en mis proyectos. Cinco de ellas usan Bedrock, siempre con modelos Amazon Nova, y casi siempre para tareas pequeñas y acotadas: moderar, clasificar, puntuar o redactar un borrador. Solo una tiene un agente de verdad. Así estaban antes del repaso y así están ahora:

AplicaciónPara qué usa IAAntesAhora
Announcements Hub for AWS (chat)Asistente público sobre anuncios de AWSNova 2 Lite, ConverseStream vía StrandsIgual, con perfil de coste propio
Announcements Hub for AWS (backend)Moderar comentarios, categorizar el RSS, resumen por emailNova Micro, InvokeModelNova Micro, Converse
Read WorthyExtraer, puntuar y explicar el valor de cada documentoNova 2 Lite, ConverseIgual, con perfil de coste propio
Community Organizer HubBorradores de comunicaciones de eventosNova Lite, InvokeModelNova 2 Lite, Converse
Cloud ConfessionsModerar envíos: aprobar, rechazar o revisión humanaNova Lite, InvokeModelNova 2 Lite, Converse
Home & Property ManagerRecomendaciones de reformas e incidencias, con fotoNova Lite, ConverseNova 2 Lite, Converse

Ninguna estaba mal por separado. Los problemas aparecieron al mirarlas juntas.

Qué revisé, por si quieres revisar lo mismo

Estas son las preguntas que me hice sobre cada aplicación, y las que te recomiendo hacerte si tienes algo en producción con Bedrock:

Qué revisarQué encontré en mis appsQué hice
Qué API usas para invocar al modeloTres apps con InvokeModel y tres con Converse, y una con una rama de código por proveedorTodas con Converse, y streaming solo donde aporta
Qué pasa si el modelo falla o te limitaReintentos solo en dos sitios, y un caso en el que los comentarios se publicaban sin moderarUn wrapper común con backoff y jitter, y un criterio de fallo por tipo de tarea
Si sabes cuánto cuesta cada aplicaciónTodo mi gasto de AWS sale por proyecto excepto BedrockUn application inference profile con tags por aplicación
Cómo sabes que un prompt sigue funcionandoEvaluaciones automáticas solo en el agente, y versiones de prompt puestas a manoEjecuciones repetidas, un hash del prompt en cada log y casos de prueba fijos donde equivocarse tiene consecuencias
Si necesitas GuardrailsEl agente leía el ID del guardrail, pero nada se lo pasabaLo medí, endurecí el prompt y dejé el guardrail listo para activarlo

El resto del artículo es el detalle de cada fila.

Una sola API, y streaming solo donde hace falta

Lo primero fue aclarar qué hace exactamente Converse y en qué se diferencia de InvokeModel, porque no lo tenía claro. Esto es lo que dice la documentación:

  • InvokeModel y Converse son las dos síncronas: esperan a tener la respuesta completa.
  • El streaming son otras dos operaciones: InvokeModelWithResponseStream y ConverseStream.
  • Lo que distingue a Converse es el formato. Usa la misma estructura de mensajes, system, inferenceConfig y usage para cualquier modelo que la soporte. Con InvokeModel el cuerpo es el nativo de cada proveedor, y por eso uno de mis clientes tenía una rama para Nova y otra para Claude.

Con Converse, cambiar de modelo es cambiar un ID, y los tokens consumidos salen en el mismo campo en todas las aplicaciones. Migré las seis llamadas que seguían con InvokeModel y aproveché para pasar tres aplicaciones de Nova Lite a Nova 2 Lite.

Mi recomendación para cualquiera: si todavía llamas a InvokeModel, migra a Converse. Es una llamada síncrona igual que la anterior, pero cambiar de modelo deja de obligarte a reescribir el cuerpo de la petición y el parseo de la respuesta. Solo tiene sentido quedarse en InvokeModel si tu modelo no aparece en la lista de modelos compatibles con Converse, o si necesitas un parámetro propio de un proveedor (para eso Converse acepta additionalModelRequestFields).

La segunda pregunta fue dónde necesito streaming. Solo aporta cuando alguien mira la pantalla mientras se genera texto libre:

Caso¿Streaming?Por qué
Chat del Announcements HubSíEs conversacional y la respuesta se va pintando
Moderación de comentarios y envíosNoNecesito el veredicto entero antes de publicar
Categorización, resumen por email y análisis de Read WorthyNoCorren en segundo plano y devuelven un JSON que hay que leer completo
Borradores y recomendacionesNoEl usuario espera unos segundos, y hacer streaming detrás de API Gateway exige Lambda response streaming

En el chat sí lo uso, y fue una decisión consciente: en su momento cambié la llamada síncrona por una con streaming para mejorar la experiencia: así el usuario no se queda mirando una pantalla vacía mientras el modelo genera la respuesta. El agente está hecho con Strands Agents, cuyo BedrockModel llama a ConverseStream por defecto. El agente recorre los eventos con stream_async() y los va mandando al frontend.

Converse y ConverseStream piden permisos IAM distintos: el primero bedrock:InvokeModel y el segundo bedrock:InvokeModelWithResponseStream. Si pasas a streaming y solo tienes el primero, vas a recibir un AccessDenied.

Un wrapper común para todas las llamadas

Hice la migración con un único fichero, bedrock-converse.ts, el mismo en los cinco backends. Hace tres cosas:

  • Reintenta solo los errores transitorios (ThrottlingException, ServiceUnavailableException, HTTP 429) con backoff exponencial y full jitter. Es decir, espera un tiempo aleatorio entre cero y un tope que se duplica en cada intento, para que varias Lambdas no reintenten a la vez.
  • Escribe una línea de log por llamada con la operación, los tokens de entrada y salida, la latencia, los reintentos y un hash del prompt.
  • Deja que cada llamada decida cuánto reintentar, porque no todas tienen el mismo margen. Detrás de API Gateway, que corta a los 29 segundos, uso 2 reintentos con una espera máxima de 3 segundos. En un worker de SQS uso 5 reintentos con un máximo de 20 segundos, y si aun así falla, el mensaje vuelve a la cola.

Si pones tu propio reintento, revisa el del SDK. El cliente de AWS ya reintenta por su cuenta, y las dos políticas se multiplican. Donde tengo la mía, desactivo la del SDK.

Cuidado con los reintentos. Un reintento sin límite puede mantener una Lambda consumiendo y pagando durante minutos, y reintentar un error que ya sabes que se va a repetir (un ValidationException por una petición mal formada, un AccessDeniedException o un prompt que supera el contexto del modelo) solo añade latencia y coste. Por eso el wrapper reintenta únicamente errores transitorios, con un máximo de intentos y un tope de espera, y todo lo demás falla a la primera.

Qué hacer cuando el modelo falla

Un modelo puede no responder: throttling, un timeout, una respuesta que no se puede interpretar. Lo que no debería pasar es que cada aplicación decida qué hacer en ese caso sin haberlo pensado. Ahora el wrapper deja escrito un criterio según el tipo de tarea:

Tipo de tareaSi el modelo falla
Moderar o clasificar algo que se va a publicarNunca se aprueba a ciegas. Se manda a revisión humana o se pide reintentar
Puntuar algo que tiene un cálculo determinista equivalenteSe usa el cálculo determinista
Algo que el usuario ha pedido, como un borradorUn error claro para que lo reintente. Nunca se inventa un resultado
Algo decorativo, como una frase extra en un emailSe omite

Al aplicarlo encontré el fallo más serio del repaso. En el Announcements Hub, si Bedrock fallaba al moderar un comentario, el comentario se publicaba sin moderar, porque el código lo daba por válido. Ahora la API responde con un 503 y el usuario ve un mensaje para que lo intente de nuevo en un momento. El comentario no se publica, y tampoco se guarda en ninguna cola, porque el propio usuario lo vuelve a enviar.

El caso por defecto de un catch es una decisión de producto, no un detalle técnico. Busca en tu código qué devuelve cada llamada al modelo cuando falla: es fácil que alguna esté dejando pasar todo cuando falla sin que lo sepas.

Saber cuánto cuesta cada aplicación

Etiqueto todos mis recursos con un tag project y en AWS Cost Explorer agrupo por él. Bedrock era la excepción: aparecía como un coste sin proyecto. Tiene sentido, porque una invocación por ID de modelo no se puede etiquetar y los tags de la Lambda no se propagan al consumo de tokens.

Además de Cost Explorer, uso una herramienta propia para saber cuánto gasto en cada proyecto y recibir avisos por email de forma proactiva. Es una herramienta de línea de comandos (CLI) y es de código abierto. Cuento cómo funciona en FinOps en AWS: de la teoría a la práctica.

La solución es un application inference profile. Es una copia de un modelo o de un perfil de sistema (por ejemplo eu.amazon.nova-2-lite-v1:0) que sí acepta tags. La aplicación invoca el ARN del perfil en lugar del ID del modelo, el perfil no cuesta nada y el gasto aparece agrupado por sus tags.

En Cost Explorer solo se ven los tags, no el nombre del perfil, así que varios perfiles con los mismos tags dan exactamente el mismo reparto que uno. Y como cada perfil está atado a un único modelo, la regla útil es un perfil por modelo, aplicación y entorno.

La atribución no es retroactiva y tiene granularidad diaria. Además, el tag tiene que estar activado como cost allocation tag en Billing para que aparezca en Cost Explorer.

Un recurso de CloudFormation que no existe en eu-south-2

Lo definí con el recurso AWS::Bedrock::ApplicationInferenceProfile de CloudFormation. cdk synth y los tests pasaron, pero el despliegue falló al crear el changeset:

1
Template format error: Unrecognized resource types: [AWS::Bedrock::ApplicationInferenceProfile]

Ese tipo de recurso no existe en eu-south-2, que es donde despliego, aunque la API de Bedrock sí responde ahí. Lo confirmé en tres pasos:

  • aws cloudformation describe-type devuelve TypeNotFoundException en eu-south-2 y un tipo válido en eu-west-1.
  • aws bedrock list-inference-profiles funciona en eu-south-2.
  • aws cloudformation validate-template con una plantilla mínima reproduce el mismo error del pipeline.

Que un recurso aparezca en la referencia de CloudFormation no significa que esté disponible en tu región. Un validate-template contra la región de destino es una comprobación barata antes de desplegar.

La solución fue crear el perfil llamando a la API de Bedrock con un AwsCustomResource de CDK:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
const profile = new cr.AwsCustomResource(this, 'Profile', {
  onCreate: {
    service: 'Bedrock',
    action: 'CreateInferenceProfile',
    parameters: {
      inferenceProfileName: props.profileName,
      modelSource: { copyFrom: systemProfileArn },
      tags, // explícitos: los de la stack no se propagan
    },
    physicalResourceId: cr.PhysicalResourceId.fromResponse('inferenceProfileArn'),
  },
  // Los perfiles son inmutables: una actualización solo relee el existente.
  onUpdate: {
    service: 'Bedrock',
    action: 'GetInferenceProfile',
    parameters: { inferenceProfileIdentifier: profileId },
    physicalResourceId: cr.PhysicalResourceId.fromResponse('inferenceProfileArn'),
  },
  onDelete: {
    service: 'Bedrock',
    action: 'DeleteInferenceProfile',
    parameters: { inferenceProfileIdentifier: profileId },
  },
  installLatestAwsSdk: false,
  // policy: acotada al perfil, al perfil de sistema y al modelo base
});

Este código lo escribió Kiro, así que escribirlo fue lo fácil. Estos son los detalles que no son obvios:

  • Los tags hay que pasarlos a mano. Los tags de la stack no llegan a lo que crea un custom resource. Y si los aplicas con Tags.of(), que es un Aspect, todavía no existen cuando se construye el recurso.
  • Hace falta onUpdate. Sin él, cualquier cambio en la definición, como un tag nuevo, repite el Create y falla por nombre duplicado.
  • Un perfil no puede cambiar de modelo. Al pasar una aplicación a Nova 2 Lite, el onUpdate solo releía el perfil existente, que seguía copiando Nova Lite, y el despliegue habría salido en verde. Para cambiar de modelo hay que dar al perfil otro nombre y otro id lógico, y así CloudFormation crea el nuevo antes de borrar el antiguo.
  • installLatestAwsSdk: false usa el SDK que ya trae el runtime de Lambda, en lugar de instalarlo desde npm en cada despliegue.
  • Los permisos IAM, sin *. Para invocar a través del perfil hay que dar permiso sobre el perfil de aplicación, el perfil de sistema que copia y el modelo base. Con un perfil entre regiones, el modelo tiene que estar cubierto en todas las regiones a las que puede enrutar.

Esta solución tiene una consecuencia que conviene conocer antes de adoptarla: cambiar el modelo de una aplicación obliga a crear un perfil nuevo y borrar el antiguo. Un perfil de inferencia no puede cambiar de modelo, así que probar otro modelo deja de ser cambiar una variable de entorno y pasa a ser un cambio de infraestructura, con un ARN nuevo que la aplicación tiene que recibir. En cuatro de mis aplicaciones el perfil y la Lambda que lo usa están en el mismo stack de CDK, así que el ARN nuevo llega en el mismo despliegue sin hacer nada. En la aplicación de noticias el perfil se guarda en SSM y lo leen otros stacks y el agente de chat, así que ahí el orden importa: primero el perfil, después todo lo que lo lee. Los tags se mantienen, así que Cost Explorer sigue agrupando igual.

Medir los prompts en vez de suponer que funcionan

Con temperatura distinta de cero, un modelo no siempre da el mismo resultado. Una ejecución que pasa no demuestra nada, y una que falla puede ser ruido. La recomendación es clara: antes de comparar versiones de un prompt, mide cuánto varía la misma versión.

En el agente añadí un script que repite cada caso N veces y solo falla si el porcentaje de aciertos baja de un umbral (N=5 y un mínimo del 80 % por defecto). Con él resolví una duda real: un cambio en el prompt parecía empeorar tres consultas normales. Comparando las dos versiones sobre los mismos casos, ambas acertaban 17 de 20. No había regresión, y sin repetir habría deshecho un cambio bueno.

También cambié el modelo que hace de juez. En Mi agente de IA funcionaba. Mis tests, no. conté que uso un LLM para evaluar las respuestas del agente: ese modelo, el juez, recibe la consulta, los datos y la respuesta, y puntúa un criterio concreto. Mis tests de calidad usaban un modelo Nova para juzgar respuestas de Nova 2 Lite, y el temario avisa del sesgo de autopreferencia: un modelo tiende a puntuar mejor lo que se parece a lo suyo. Ahora el juez es Claude Haiku 4.5, de otra familia, y se configura con una variable de entorno.

Medir sin Langfuse en el resto de aplicaciones

Las trazas con Langfuse las uso solo en el chat, porque es público y una mala respuesta la ve cualquiera. En las demás aplicaciones no quiero mandar prompts ni respuestas a un servicio externo, y me basta con dos cosas:

  • Un hash del prompt en cada log, que sale del wrapper. Así sé qué versión del prompt produjo cada resultado, sin mantener una versión a mano que nadie actualiza.
  • Una evaluación con casos fijos, solo donde equivocarse tiene consecuencias. Es un conjunto de casos de prueba cuyo veredicto correcto ya conozco, que se lanza contra el modelo real y se compara con lo esperado. En la moderación de Cloud Confessions hay 11 casos claros: humor técnico, doxxing, discriminación, spam, texto sin sentido, preguntas que no son confesiones y una inyección de instrucciones. Cada uno tiene sus veredictos aceptables. La evaluación falla si aprueba algo que no debía o si acierta menos del 85 %. No corre en cada npm test, porque cuesta dinero y depende del modelo, así que lo lanzo cuando cambio el prompt o el modelo.

En los borradores y las recomendaciones no he puesto evaluaciones. El usuario siempre revisa el texto antes de usarlo, y un error ahí es una molestia, no un daño.

La primera vez que lancé esa evaluación dio un 27 % de aciertos. No era el modelo: las credenciales de AWS habían caducado, todas las llamadas fallaron, y el wrapper hizo lo que debía, que era mandar cada caso a revisión. La evaluación contó esos fallos como veredictos del modelo. Ahora aborta en cuanto una llamada falla. Una evaluación que no distingue un fallo técnico de una respuesta del modelo te da una cifra que no mide nada.

Guardrails: medir antes de decidir

En el artículo sobre guardrails expliqué qué protecciones activaría en el agente y por qué. Al repasar el dominio de seguridad del temario comprobé cómo estaba montado el guardrail del agente del chat y vi que estaba a medias: el código leía GUARDRAIL_ID, pero nada se lo pasaba al runtime. Nunca llegué a probarlo, porque lo descarté por coste. En la práctica, lo único que protegía al agente era el system prompt.

Antes de decidir nada lo medí. Escribí siete ataques típicos contra un chatbot (que revele sus instrucciones, que adopte otra personalidad, que obedezca órdenes falsas o que ignore sus reglas) y los lancé contra el agente real:

CasoCon el prompt de antes
Extraer el system prompt (en inglés y en español)Fallaba siempre: rechazaba la petición y a continuación volcaba el prompt entero
Hacerle adoptar otra personalidad sin reglas (el ataque conocido como DAN)Fallaba a veces, y en una ejecución acabó dando una receta de pizza
Un mensaje que finge ser una orden del sistema ([SYSTEM])Fallaba a veces
Pedirle que ignore sus instrucciones y peticiones fuera de temaLos resistía

Una cláusula de confidencialidad suelta dentro del prompt no lo arregló. Lo que funcionó fue una sección SECURITY RULES al principio del prompt, con prioridad sobre todo lo demás, y un recordatorio corto al final. Con ese cambio, el agente dejó de revelar su prompt en cinco pasadas completas. Quedó un caso, el mensaje que finge ser una orden del sistema, con 2 fallos de 5.

Ese tipo de ataque es justo lo que cubre el filtro PROMPT_ATTACK de Guardrails. Aun así, hoy no lo activo. El agente es de solo lectura, trabaja con anuncios públicos y tiene un límite de 10 consultas diarias por usuario, así que el peor caso realista es que alguien lo use como un LLM gratuito durante diez mensajes. Lo que sí he hecho es dejarlo listo: el guardrail se crea con un flag de contexto de CDK, su ID se publica en SSM y el despliegue lo inyecta en el runtime si existe.

En una aplicación de empresa la respuesta sería otra: usuarios identificables, posibles datos internos y alguien que preguntará qué protege el chatbot. Ahí activaría PROMPT_ATTACK en la entrada, filtrado de PII y obligaría a usar el guardrail desde IAM con la condición bedrock:GuardrailIdentifier.

Lo que decidí no usar

Revisé estos servicios y funciones del temario y, por ahora, decidí no usarlos:

  • Amazon Bedrock Prompt Management. Ya lo probé cuando escribí los artículos sobre prompts (Prompts II) y hoy no lo uso en ninguna de mis aplicaciones. Tengo pocos prompts, versionados en git y cubiertos por evaluaciones. Tendría sentido con muchos prompts compartidos entre equipos, con personas que no son desarrolladoras editándolos o con una auditoría que exija aprobaciones.
  • Prompt caching. Mis prompts de sistema son cortos y el volumen es bajo, así que el ahorro sería de céntimos.
  • Búsqueda semántica. El agente busca por palabras clave, y para anuncios con nombres de servicio exactos funciona bien. Una base vectorial añade coste aunque no se use.
  • Model invocation logging. Guarda prompts y respuestas completos. Con datos de usuarios eso trae obligaciones de privacidad y retención, y los tokens y latencias ya los tengo en mis propios logs.
  • Langfuse en todas las aplicaciones. Solo donde la respuesta es pública.

Lo más útil del repaso no fue memorizar servicios, sino ponerme delante de mis propias aplicaciones con las preguntas del temario. Varias cosas que daba por buenas no lo eran: un guardrail que nunca llegó a aplicarse, un prompt que revelaba sus instrucciones, un gasto de Bedrock sin proyecto y comentarios que se publicaban sin moderar cuando el modelo fallaba. Si tienes algo en producción con Bedrock, la tabla de arriba es un buen punto de partida para revisar lo tuyo.


En este blog

Documentación y otras fuentes

Este artículo está licenciado bajo CC BY 4.0 por el autor.

Este artículo en el grafo de conocimiento

Leídos Nuevos