Azure AI Foundry Barreras de protección de IA responsable: una guía de implementación completa

en las implementaciones de ia de azure en industrias reguladas, el patrón suele ser el mismo: el equipo domina la pipeline rag, el almacén de vectores y la ui de streaming, y luego se lanza sin barreras de protección. esto siempre fue un movimiento arriesgado, pero con la ley de ia de la ue ahora en vigor, ha cambiado el cálculo de riesgos de forma permanente. lo que antes era un 'deseable' es ahora un requisito de cumplimiento estricto para cualquier aplicación llm empresarial seria.

construir aplicaciones llm de grado de producción no se trata solo de obtener la respuesta correcta; se trata de garantizar la respuesta segura y responsable. las organizaciones, particularmente las de finanzas, atención médica y el sector público en toda europa, están lidiando con alucinaciones de modelos, ataques de inyección de prompt, la generación de contenido dañino y la infracción de la propiedad intelectual. estos no son riesgos abstractos; se traducen directamente en multas regulatorias, daños a la reputación y una pérdida total de la confianza del usuario.

esta guía proporciona un enfoque integral, centrado en el código, para construir una capa de seguridad de ia responsable robusta en azure. iremos más allá de los conceptos de marketing y nos sumergiremos en controles de ingeniería concretos utilizando dos rutas complementarias: la api de análisis independiente azure ai content safety para una detección rápida y basada en políticas de categorías de daño (y señales opcionales tipo jailbreak a través de shield_prompt en esa api), y azure openai service para controles a nivel de implementación – prompt shields, groundedness detection y protected material detection – que usted habilita y lee de la respuesta de finalización de azure openai, no solo de contentsafetyclient. le mostraré cómo componerlos en una única cadena de middleware fastapi modular, aprovisionar toda la pila con terraform y mapear cada barrera de protección a su obligación correspondiente según la ley de ia de la ue.

este es el artículo principal de nuestra serie 'barreras de protección de ia responsable con azure ai foundry'. presenta todas las barreras de protección clave con ejemplos de código independientes, que se pueden copiar y pegar, y enlaza con artículos específicos para inmersiones aún más profundas.

cuando diseño estos sistemas en azure, no trato la seguridad de llm como un componente único. es un modelo de defensa en profundidad por capas. la idea central es implementar una secuencia de comprobaciones —algunas antes de que se llame al llm, otras después de que genere una respuesta— para garantizar que tanto las entradas del usuario como las salidas del modelo cumplan con nuestras políticas de seguridad predefinidas. es una tubería de confianza.

nuestra arquitectura utiliza dos servicios clave de azure, compuestos en un orden específico:

1. azure ai content safety: un servicio independiente de alto rendimiento que utilizamos como primera línea de defensa. a través de contentsafetyclient.analyze_text, puntúa la entrada del usuario contra categorías de daño (odio, sexual, violencia, autolesión) y puede generar señales de jailbreak / ataque indirecto cuando shield_prompt está habilitado — antes de que el texto llegue al costoso llm.
2. azure openai service: el llm y sus filtros a nivel de implementación. prompt shields (ataques de prompt de usuario), groundedness y protected material están integrados con este servicio: los configura para la implementación e interpreta las anotaciones devueltas en la respuesta de la api de azure openai junto con la finalización.

el siguiente diagrama ilustra este flujo en capas desde la solicitud del usuario hasta la respuesta de aplicación final y segura.

este modelo componible, que implementaremos como un middleware fastapi, es potente porque permite configuraciones específicas del entorno. su entorno dev puede tener umbrales permisivos para las pruebas, mientras que su entorno production permanece bloqueado y altamente seguro.

antes de escribir una línea de código, configuremos nuestro entorno. esta es la caja de herramientas estándar que uso para todos mis proyectos de ia basados en azure.

• azure cli: asegúrese de tener la cli instalada y de estar autenticado en la suscripción de azure correcta.

az login
az account set --subscription "your-azure-subscription-id"

• terraform cli: usaremos terraform para el aprovisionamiento declarativo de infraestructura. estoy usando la versión 1.5+, pero cualquier versión reciente debería funcionar.

terraform --version

• python 3.12+: nuestra capa de aplicación se construye exclusivamente con python. insisto en usar un entorno virtual para cada proyecto para gestionar las dependencias de forma limpia.

python3.12 -m venv .venv
source .venv/bin/activate
python3.12 --version

• paquetes python requeridos: instale los sdk de azure necesarios, fastapi para nuestra capa web y algunas utilidades.

pip install "azure-ai-contentsafety==1.0.0b2" "azure-identity>=1.15.0" "fastapi>=0.110.0" "uvicorn[standard]>=0.29.0" "python-dotenv>=1.0.0" "openai>=1.23.0"

• variables de entorno: usamos variables de entorno para la configuración. cree un archivo .env en la raíz de su proyecto. defaultazurecredential las usará para el desarrollo local y cambiará sin problemas a managed identity en azure.

# .env file
AZURE_TENANT_ID="your-tenant-id"
AZURE_CLIENT_ID="your-service-principal-app-id"
AZURE_CLIENT_SECRET="your-service-principal-password"
AZURE_SUBSCRIPTION_ID="your-azure-subscription-id"

# Endpoints from Terraform output
AZURE_CONTENT_SAFETY_ENDPOINT="https://your-content-safety-resource.cognitiveservices.azure.com/"
AZURE_OPENAI_ENDPOINT="https://your-aoai-resource.openai.azure.com/"

# Azure OpenAI Configuration
AZURE_OPENAI_API_VERSION="2024-05-01-preview"
AZURE_OPENAI_DEPLOYMENT_NAME="gpt-4o-demo"

con nuestro entorno listo, aprovisionemos la infraestructura en la nube que necesitamos.

primero lo primero: necesitamos crear los recursos de azure. uso terraform para esto para garantizar que nuestra infraestructura sea repetible, con control de versiones y documentada como código. aprovisionaremos todo en francecentral. esa región está en la lista actual de microsoft donde la detección de fundamentación (groundedness detection) está disponible (junto con regiones como east us y canada east); varias regiones adyacentes a la ue no están en esa lista, por lo que elegir una región compatible evita fallos silenciosos cuando se habilita la fundamentación en el código.

esta configuración creará: 1. un grupo de recursos para contener nuestros servicios. 2. un espacio de trabajo de azure machine learning, que actúa como nuestro centro de ia foundry. 3. una cuenta independiente de azure ai content safety. 4. una cuenta de azure openai con una implementación de gpt-4o. 5. la asignación de roles necesaria para permitir que el espacio de trabajo ml acceda al servicio openai.

aquí está el archivo main.tf completo:

# main.tf
terraform {
  required_providers {
    azurerm = {
      source  = "hashicorp/azurerm"
      version = ">=3.90.0"
    }
  }
}

provider "azurerm" {
  features {}
}

data "azurerm_client_config" "current" {}

resource "azurerm_resource_group" "rg" {
  name     = "rg-ai-foundry-guardrails-francecentral"
  location = "francecentral"
}

# 1. AI Foundry Hub (Azure AI Workspace)
resource "azurerm_machine_learning_workspace" "ai_foundry_hub" {
  name                = "mlw-aifoundry-hub-frc"
  location            = azurerm_resource_group.rg.location
  resource_group_name = azurerm_resource_group.rg.name
  sku_name            = "Premium" # Premium SKU for advanced features

  identity {
    type = "SystemAssigned"
  }

  tags = {
    environment = "production"
    project     = "AI_Foundry_Guardrails"
  }
}

# 2. Standalone Content Safety Service
resource "azurerm_cognitive_account" "content_safety" {
  name                = "cogs-contentsafety-guardrails-frc"
  location            = azurerm_resource_group.rg.location
  resource_group_name = azurerm_resource_group.rg.name
  kind                = "ContentSafety"
  sku_name            = "S0"

  tags = {
    environment = "production"
    project     = "AI_Foundry_Guardrails"
  }
}

# 3. Azure OpenAI Service Account
resource "azurerm_cognitive_account" "openai" {
  name                = "cogs-openai-guardrails-frc"
  location            = azurerm_resource_group.rg.location
  resource_group_name = azurerm_resource_group.rg.name
  kind                = "OpenAI"
  sku_name            = "S0"
}

# 4. Azure OpenAI Deployment (e.g., GPT-4o)
resource "azurerm_cognitive_deployment" "gpt4o" {
  name                 = "gpt-4o-demo" # This must match your AZURE_OPENAI_DEPLOYMENT_NAME env var
  cognitive_account_id = azurerm_cognitive_account.openai.id
  model {
    format  = "OpenAI"
    name    = "gpt-4o"
    version = "2024-05-13"
  }
  scale {
    type = "Standard"
  }
}

# 5. RBAC: Granting the ML workspace access to OpenAI
resource "azurerm_role_assignment" "mlw_to_openai" {
  scope                = azurerm_cognitive_account.openai.id
  role_definition_name = "Cognitive Services OpenAI User"
  principal_id         = azurerm_machine_learning_workspace.ai_foundry_hub.identity[0].principal_id
}

# Outputs for our .env file
output "content_safety_endpoint" {
  description = "Endpoint for the Azure AI Content Safety service."
  value       = azurerm_cognitive_account.content_safety.endpoint
}

output "openai_endpoint" {
  description = "Endpoint for the Azure OpenAI service."
  value       = azurerm_cognitive_account.openai.endpoint
}

ejecute terraform init, terraform plan y terraform apply para crear estos recursos. una vez completado, copie los valores de salida en su archivo .env.

ahora implementaremos cada barrera de protección como un componente distinto en python. este enfoque modular hace que el sistema sea más fácil de probar, mantener y configurar.

ahora, unamos todo. un middleware fastapi es el lugar perfecto para orquestar esta cadena de barreras de protección. nos permite interceptar cada solicitud entrante a nuestro endpoint de chat, aplicar nuestras comprobaciones de seguridad y modificar o bloquear la respuesta antes de que llegue al usuario.

esta implementación define una clase responsibleaimiddleware que ejecuta nuestra lógica de preprocesamiento y posprocesamiento.

# main.py
import os
import json
from fastapi import FastAPI, Request, Response, HTTPException
from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
from starlette.responses import JSONResponse

from azure.ai.contentsafety.models import TextCategory
from services.content_safety_service import PreemptiveContentSafety
from services.openai_service import GuardedOpenAIService

# --- App and Service Initialization ---
app = FastAPI(
    title="Secure AI Chat API",
    description="An API for chat completions with Responsible AI guardrails."
)

safety_service = PreemptiveContentSafety()
openai_service = GuardedOpenAIService()

# --- Middleware Configuration ---
# In a real app, load this from a config file or env vars
PROD_HARM_THRESHOLDS = {
    TextCategory.HATE: 2,
    TextCategory.SEXUAL: 2,
    TextCategory.VIOLENCE: 2,
    TextCategory.SELF_HARM: 4,
}

class ResponsibleAIMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request: Request, call_next: RequestResponseEndpoint) -> Response:
        if not request.url.path == "/chat/invoke":
            return await call_next(request)

        try:
            body = await request.json()
            user_prompt = body.get("prompt")
            if not user_prompt:
                return JSONResponse(status_code=400, content={"detail": "'prompt' field is required."})
        except json.JSONDecodeError:
            return JSONResponse(status_code=400, content={"detail": "Invalid JSON body."})

        # === GUARDRAIL CHAIN: PRE-PROCESSING ===
        is_safe, analysis = await safety_service.analyze_input(user_prompt, PROD_HARM_THRESHOLDS)
        if not is_safe:
            raise HTTPException(status_code=400, detail={"error": "Input rejected by content safety filter", "details": analysis})

        # If input is safe, proceed to the actual endpoint
        response = await call_next(request)

        # === GUARDRAIL CHAIN: POST-PROCESSING ===
        if response.status_code == 200:
            response_body = b''
            async for chunk in response.body_iterator:
                response_body += chunk
            response_data = json.loads(response_body)

            safety_analysis = response_data.get("safety_analysis", {})

            # Check for protected material
            if safety_analysis.get('protected_material_text') or safety_analysis.get('protected_material_code'):
                # For this example, we block. You could also replace with a citation.
                raise HTTPException(status_code=400, detail={"error": "Response blocked due to protected material detection."})

            # Check for ungroundedness
            groundedness = safety_analysis.get('groundedness', {})
            if not groundedness.get('detected', True) or groundedness.get('score', 1.0) < 0.5:
                # Append a warning instead of blocking
                response_data['content'] += "\n\n[Warning: This response may contain information not present in the source documents and should be verified.]"
                response_data['safety_analysis']['warning'] = 'low_groundedness_score'
                return JSONResponse(content=response_data)

        return response

app.add_middleware(ResponsibleAIMiddleware)

# --- API Endpoint ---
@app.post("/chat/invoke")
async def invoke_chat(request: Request):
    """
    This endpoint is protected by the ResponsibleAIMiddleware.
    It expects a body with {'prompt': '...', 'documents': ['doc1', 'doc2']}
    """
    body = await request.json()
    user_prompt = body.get("prompt")
    documents = body.get("documents", [])

    # The middleware has already validated the prompt. Now call the LLM.
    result = await openai_service.get_grounded_completion(user_prompt, documents)

    if "error" in result:
        raise HTTPException(status_code=500, detail=result)

    return JSONResponse(content=result)

con esta configuración, cualquier solicitud a /chat/invoke pasa automáticamente por toda nuestra canalización de seguridad. esta es una forma limpia, escalable y no intrusiva de hacer cumplir las políticas de ia responsable en toda su aplicación.

para las organizaciones en europa, la pregunta más apremiante es: "¿cómo me ayuda esto a cumplir con la ley de ia de la ue?" la respuesta es que estos controles técnicos se corresponden directamente con obligaciones legales específicas. la construcción de esta capa de seguridad no es solo buena ingeniería; es un componente central de su estrategia de cumplimiento.

aquí se explica cómo cada barrera de protección se alinea con los artículos clave de la ley para los sistemas de ia de alto riesgo:

lanzar un llm en bruto a un entorno de producción, especialmente en una industria regulada, ya no es una opción viable. los riesgos de contenido dañino, alucinaciones catastróficas y ataques de inyección de prompt son demasiado grandes, y el panorama regulatorio, liderado por la ley de ia de la ue, exige controles concretos y demostrables.

hemos recorrido un patrón completo y probado en el campo para construir una defensa de varias capas. al componer azure ai content safety para un escaneo rápido de entradas y aprovechar los filtros profundamente integrados de azure openai para amenazas avanzadas como jailbreaks y falta de fundamentación, puede construir una aplicación de ia robusta, conforme y confiable. el patrón de middleware fastapi que he mostrado proporciona una forma flexible y escalable de aplicar estas políticas de forma centralizada, asegurando que su llm opere de forma segura dentro de las barreras de protección que defina.

mi recomendación de campo: no intente abarcar demasiado. empiece con dos barreras de protección: azure ai content safety en todas las entradas de usuario con umbrales conservadores, y detección de fundamentación (groundedness detection) en todas las salidas basadas en rag. solo estos dos controles mitigarán más del 80% de los problemas comunes de seguridad y calidad en las implementaciones empresariales. a partir de ahí, habilite azure openai prompt shields en la implementación y añada detección de material protegido según el perfil de riesgo de su aplicación.

siguiente paso accionable: tome el código del middleware fastapi de esta guía e intégrélo en una nueva rama de su aplicación llm existente. configúrelo con umbrales permisivos y despliéguelo en un entorno de staging. empiece a recopilar registros sobre lo que marca y bloquea. estos datos serán invaluables para ajustar sus políticas antes de aplicarlas en producción. así es como se pasa de la teoría a un sistema de seguridad tangible de nivel empresarial.