Azure AI Foundry Guardrails IA responsable : un guide d'implémentation complet

dans les déploiements d'ia azure dans les industries réglementées, et le modèle est souvent le même : l'équipe réussit le pipeline rag, le magasin de vecteurs et l'interface utilisateur de streaming, puis livre sans aucune protection. cela a toujours été une décision risquée, mais avec la loi européenne sur l'ia désormais en vigueur, cela a modifié de façon permanente le calcul des risques. ce qui était autrefois un « plus » est désormais une exigence de conformité stricte pour toute application llm d'entreprise sérieuse.

bâtir des applications llm de qualité production ne consiste pas seulement à obtenir la bonne réponse ; il s'agit de garantir une réponse sûre et responsable. les organisations, en particulier celles de la finance, des soins de santé et du secteur public en europe, sont confrontées aux hallucinations de modèles, aux attaques par injection de prompt, à la génération de contenu préjudiciable et à la violation de la propriété intellectuelle. ce ne sont pas des risques abstraits ; ils se traduisent directement par des amendes réglementaires, une atteinte à la réputation et une perte totale de confiance des utilisateurs.

ce guide propose une approche complète, axée sur le code, pour construire une couche de sécurité ia responsable robuste sur azure. nous dépasserons les concepts marketing pour nous plonger dans des contrôles d'ingénierie concrets utilisant deux chemins complémentaires : l'api d'analyse autonome azure ai content safety pour un filtrage rapide des catégories de contenu préjudiciable basé sur des politiques (et des signaux de type jailbreak optionnels via shield_prompt sur cette api), et azure openai service pour les contrôles au niveau du déploiement – prompt shields, groundedness detection et protected material detection – que vous activez et lisez à partir de la réponse de complétion azure openai, et non uniquement de contentsafetyclient. je vais vous montrer comment les composer en une seule chaîne de middleware fastapi modulaire, provisionner l'ensemble de la pile avec terraform et associer chaque garde-fou à son obligation correspondante en vertu de la loi européenne sur l'ia.

c'est l'article pilier de notre série « garde-fous ia responsable avec azure ai foundry ». il présente tous les garde-fous clés avec des exemples de code autonomes à copier-coller et renverra à des articles spécialisés pour des approfondissements encore plus poussés.

quand j'architecte ces systèmes sur azure, je ne traite pas la sécurité des llm comme un seul composant. c'est un modèle de défense en profondeur en couches. l'idée centrale est de mettre en œuvre une séquence de vérifications — certaines avant que le llm ne soit appelé, certaines après qu'il génère une réponse — pour garantir que les entrées de l'utilisateur et les sorties du modèle respectent nos politiques de sécurité prédéfinies. c'est un pipeline de confiance.

notre architecture utilise deux services azure clés, composés dans un ordre spécifique :

1. azure ai content safety : un service autonome et performant que nous utilisons comme première ligne de défense. via contentsafetyclient.analyze_text, il évalue l'entrée de l'utilisateur par rapport aux catégories de contenu préjudiciable (haine, contenu sexuel, violence, auto-mutilation) et peut déclencher des signaux de jailbreak / attaque indirecte lorsque shield_prompt est activé — avant que le texte n'atteigne le llm coûteux.
2. azure openai service : le llm et ses filtres au niveau du déploiement. prompt shields (attaques de prompt utilisateur), groundedness et protected material sont intégrés à ce service : vous les configurez pour le déploiement et interprétez les annotations renvoyées dans la réponse de l'api azure openai en même temps que la complétion.

le diagramme ci-dessous illustre ce flux en couches depuis la demande de l'utilisateur jusqu'à la réponse finale et sécurisée de l'application.

ce modèle composable, que nous implémenterons en tant que middleware fastapi, est puissant car il permet des configurations spécifiques à l'environnement. votre environnement dev peut avoir des seuils permissifs pour les tests, tandis que votre environnement production reste verrouillé et hautement sécurisé.

avant d'écrire une ligne de code, configurons notre environnement. c'est la boîte à outils standard que j'utilise pour tous mes projets ia basés sur azure.

• azure cli : assurez-vous que la cli est installée et que vous êtes authentifié sur l'abonnement azure correct.

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

• terraform cli : nous utiliserons terraform pour le provisionnement déclaratif de l'infrastructure. j'utilise la version 1.5+, mais toute version récente devrait fonctionner.

terraform --version

• python 3.12+ : notre couche d'application est construite exclusivement avec python. j'insiste pour utiliser un environnement virtuel pour chaque projet afin de gérer les dépendances proprement.

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

• packages python requis : installez les sdk azure nécessaires, fastapi pour notre couche web, et quelques utilitaires.

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 d'environnement : nous utilisons des variables d'environnement pour la configuration. créez un fichier .env à la racine de votre projet. defaultazurecredential les utilisera pour le développement local et basculera de manière transparente vers managed identity dans 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"

avec notre environnement prêt, provisionnons l'infrastructure cloud dont nous avons besoin.

tout d'abord : nous devons créer les ressources azure. j'utilise terraform pour cela afin de garantir que notre infrastructure est reproductible, versionnée et documentée sous forme de code. nous provisionnerons tout dans francecentral. cette région figure sur la liste actuelle de microsoft où la détection d'ancrage (groundedness detection) est disponible (à côté de régions telles que east us et canada east) ; plusieurs régions adjacentes à l'ue ne figurent pas sur cette liste, de sorte que le choix d'une région prise en charge évite les échecs silencieux lorsque vous activez l'ancrage dans le code.

cette configuration créera : 1. un groupe de ressources pour contenir nos services. 2. un espace de travail azure machine learning, qui agit comme notre hub ia foundry. 3. un compte autonome azure ai content safety. 4. un compte azure openai avec un déploiement gpt-4o. 5. l'affectation de rôle nécessaire pour permettre à l'espace de travail ml d'accéder au service openai.

voici le fichier main.tf complet :

# 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
}

exécutez terraform init, terraform plan et terraform apply pour créer ces ressources. une fois terminé, copiez les valeurs de sortie dans votre fichier .env.

maintenant, nous allons implémenter chaque garde-fou comme un composant distinct en python. cette approche modulaire rend le système plus facile à tester, à maintenir et à configurer.

maintenant, nous allons tout assembler. un middleware fastapi est l'endroit idéal pour orchestrer cette chaîne de garde-fous. il nous permet d'intercepter chaque requête entrante vers notre point de terminaison de chat, d'appliquer nos vérifications de sécurité et de modifier ou de bloquer la réponse avant qu'elle n'atteigne l'utilisateur.

cette implémentation définit une classe responsibleaimiddleware qui exécute notre logique de pré-traitement et de post-traitement.

# 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)

avec cette configuration, toute requête à /chat/invoke passe automatiquement par l'ensemble de notre pipeline de sécurité. c'est un moyen propre, évolutif et non intrusif d'appliquer les politiques d'ia responsable dans toute votre application.

pour les organisations en europe, la question la plus pressante est : « comment cela m'aide-t-il à me conformer à la loi européenne sur l'ia ? » la réponse est que ces contrôles techniques correspondent directement à des obligations légales spécifiques. la construction de cette couche de sécurité n'est pas seulement une bonne ingénierie ; c'est un élément essentiel de votre stratégie de conformité.

voici comment chaque garde-fou s'aligne sur les articles clés de la loi pour les systèmes d'ia à haut risque :

l'envoi d'un llm brut dans un environnement de production, en particulier dans une industrie réglementée, n'est plus une option viable. les risques de contenu préjudiciable, d'hallucinations catastrophiques et d'attaques par injection de prompt sont trop importants, et le paysage réglementaire, dirigé par la loi européenne sur l'ia, exige des contrôles concrets et démontrables.

nous avons parcouru un modèle complet et testé sur le terrain pour construire une défense multi-couches. en composant azure ai content safety pour un balayage rapide des entrées et en tirant parti des filtres profondément intégrés d'azure openai pour les menaces avancées comme les jailbreaks et le manque d'ancrage, vous pouvez construire une application ia robuste, conforme et digne de confiance. le modèle de middleware fastapi que j'ai présenté offre un moyen flexible et évolutif d'appliquer ces politiques de manière centralisée, garantissant que votre llm fonctionne en toute sécurité dans les garde-fous que vous définissez.

ma recommandation sur le terrain : n'essayez pas de tout faire d'un coup. commencez par deux garde-fous : azure ai content safety sur toutes les entrées utilisateur avec des seuils conservateurs, et la détection de l'ancrage sur toutes les sorties basées sur rag. ces deux contrôles à eux seuls atténueront plus de 80 % des problèmes courants de sécurité et de qualité dans les déploiements d'entreprise. à partir de là, activez les azure openai prompt shields sur le déploiement et ajoutez la détection de matériel protégé selon le profil de risque de votre application.

prochaine étape actionnable : prenez le code du middleware fastapi de ce guide et intégrez-le dans une nouvelle branche de votre application llm existante. configurez-le avec des seuils indulgents et déployez-le dans un environnement de staging. commencez à collecter des journaux sur ce qu'il signale et bloque. ces données seront inestimables pour affiner vos politiques avant de les appliquer en production. c'est ainsi que vous passez de la théorie à un système de sécurité tangible de qualité entreprise.