Mejores prácticas para aplicar Amazon Bedrock Guardrails a flujos de trabajo de generación de código

Esta publicación continúa nuestra serie sobre prácticas recomendadas con Amazon Bedrock Guardrails. Para la publicación anterior, consulte Cree aplicaciones de IA generativa seguras como un profesional: prácticas recomendadas con Amazon Bedrock Guardrails.

Los asistentes de codificación impulsados ​​por IA y los flujos de trabajo de generación de código, como Claude Code, Kiro y OpenAI Codex, están transformando la forma en que los desarrolladores escriben software. Estas herramientas generan código en tiempo real a través de respuestas en tiempo real, y a menudo producen miles de caracteres en sesiones prolongadas. A medida que las organizaciones adoptan flujos de trabajo de IA generativos con código a escala utilizando estos asistentes, es importante que los patrones de código inseguros se detecten y bloqueen cuando sea necesario. Amazon Bedrock Guardrails ayuda a detectar y filtrar contenido de código inseguro y no deseado con salvaguardas como filtros de contenido para moderación de contenido, prevención rápida de ataques con jailbreak, inyección rápida y fuga rápida, filtros de información confidencial para redactar y bloquear información de identificación personal (PII) y más.

Sin embargo, los flujos de trabajo de codificación junto con los bucles agentes tienen características de rendimiento únicas que incluyen salidas de transmisión largas, sesiones de desarrollador simultáneas y evaluación de contexto repetitiva. La aplicación de Amazon Bedrock Guardrails a flujos de trabajo con estas características sin la configuración adecuada podría generar limitaciones como errores de limitación, mayores costos y una latencia inferior a la óptima. En esta publicación, explicamos cómo se pueden configurar Amazon Bedrock Guardrails para flujos de trabajo de generación de código con asistentes de codificación para superar estas limitaciones. Con estas mejores prácticas, puede crear un plan eficiente que le ayude con una planificación de capacidad eficaz con una sólida cobertura de seguridad.

Por qué las barreras de seguridad son importantes para los flujos de trabajo de generación de código

Amazon Bedrock Guardrails ofrece protecciones integrales que detectan y filtran contenido dañino e indeseable tanto de las entradas de los usuarios como de las respuestas del modelo, para ayudar a crear aplicaciones de IA generativa seguras. Si bien estas medidas de seguridad se pueden configurar e implementar en una variedad de aplicaciones, existen medidas de seguridad específicas que se pueden utilizar para proteger patrones de código dañinos como:

Detecte ataques rápidos: bloquee los intentos de manipular el modelo para generar código malicioso o eludir instrucciones. Filtrar información confidencial: puede ayudar a bloquear o enmascarar información confidencial, como información de identificación personal (PII), expresiones regulares personalizadas en las entradas del usuario y respuestas del modelo, capturar claves de acceso de AWS codificadas, cadenas de conexión de bases de datos o claves privadas antes de que aparezcan en el código generado. Moderación de contenido: detecte y filtre contenido dañino en las indicaciones de los usuarios y modele las respuestas, incluido el contenido que viola las políticas de uso aceptable de su organización. Bloquear temas denegados: defina temas personalizados que se utilizan como base para bloquear conversaciones relacionadas con actividades prohibidas, como generar código para eludir mecanismos de autenticación o ayudar con patrones de acceso no autorizados.

Estas salvaguardas son esenciales cuando se utiliza código generado por IA en sistemas de producción.

Un escenario: cuando las buenas barandillas se desvían

Un equipo de sistemas de clientes acaba de implementar Claude Code en Amazon Bedrock para 15 desarrolladores. Han configurado una barrera de seguridad con tres salvaguardas: detección rápida de ataques para ayudar a prevenir la inyección, un filtro de información confidencial para redactar o bloquear credenciales filtradas y un filtro de contenido para bloquear patrones de código inseguros. Todo funcionó perfectamente durante el piloto con dos desarrolladores. Después de una prueba piloto exitosa, los 15 desarrolladores comienzan sus sesiones de codificación simultáneamente. En cuestión de minutos, su equipo comienza a informar errores: respuestas ThrottlingException de la inferencia del modelo de Amazon Bedrock. La finalización del código se detiene a mitad de camino. Los desarrolladores están frustrados y su canal Slack se ilumina.

¿Qué pasó? La sesión de cada desarrollador genera aproximadamente 5000 caracteres de código por función en promedio. Con la configuración de transmisión predeterminada, Amazon Bedrock evalúa las barreras de seguridad por cada 50 caracteres, lo que activa 100 llamadas API por función y por desarrollador. Multiplíquelo en 15 sesiones simultáneas y el sistema generará 1500 solicitudes de evaluación por segundo. Peor aún, debido a que tienen 3 salvaguardas activas, cada evaluación consume 3 unidades de texto en lugar de 1, lo que triplica el consumo de rendimiento.

La causa fundamental no fue una cuota insuficiente. Fue un desajuste arquitectónico. Aplicaron un patrón diseñado para intercambios conversacionales cortos a una canalización de generación de código de alto rendimiento. Esta publicación proporciona patrones arquitectónicos para resolver este problema.

Unidades de texto: la moneda de las barandillas

Antes de sumergirse en la arquitectura, es importante comprender cómo se calcula el consumo de guardarrail, porque es la clave para cada optimización posterior.

Una unidad de texto se define como 1000 caracteres en el texto. Una llamada a la API de ApplyGuardrail con 1000 caracteres de texto evaluados con 3 salvaguardas genera 3 unidades de texto de consumo.

Fundamentalmente, el consumo es multiplicativo. Se adapta tanto a la longitud del contenido como al número de salvaguardas activas.

Para los flujos de trabajo de generación de código donde los resultados suelen ser detallados (miles de caracteres por función), esta relación multiplicativa es un factor crítico en la planificación de la capacidad. Una barrera de seguridad configurada con filtros de contenido, temas denegados y filtros de información confidencial se mide según la cantidad de unidades de texto procesadas por cada protección o filtro.

Nota: Los filtros de contenido se cobran como una sola unidad de texto por cada 1000 caracteres, independientemente de cuántas categorías (Odio, Insultos, Sexual, Violencia, Mala conducta, Ataque inmediato) estén habilitadas dentro del filtro. Por ejemplo, si habilita las seis categorías de filtro de contenido, todavía cuenta como una unidad de texto, no seis. La relación multiplicativa se aplica a distintos tipos de políticas (filtros de contenido, temas denegados, filtros de información confidencial), no a través de categorías dentro de un solo tipo de política.

El desafío: los flujos de trabajo de generación de código podrían desencadenar una limitación

Los flujos de trabajo de IA conversacionales tradicionales implican indicaciones breves y discretas para el usuario y respuestas modelo. Los flujos de trabajo de generación de código difieren en formas que impactan directamente en la arquitectura de barrera:

La siguiente tabla muestra por qué los flujos de trabajo de generación de código son especialmente exigentes:

Característica Generación de código de IA conversacional Longitud de salida 100-500 caracteres 5000-50 000+ caracteres Duración de la sesión Un solo turno o algunos turnos Sesiones extendidas de varios turnos Usuarios simultáneos Generalmente, asíncronos Teams codifican simultáneamente Reutilización del contexto Mínimo Las indicaciones del sistema, las definiciones de herramientas y el código anterior se presentan en cada turno Salida intermedia Mínimo Razonamiento en cadena de pensamiento extenso

Estas diferencias significan que un enfoque de escaneo en línea, donde las barreras de seguridad evalúan cada fragmento de salida transmitida a medida que se genera, crea un volumen de evaluaciones que es desproporcionado con respecto al valor de seguridad real entregado.

Mejores prácticas: patrones de arquitectura para flujos de trabajo de generación de código

Para abordar estos desafíos, recomendamos un conjunto de patrones de arquitectura que optimicen el uso de barreras de seguridad para los flujos de trabajo de generación de código. Cada patrón apunta a un aspecto específico del problema, desde reducir la frecuencia de evaluación hasta escanear selectivamente solo contenido de alto riesgo. Puede aplicar estos patrones individualmente o combinarlos según las características de su carga de trabajo y los requisitos de seguridad.

Patrón de arquitectura 1: el modelo de gancho previo a la confirmación

Comprender el escaneo en línea: el enfoque predeterminado

Cuando adjuntas barreras de seguridad directamente a la invocación del modelo usando guardrailConfig con las API Converse o InvokeModel, estás usando lo que se conoce como escaneo en línea. En este modo, Amazon Bedrock Guardrails evalúa automáticamente tanto el mensaje de entrada completo como la salida de transmisión en función de las salvaguardas activas de forma continua, en tiempo real, a medida que se generan los tokens. Para la IA conversacional tradicional, este enfoque funciona bien: las indicaciones son breves, las respuestas son concisas y la sobrecarga de evaluación es insignificante.

Pero para los flujos de trabajo de generación de código, el escaneo en línea se convierte en una sobrecarga ineficiente. Agrega costos y consume cuota sin mejorar significativamente su postura de seguridad. Un asistente de codificación no produce sólo una respuesta breve. Transmite miles de caracteres de código, intercalados con razonamientos, comentarios y refinamientos iterativos. Con la evaluación en línea activa, cada parte de esa salida se analiza con respecto a cada protección configurada, incluido el mensaje estático del sistema y el contexto generado previamente que no ha cambiado desde la última evaluación. El resultado es un trabajo redundante: las mismas instrucciones repetitivas, definiciones de herramientas e historial de conversaciones anteriores se reevalúan turno tras turno, consumiendo unidades de texto sin agregar valor de seguridad.

La mejor práctica principal es pasar del escaneo continuo en línea a la validación selectiva en puntos de control estratégicos, de manera análoga a un gancho de confirmación previa en un flujo de trabajo de Git. En lugar de escanear cada token a medida que se transmite, valide el contenido en límites bien definidos donde cambia el perfil de riesgo.

Por qué funciona el pensamiento de “gancho previo al compromiso”

Los desarrolladores de software no ejecutan linters, formateadores ni escáneres de seguridad después de cada línea que escriben. Se validan en el momento de la confirmación. No validan cada edición intermedia, cada línea eliminada o cada función a medio escribir, sino que validan el resultado final en el momento que importa.

En un flujo de trabajo de Git, un enlace de confirmación previa es un script que se ejecuta automáticamente en un límite específico y bien definido: en el momento en que intenta enviar código a su repositorio. Es la última puerta antes de que los cambios pasen a formar parte del código base compartido. En este punto de control, ejecuta sus validaciones y pruebas todas a la vez, contra el artefacto final que está a punto de persistir.

Este patrón funciona porque equilibra dos necesidades en competencia: minuciosidad (cada cambio comprometido se valida completamente) y eficiencia (la validación solo ocurre cuando el perfil de riesgo cambia, a medida que el código pasa de "borrador en progreso" a "artefacto en proceso de persistencia").

Aplicar el patrón a Amazon Bedrock Guardrails

La mejor práctica principal es aplicar este mismo principio a Amazon Bedrock Guardrails: pasar del escaneo continuo en línea a la validación selectiva en puntos de control estratégicos.

Piense en su canal de generación de código como si tuviera puntos de confirmación naturales, momentos en los que el contenido pasa de un nivel de confianza a otro:

Entrada del usuario recibida: el contenido ingresa a su sistema desde una fuente no confiable (valide aquí). Artefacto de código final ensamblado: la respuesta completa del modelo está lista para ser presentada o guardada (valídela aquí). Código escrito en un archivo o enviado al repositorio: el contenido generado por IA está a punto de volverse persistente y potencialmente ejecutable (valídelo aquí).

Entre estos puntos de control, mientras el modelo razona, genera tokens intermedios o produce explicaciones en cadena de pensamientos, el contenido es efímero. No ha cruzado un límite de confianza. Escanearlo continuamente agrega costos y consume cuota sin mejorar significativamente su postura de seguridad.

Principio clave: utilice la API ApplyGuardrail desacoplada para evaluar las entradas proporcionadas por el usuario antes de que lleguen al modelo y valide los artefactos de código final agregados antes de que se confirmen, no todos los tokens de razonamiento intermedios.

Implementación: validación previa a la confirmación para operaciones de archivos

Para el punto de control de mayor riesgo, cuando el código generado por IA está a punto de escribirse en un archivo o enviarse a un repositorio, realice una evaluación integral de las barreras de seguridad. Este es el patrón de gancho previo a la confirmación aplicado directamente:

import hashlib from pathlib import Path class CodeCommitGuardrail: """ Valida todos los cambios de código generados por IA antes de que persistan. Análogo a ejecutar escáneres de seguridad en un gancho de confirmación previa de Git. Úselo cuando: – Un asistente de codificación escribe código en el disco – Los cambios generados por IA se preparan para su confirmación – El código generado está a punto de implementarse """ def __init__(self, client, guardrail_id, guardrail_version): self.client = client self.guardrail_id = guardrail_id self.guardrail_version = guardrail_version self.validated_hashes = {} # Caché: no volver a validar archivos sin cambios def validar_file_changes(self, staged_files: dict) -> dict: """ Evaluar todos los cambios en el código preparado por IA antes de confirmar. Args: staged_files: Dict of {file_path: file_content} para todos los cambios archivos Devuelve: Dict con booleano 'seguro' y cualquier infracción encontrada """ violaciones =[]omitido =[]para file_path, contenido en staged_files.items(): # Omitir archivos que no han cambiado desde la última validación content_hash = hashlib.sha256(content.encode()).hexdigest() if self.validated_hashes.get(file_path) == content_hash: skipped.append(file_path) continue # Evaluar en fragmentos alineados de 1000 caracteres file_violations = self._evaluate_file(file_path, content) if file_violations: violaciones.extend(file_violations) else: # Caché de validación exitosa self.validated_hashes[file_path] = content_hash return { 'safe': len(violations) == 0, 'violations': violaciones, 'files_evaluated': len(staged_files) – len(skipped), 'files_skipped_cached': len(skipped) } def _evaluate_file(self, file_path: str, content: str) -> list: """Evaluar el contenido de un solo archivo según las barreras de seguridad.""" violaciones =[]para desplazamiento en rango (0, len (contenido), 1000): fragmento = contenido [desplazamiento: desplazamiento + 1000] respuesta = self.client.apply_guardrail (guardrailIdentifier = self.guardrail_id, guardrailVersion = self.guardrail_version, fuente = "SALIDA", contenido = [{'text': {'text': fragmento}}]) si respuesta ['acción'] == 'GUARDRAIL_INTERVENED': violaciones.append({ 'file': file_path, 'offset': offset, 'length': len(chunk), 'evaluaciones': respuesta['evaluaciones'], 'snippet': fragment[:200] + '…' if len(chunk) > 200 else fragment }) return violaciones # Ejemplo: Integración con la definición de operación de escritura de archivos de un asistente de codificación write_ai_generated_code(file_path: str, content: str, guardrail: CodeCommitGuardrail): """ Contenedor para escrituras de archivos que valida el contenido antes de persistir. """ resultado = guardrail.validate_file_changes({file_path: content}) si no resulta['safe']: print(f"Guardrail bloqueó la escritura en {file_path}") for v in result['violations']: print(f" Violación en el desplazamiento {v['offset']}: {v['evaluaciones']}") return False # Es seguro escribir Ruta(file_path).write_text(content) print(f"{file_path} validado y escrito correctamente") return True

Patrón de arquitectura 2: aumentar el intervalo de transmisión a 1000 caracteres

Cuando necesite una evaluación de transmisión en tiempo real, por ejemplo, sesiones de codificación interactivas en las que desee detener la generación inmediatamente después de detectar una infracción, optimice el intervalo de transmisión. Aumentar el intervalo de la barrera de seguridad de los 50 caracteres predeterminados a 1000 caracteres puede reducir el volumen de llamadas API en 20 veces. Vea la siguiente configuración:

# Cuando se usa InvokeModelWithResponseStream con guardrails respuesta = bedrock_runtime.invoke_model_with_response_stream( modelId='anthropic.claude-sonnet-4-20250514', body=json.dumps(request_body), guardrailIdentifier="your-guardrail-id", guardrailVersion='1', # Configuración clave: aumentar el intervalo de transmisión streamingConfigurations={ 'guardrailStreamingInterval': 1000 # ¡El valor predeterminado es 50} )

Impacto: Una función de 5.000 caracteres pasa de 100 valoraciones a 5. Un archivo de 50.000 caracteres pasa de 1.000 valoraciones a 50.

Patrón de arquitectura 3: utilice la API ApplyGuardrail desacoplada para una evaluación selectiva

Con la API ApplyGuardrail independiente, puede utilizar Amazon Bedrock Guardrails independientemente del modelo de base. Puede evaluar texto sin invocar el modelo básico.

Patrón: validación de solo entrada con inferencia no protegida

Cuando su principal preocupación es evitar la inyección rápida y bloquear entradas maliciosas, valide solo el contenido dinámico del usuario antes de que llegue al modelo. En ese caso, invoque el modelo sin barandillas en línea:

import boto3 import json bedrock_runtime = boto3.client('bedrock-runtime') def Process_coding_request(user_input: str, system_prompt: str, conversation_history: list): """ Valide la entrada del usuario con barandillas, luego invoque el modelo sin escaneo en línea. El indicador del sistema y el historial de conversaciones NO se reevalúan en cada turno. """ # Paso 1: Evaluar SÓLO la nueva entrada dinámica del usuario guardrail_response = bedrock_runtime.apply_guardrail( guardrailIdentifier="your-guardrail-id", guardrailVersion='1', source="INPUT", content=[ { 'text': { 'text': user_input # Solo el contenido nuevo, no el mensaje completo } } ] ) if guardrail_response['action'] == 'GUARDRAIL_INTERVENED': return { 'blocked': True, 'mensaje': guardrail_response['salidas'][0]['text'], 'assessments': guardrail_response['assessments'] } # Paso 2: Es seguro continuar – invocar el modelo SIN barandillas en línea # El mensaje del sistema y el historial omiten los mensajes de evaluación redundantes = conversion_history + [{'role': 'user', 'content': user_input}] respuesta = bedrock_runtime.converse( modelId='anthropic.claude-sonnet-4-20250514', mensajes=messages, system=[{'text': system_prompt}] # Nota: No hay guardrailConfig aquí; ya hemos validado la entrada) return { 'bloqueado': Falso, 'respuesta': respuesta['salida']['mensaje']['contenido'][0]['texto'] }

Por qué esto es importante para los flujos de trabajo de codificación: en una sesión de codificación típica, el mensaje del sistema (a menudo entre 2000 y 5000 caracteres de definiciones e instrucciones de herramientas) y el historial de conversaciones (que crece con cada turno) se reenvían en cada invocación. Con la evaluación en línea, este contenido estático se vuelve a escanear en cada turno. Con el enfoque desacoplado, se evalúa solo el mensaje de usuario de ~200 caracteres que realmente cambió.

Patrón: validación de solo salida al finalizar

Cuando necesite escanear el código generado en busca de información confidencial (credenciales filtradas, secretos codificados) pero confíe en que la entrada del usuario sea benigna (por ejemplo, herramientas internas de desarrollo detrás de la autenticación), valide solo el resultado final:

def generate_and_validate_code(user_input: str, system_prompt: str): """ Genera código sin barreras de seguridad en línea y luego valida el resultado completo. Ideal para detectar secretos, PII o patrones inseguros en el código generado. """ # Paso 1: Generar código sin barreras de seguridad en línea respuesta general = bedrock_runtime.converse( modelId='anthropic.claude-sonnet-4-20250514', mensajes=[{'role': 'usuario', 'contenido': user_input}], sistema=[{'text': system_prompt}] ) código_generado = respuesta['salida']['mensaje']['contenido'][0]['text'] # Paso 2: Validar el artefacto de código COMPLETO, no fragmentos intermedios guardrail_response = bedrock_runtime.apply_guardrail( guardrailIdentifier="your-guardrail-id", guardrailVersion='1', source="OUTPUT", content=[ { 'text': { 'text': generate_code } } ] ) if guardrail_response['action'] == 'GUARDRAIL_INTERVENED': return { 'bloqueado': Verdadero, 'mensaje': 'El código generado contiene contenido confidencial que fue bloqueado.', 'evaluaciones': guardrail_response['evaluaciones'] } return { 'bloqueado': Falso, 'código': código_generado }

Patrón: Validación bidireccional con alcance selectivo

Para obtener la máxima cobertura, valide las entradas para ataques de inyección y las salidas para contenido confidencial y, al mismo tiempo, evite la sobrecarga del escaneo en línea:

def Secure_code_generación_pipeline(user_input: str, system_prompt: str, historial: list): """ Validación bidireccional completa sin sobrecarga de escaneo en línea. Entrada: Verificar inyección/manipulación rápida Salida: Verificar secretos filtrados y patrones inseguros """ # Paso 1: Validar la entrada para inyección rápida input_check = bedrock_runtime.apply_guardrail( guardrailIdentifier="your-guardrail-id", guardrailVersion='1', fuente="INPUT", content=[{'text': {'text': user_input}}]) if input_check['action'] == 'GUARDRAIL_INTERVENED': return {'blocked': True, 'stage': 'input', 'motivo': input_check['outputs'][0]['text']} # Paso 2: Generar código – no se necesitan barreras de seguridad en línea mensajes = historial + [{'role': 'user', 'content': user_input}] respuesta = bedrock_runtime.converse( modelId='anthropic.claude-sonnet-4-20250514', mensajes=messages, system=[{'text': system_prompt}] ) generate_code = respuesta['salida']['mensaje']['contenido'][0]['text'] # Paso 3: Validar la salida para información confidencial output_check = bedrock_runtime.apply_guardrail( guardrailIdentifier="your-guardrail-id", guardrailVersion='1', source="OUTPUT", content=[{'text': {'text': generate_code}}] ) if output_check['action'] == 'GUARDRAIL_INTERVENED': return {'blocked': True, 'stage': 'salida', 'motivo': salida_check['salidas'][0]['text']} return {'bloqueado': Falso, 'código': código_generado}

Patrón de arquitectura 4: salida por lotes a límites alineados de unidades de texto

Dado que un fragmento de 600 caracteres todavía cuesta una unidad de texto completo (1000 caracteres), siempre haga lotes en múltiplos de 1000 caracteres para evitar el desperdicio de unidades parciales:

import asyncio class GuardrailBatcher: """Acumula salida de streaming y evalúa en límites de 1000 caracteres.""" def __init__(self, client, guardrail_id, guardrail_version): self.client = client self.guardrail_id = guardrail_id self.guardrail_version = guardrail_version self.buffer = "" self.BATCH_SIZE = 1000 # Alinear con el límite de TextUnit asíncrono def Process_chunk(self, chunk: str): """Buffer fragments y evaluar cuando alcanzamos un límite de TextUnit.""" self.buffer += chunk while len(self.buffer) >= self.BATCH_SIZE: # Extrae exactamente 1000 caracteres para evaluación lote = self.buffer[:self.BATCH_SIZE] self.buffer = self.buffer[self.BATCH_SIZE:] respuesta = self.client.apply_guardrail( guardrailIdentifier=self.guardrail_id, guardrailVersion=self.guardrail_version, source="OUTPUT", content=[{'text': {'text': lote}}] ) if respuesta['action'] == 'GUARDRAIL_INTERVENED': rise GuardrailViolation(response) async def flush(self): """Evaluar cualquier contenido restante al final de la transmisión.""" if self.buffer: respuesta = self.client.apply_guardrail( guardrailIdentifier=self.guardrail_id, guardrailVersion=self.guardrail_version, source="OUTPUT", content=[{'text': {'text': self.buffer}}] ) self.buffer = "" devolver respuesta

Patrón de arquitectura 5: profundidad de evaluación basada en riesgos

No todo el código generado conlleva el mismo riesgo. El código que afecta a las políticas, los secretos o la autenticación de IAM merece un análisis más exhaustivo que el código de diseño de la interfaz de usuario. Implemente una profundidad de evaluación adaptativa basada en señales de contenido:

import re class RiskBasedGuardrail: """ Ajusta la estrategia de evaluación de la barrera de seguridad según el perfil de riesgo del código que se genera. Código de alto riesgo: evaluación completa con todas las salvaguardas Código estándar: evaluación ligera (solo información confidencial) Código de bajo riesgo: omitir evaluación intermedia; validar solo en la confirmación """ # Patrones que indican código de alto riesgo HIGH_RISK_PATTERNS = [ r'iam[_.]', # Manipulación de políticas de IAM r'(access_key|secret_key|password)', # Manejo de credenciales r'(exec|eval|subprocess|os.system)', # Ejecución de código r'(BEGIN.*PRIVATE KEY)', # Claves criptográficas r'(security_group|nacl|firewall)', # Seguridad de red r'(grant|revoke|permission)', # Autorización r'(encrypt|decrypt|kms)', # Operaciones de cifrado ] # Patrones que indican código de bajo riesgo LOW_RISK_PATTERNS = [ r'(.css|style|className|fontSize)', # Estilo r'(render|component|jsx|tsx)', # Componentes de UI r'(test|spec|mock|fixture)', # Archivos de prueba r'(README|docs|comment)', # Documentación ] def __init__(self, client, guardrail_id_full, guardrail_id_lightweight): self.client = client self.guardrail_id_full = guardrail_id_full # Todas las salvaguardas activas self.guardrail_id_lightweight = guardrail_id_lightweight # Solo información confidencial def classify_risk(self, code: str, file_path: str = "") -> str: """Determinar el nivel de riesgo del código generado.""" combinado = código + " " + file_path para el patrón en self.HIGH_RISK_PATTERNS: si re.search(patrón, combinado, re.IGNORECASE): devuelve 'ALTO' para el patrón en self.LOW_RISK_PATTERNS: si re.search(patrón, combinado, re.IGNORECASE): devuelve 'BAJO' devuelve 'ESTÁNDAR' def evalua(self, código: str, file_path: str = "") -> dict: """ Evalúa el código con la profundidad adecuada según la clasificación de riesgo. """ Risk_level = self.classify_risk(code, file_path) if Risk_level == 'LOW': # Bajo riesgo: aplazar la validación en el momento de la confirmación return { 'action': 'PASS', 'risk_level': 'LOW', 'evaluación': 'deferred_to_commit', 'reason': 'Contenido clasificado como de bajo riesgo (UI/tests/docs)' } # Elija barandilla según el riesgo guardrail_id = ( self.guardrail_id_full if Risk_level == 'HIGH' else self.guardrail_id_lightweight ) respuesta = self.client.apply_guardrail( guardrailIdentifier=guardrail_id, guardrailVersion='1', source="OUTPUT", content=[{'text': {'text': code}}] ) return { 'acción': respuesta ['acción'], 'nivel_riesgo': nivel_riesgo, 'evaluación': 'completa' si nivel_riesgo == 'ALTO' else 'ligero', 'evaluaciones': respuesta.get('evaluaciones',[]) } # Ejemplo: uso de la evaluación basada en riesgos en un proceso de codificación Risk_guardrail = RiskBasedGuardrail( client=bedrock_runtime, guardrail_id_full="guardrail-all-safeguards", guardrail_id_lightweight="guardrail-SENSITIVE-INFO-only" )
# Alto riesgo: código de política de IAM → evaluación completa (3 salvaguardas) # ADVERTENCIA: El siguiente es un ejemplo de un antipatrón INSEGURO utilizado aquí # únicamente para demostrar la detección de barreras de seguridad. Nunca utilice permisos comodín # (Acción: '*', Recurso: '*') en producción. Siga siempre el principio de #mínimo privilegio. Consulte: https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege iam_code = """ Policy = iam.create_policy( PolicyName="AdminAccess", PolicyDocument=json.dumps({ 'Declaración': [{'Efecto': 'Permitir', 'Acción': '*', 'Recurso': '*'}] }) ) """ resultado = Risk_guardrail.evaluate(iam_code, "deploy/iam_policies.py") # → nivel_riesgo: ALTO, evaluación: completo # Riesgo bajo: Componente React → diferido para confirmar ui_code = """ función Botón({ etiqueta, onClick }) { return {etiqueta} } """ resultado = Risk_guardrail.evaluate(ui_code, "src/components/Button.tsx") # → nivel_riesgo: BAJO, evaluación: deferred_to_commit

Patrón de arquitectura 6: canalización de agentes de varias etapas

Los flujos de trabajo de codificación agente (donde el modelo utiliza herramientas, razona en múltiples pasos y produce resultados intermedios) requieren una estrategia de evaluación diferente a la generación de un solo turno:

clase AgentPipelineGuardrail: """ Arquitectura Guardrail para flujos de trabajo de codificación agentic de varios pasos. Información clave: en un bucle de agente, el modelo puede tomar de 5 a 10 pasos de razonamiento (llamadas a herramientas, observaciones, reflexiones) antes de producir el código final. Evaluar cada paso intermedio es un desperdicio: la mayoría contiene razonamiento interno que nunca llega al usuario o al sistema de archivos. Estrategia: – ENTRADA: Validar la solicitud del usuario antes de que comience el agente – INTERMEDIO: Omitir la cadena de pensamiento y el uso de herramientas razonamiento – ENTRADAS DE HERRAMIENTA: Validar cuando el agente escribe en un archivo o ejecuta código – SALIDA FINAL: Valida la respuesta completa mostrada al usuario """ def __init__(self, client, guardrail_id, guardrail_version): self.client = cliente self.guardrail_id = guardrail_id self.guardrail_version = guardrail_version def run_agent_with_guardrails(self, user_request: str, agente): """ Ejecute un flujo de trabajo de codificación agente con colocación estratégica de barreras de seguridad. """ # Puerta 1: valide la entrada del usuario ANTES de que el agente comience a trabajar input_check = self._evaluate(user_request, 'INPUT') if input_check['action'] == 'GUARDRAIL_INTERVENED': return {'blocked': True, 'stage': 'input', 'response': input_check} # Ejecute el agente – SIN evaluación de barreras durante el razonamiento. pasos agente_pasos =[]final_output = Ninguno para el paso en agent.run(user_request): if step['type'] == 'thinking': # Saltar: el razonamiento interno no necesita evaluación agent_steps.append(step) continuar elif step['type'] == 'tool_call': # Puerta 2: Validar SÓLO las entradas de herramientas peligrosas if self._is_dangerous_tool(step['tool_name']): tool_check = self._evaluate( json.dumps(paso['tool_input']), 'SALIDA' ) if tool_check['action'] == 'GUARDRAIL_INTERVENED': return { 'bloqueado': Verdadero, 'etapa': f"tool_call:{step['tool_name']}", 'respuesta': tool_check } agent_steps.append(paso) elif paso['tipo'] == 'respuesta_final': salida_final = paso['contenido'] # Puerta 3: Validar la salida final antes de mostrársela al usuario if salida_final: salida_check = self._evaluate(salida_final, 'SALIDA') if salida_check['acción'] == 'GUARDRAIL_INTERVENED': return {'bloqueado': Verdadero, 'etapa': 'salida', 'respuesta': salida_check} return { 'bloqueado': Falso, 'salida': salida_final, 'pasos_tomados': len(pasos_agente), 'pasos_evaluados': suma( 1 para s en pasos_agente si s['tipo'] == 'llamada_herramienta' y self._is_dangerous_tool(s.get('nombre_herramienta', '')) ) } def _is_dangerous_tool(self, nombre_herramienta: str) -> bool: """Herramientas que escriben al disco o ejecutar código necesita evaluación de barandilla.""" herramientas_peligrosas = { 'write_file', 'execute_code', 'run_command', 'create_file', 'edit_file', 'bash' } return nombre_herramienta en herramientas_peligrosas def _evaluate(self, content: str, source: str) -> dict: return self.client.apply_guardrail( guardrailIdentifier=self.guardrail_id, guardrailVersion=self.guardrail_version, fuente=fuente, contenido=[{'texto': {'texto': contenido}}])

El marco de decisión completo

La siguiente tabla muestra el marco de decisión para varios puntos de control:

Punto de control Qué validar Cómo impacta la unidad de texto Entrada del usuario (cada turno) Solo contenido de usuario dinámico ApplyGuardrail (fuente=ENTRADA) Bajo: solo se evalúa el contenido nuevo Salida de transmisión Contenido activo a medida que se transmite Establezca el intervalo en 1000 caracteres Reducción potencial de 20 veces en comparación con la opción predeterminada Respuesta completada Artefacto de código agregado final ApplyGuardrail (fuente=SALIDA) Pase completo de una sola vez Confirmación previa/guardado de archivos Cambios de código generados por IA ApplyGuardrail (fuente=SALIDA) Completo pero llamadas poco frecuentes a herramientas del agente Solo herramientas peligrosas (escribir/ejecutar) ApplyGuardrail (fuente=SALIDA) Dirigido: omitir herramientas benignas Razonamiento intermedio Omitir por completo No evaluar tokens CoT Cero

Conclusiones clave

Cambie del escaneo en línea a la evaluación selectiva: utilice la API desacoplada ApplyGuardrail para controlar exactamente qué se escanea y cuándo. Evalúe en los límites de confianza, no continuamente. Establezca el intervalo de transmisión en 1000 caracteres: cuando se necesita una evaluación de transmisión, este único cambio puede ofrecer una reducción de hasta 20 veces en la frecuencia de evaluación. Evalúe solo contenido dinámico: no vuelva a evaluar las indicaciones del sistema, las definiciones de herramientas y el historial de conversaciones en cada momento. Utilice el almacenamiento en caché basado en hash para el contenido que debe reevaluarse. Aplique una evaluación profunda basada en riesgos: analice las políticas de IAM y el código de manejo de credenciales con las salvaguardas. Posponga el escaneo de componentes de la interfaz de usuario para comprometer el tiempo. Omitir tokens de razonamiento intermedio: en flujos de trabajo agentes, evalúe solo cuando el contenido cruce un límite de confianza (entrada del usuario, llamadas a herramientas peligrosas, resultado final). Lote hasta límites de 1000 caracteres: un fragmento de 600 caracteres cuesta lo mismo que 1000 caracteres. Alinee sus evaluaciones con los límites de las unidades de texto para reducir el desperdicio. Vigile el límite de confirmación: como un gancho de confirmación previa de Git, realice una validación integral cuando el código generado por IA esté a punto de volverse persistente y ejecutable.

Conclusión

En esta publicación, propusimos prácticas recomendadas para optimizar los flujos de trabajo de generación de código asistidos por IA con Amazon Bedrock Guardrails. Aquí está el resumen general sobre cómo puede implementar Guardrails de manera efectiva para sus flujos de trabajo de codificación.

Audite su configuración actual: abra la consola de Amazon Bedrock y revise sus barreras de seguridad existentes. Verifique la configuración del intervalo de transmisión. Si no lo ha cambiado de los 50 caracteres predeterminados, está dejando sobre la mesa una ganancia potencial de eficiencia de 20 veces. Verifique las cuotas de su cuenta: antes de escalar sus flujos de trabajo de codificación, verifique sus límites reales asignados en la consola de cuotas de servicio de AWS. No asuma que se aplican los valores predeterminados publicados, especialmente para las cuentas más nuevas. Consulte la documentación de cuotas y puntos de enlace de Amazon Bedrock para conocer los límites regionales más recientes. Implemente la API de ApplyGuardrail desacoplada: pase de la evaluación en línea a la validación selectiva utilizando la API de ApplyGuardrail. Revise la documentación Configurar el comportamiento de respuesta de transmisión para ajustar su intervalo de transmisión. Explore el conjunto completo de funciones de Guardrails: profundice en la documentación de Amazon Bedrock Guardrails para obtener información sobre filtros de contenido, temas denegados, detección de información confidencial y cómo crear y modificar guardrails para su caso de uso.

Sobre los autores

Sandeep Singh

Sandeep Singh

Sandeep es científico senior de datos de IA generativa en AWS y ayuda a grandes empresas a innovar con IA generativa. Se especializa en IA generativa, IA agente, aprendizaje automático y diseño de sistemas, y ofrece soluciones basadas en IA/ML para resolver problemas comerciales complejos en diversas industrias.

Denis Batalov

Denis Batalov

Como veterano de Amazon con 21 años de experiencia y doctorado en Aprendizaje Automático, Denis trabajó en proyectos interesantes como Search Inside the Book, aplicaciones móviles de Amazon y Kindle Direct Publishing. Desde 2013, ha ayudado a los clientes de AWS a adoptar la tecnología AI/ML como arquitecto de soluciones. Actualmente, Denis lidera un equipo que ayuda a los clientes a crear aplicaciones Gen AI con Amazon Bedrock y también se concentra personalmente en promover la práctica de la IA responsable contribuyendo a los esfuerzos de estandarización de ISO y la UE en ese espacio. Denis es un orador público frecuente; Puedes seguirlo en LinkedIn.

Shyam Srinivasan

Shyam Srinivasan

Shyam Srinivasan es director principal de productos del equipo de Amazon Bedrock. Le preocupa hacer del mundo un lugar mejor a través de la tecnología y le encanta ser parte de este viaje. En su tiempo libre, a Shyam le gusta correr largas distancias, viajar alrededor del mundo y experimentar nuevas culturas con familiares y amigos.

Antonio Rodríguez

Antonio es arquitecto principal de soluciones especializado en IA generativa en Amazon Web Services. Ayuda a empresas de todos los tamaños a resolver sus desafíos, adoptar la innovación y crear nuevas oportunidades comerciales con Amazon Bedrock. Además del trabajo, le encanta pasar tiempo con su familia y hacer deporte con sus amigos.