Azure AI Foundry Verantwoordelijke AI-vangrails: een complete implementatiehandleiding

in azure ai-implementaties in gereguleerde sectoren, is het patroon vaak hetzelfde: het team perfectioneert de rag-pipeline, de vector store en de streaming ui – en levert vervolgens zonder vangrails. dit was altijd al een riskante zet, maar met de eu ai-wet die nu van kracht is, is de risicoberekening permanent veranderd. wat ooit een 'leuk-om-te-hebben' was, is nu een harde compliance-vereiste voor elke serieuze bedrijfs-llm-applicatie.

het bouwen van productieklare llm-applicaties gaat niet alleen over het krijgen van het juiste antwoord; het gaat over het garanderen van het veilige en verantwoordelijke antwoord. organisaties, met name die in de financiële sector, de gezondheidszorg en de publieke sector in heel europa, worstelen met modelhallucinaties, prompt-injectieaanvallen, het genereren van schadelijke inhoud en inbreuk op intellectueel eigendom. dit zijn geen abstracte risico's; ze vertalen zich direct in boetes van regelgevende instanties, reputatieschade en een volledig verlies van gebruikersvertrouwen.

deze gids biedt een uitgebreide, code-first aanpak voor het bouwen van een robuuste responsible ai-veiligheidslaag op azure. we zullen verder gaan dan marketingconcepten en ons verdiepen in concrete engineeringcontroles met behulp van twee complementaire paden: de stand-alone azure ai content safety analyse-api voor snelle, beleidsgestuurde screening op schadelijke inhoudscategorieën (en optionele jailbreak-achtige signalen via shield_prompt op die api), en azure openai service voor controles op implementatieniveau – prompt shields, groundedness detection en protected material detection – die u inschakelt en leest uit de azure openai voltooiingsrespons, niet alleen uit contentsafetyclient. ik zal u laten zien hoe u deze samenstelt tot één, modulaire fastapi-middlewareketen, de hele stack met terraform voorziet en elke vangrail koppelt aan de bijbehorende verplichting onder de eu ai-wet.

dit is het hoofdartikel voor onze serie 'responsible ai-vangrails met azure ai foundry'. het introduceert alle belangrijke vangrails met stand-alone, kopieer-en-plak-codevoorbeelden en linkt naar toegewijde 'spoke'-artikelen voor nog diepere duiken.

wanneer ik deze systemen op azure architecteer, behandel ik llm-veiligheid niet als één component. het is een gelaagd, diepgaand verdedigingsmodel. het kernidee is om een reeks controles te implementeren – sommige voordat de llm ooit wordt aangeroepen, sommige nadat deze een antwoord heeft gegenereerd – om ervoor te zorgen dat zowel gebruikersinvoer als modeluitvoer voldoen aan onze vooraf gedefinieerde veiligheidsbeleidsregels. het is een pijplijn van vertrouwen.

onze architectuur gebruikt twee belangrijke azure-services, samengesteld in een specifieke volgorde:

1. azure ai content safety: een stand-alone, krachtige service die we gebruiken als eerste verdedigingslinie. via contentsafetyclient.analyze_text scoort het gebruikersinvoer op basis van schadelijke inhoudscategorieën (haat, seksueel, geweld, zelfbeschadiging) en kan het jailbreak- / indirecte aanvalssignalen genereren wanneer shield_prompt is ingeschakeld – voordat de tekst de dure llm bereikt.
2. azure openai service: de llm en de filters op implementatieniveau. prompt shields (gebruikers-promptaanvallen), groundedness en protected material zijn geïntegreerd met deze service: u configureert ze voor de implementatie en interpreteert de annotaties die worden geretourneerd in de azure openai api-respons samen met de voltooiing.

het onderstaande diagram illustreert deze gelaagde stroom van gebruikersaanvraag tot definitieve, veilige applicatierespons.

dit componeerbare model, dat we als fastapi-middleware zullen implementeren, is krachtig omdat het omgevingsspecifieke configuraties mogelijk maakt. uw dev-omgeving kan permissieve drempels hebben voor testen, terwijl uw production-omgeving vergrendeld en zeer veilig blijft.

voordat we een regel code schrijven, laten we onze omgeving instellen. dit is de standaard toolkit die ik gebruik voor al mijn azure-gebaseerde ai-projecten.

• azure cli: zorg ervoor dat de cli is geïnstalleerd en dat u bent geverifieerd bij het juiste azure-abonnement.

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

• terraform cli: we gebruiken terraform voor declaratieve infrastructuurprovisioning. ik gebruik versie 1.5+, maar elke recente versie zou moeten werken.

terraform --version

• python 3.12+: onze applicatielaag is uitsluitend gebouwd met python. ik sta erop om voor elk project een virtuele omgeving te gebruiken om afhankelijkheden schoon te beheren.

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

• vereiste python-pakketten: installeer de benodigde azure sdk's, fastapi voor onze weblaag en een paar hulpprogramma's.

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"

• omgevingsvariabelen: we gebruiken omgevingsvariabelen voor configuratie. maak een .env-bestand aan in de hoofdmap van uw project. defaultazurecredential zal deze gebruiken voor lokale ontwikkeling en naadloos overschakelen naar managed identity in 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"

nu onze omgeving gereed is, gaan we de benodigde cloudinfrastructuur inrichten.

eerst en vooral: we moeten de azure-resources aanmaken. ik gebruik terraform hiervoor om ervoor te zorgen dat onze infrastructuur herhaalbaar, versiebeheerd en gedocumenteerd is als code. we zullen alles in francecentral provisioneren. die regio staat op de huidige lijst van microsoft waar groundedness detection (gegrondheidsdetectie) beschikbaar is (naast regio's zoals east us en canada east); verschillende aangrenzende eu-regio's staan niet op die lijst, dus het kiezen van een ondersteunde regio voorkomt stille fouten wanneer u gegrondheid in code inschakelt.

deze configuratie zal aanmaken: 1. een resourcegroep om onze services te bevatten. 2. een azure machine learning workspace, die fungeert als onze ai foundry hub. 3. een zelfstandig azure ai content safety-account. 4. een azure openai-account met een gpt-4o-implementatie. 5. de benodigde role assignment om de ml-workspace toegang te geven tot de openai-service.

hier is het complete main.tf-bestand:

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

voer terraform init, terraform plan en terraform apply uit om deze resources aan te maken. kopieer de uitvoerwaarden naar uw .env-bestand wanneer dit voltooid is.

nu zullen we elke vangrail implementeren als een afzonderlijk onderdeel in python. deze modulaire aanpak maakt het systeem gemakkelijker te testen, te onderhouden en te configureren.

nu brengen we alles samen. een fastapi-middleware is de perfecte plek om deze keten van vangrails te orkestreren. hiermee kunnen we elke inkomende aanvraag naar ons chat-eindpunt onderscheppen, onze veiligheidscontroles toepassen en de respons wijzigen of blokkeren voordat deze de gebruiker ooit bereikt.

deze implementatie definieert een responsibleaimiddleware-klasse die onze pre- en post-processinglogica uitvoert.

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

met deze opstelling wordt elke aanvraag naar /chat/invoke automatisch door onze volledige veiligheidspijplijn geleid. dit is een schone, schaalbare en niet-intrusieve manier om responsible ai-beleid in uw applicatie af te dwingen.

voor organisaties in europa is de meest dringende vraag: "hoe helpt dit mij om te voldoen aan de eu ai-wet?" het antwoord is dat deze technische controles direct overeenkomen met specifieke wettelijke verplichtingen. het bouwen van deze veiligheidslaag is niet alleen goede engineering; het is een kerncomponent van uw compliancestrategie.

hier ziet u hoe elke vangrail aansluit bij belangrijke artikelen van de wet voor hoogrisico ai-systemen:

het in productie nemen van een ruwe llm, vooral in een gereguleerde sector, is geen haalbare optie meer. de risico's van schadelijke inhoud, catastrofale hallucinaties en prompt-injectieaanvallen zijn te groot, en het regelgevingslandschap, geleid door de eu ai-wet, eist concrete, aantoonbare controles.

we hebben een compleet, in de praktijk getest patroon doorlopen voor het bouwen van een meerlaagse verdediging. door azure ai content safety te combineren voor snelle invoerscans en gebruik te maken van de diep geïntegreerde filters van azure openai voor geavanceerde bedreigingen zoals jailbreaks en ongegrondheid, kunt u een robuuste, conforme en betrouwbare ai-applicatie bouwen. het fastapi-middlewarepatroon dat ik heb getoond, biedt een flexibele en schaalbare manier om dit beleid centraal af te dwingen, zodat uw llm veilig opereert binnen de vangrails die u definieert.

mijn aanbeveling in de praktijk: probeer niet de oceaan leeg te koken. begin met twee vangrails: azure ai content safety op alle gebruikersinvoer met conservatieve drempels, en groundedness detection op alle rag-gebaseerde uitvoer. deze twee controles alleen al zullen meer dan 80% van de veelvoorkomende veiligheids- en kwaliteitsproblemen in bedrijfsimplementaties beperken. schakel vervolgens azure openai prompt shields in op de implementatie en voeg protected material detection toe naargelang het risicoprofiel van uw applicatie.

actie ondernemen volgende stap: neem de fastapi-middlewarecode uit deze gids en integreer deze in een nieuwe branch van uw bestaande llm-applicatie. configureer deze met soepele drempels en implementeer deze in een staging-omgeving. begin met het verzamelen van logs over wat het markeert en blokkeert. deze gegevens zullen van onschatbare waarde zijn voor het verfijnen van uw beleid voordat u het in productie afdwingt. zo gaat u van theorie naar een tastbaar, enterprise-grade veiligheidssysteem.