Azure AI Foundry Responsible AI Guardrails: Ein vollständiger Implementierungsleitfaden

in azure ai-bereitstellungen in regulierten industrien ist das muster oft dasselbe: das team beherrscht die rag-pipeline, den vektorspeicher und die streaming-ui – und liefert dann ohne schutzmaßnahmen aus. das war schon immer ein riskantes unterfangen, aber mit dem jetzt geltenden eu-ki-gesetz hat sich die risikoberechnung dauerhaft geändert. was einst ein „nice-to-have“ war, ist jetzt eine harte compliance-anforderung für jede ernsthafte enterprise llm-anwendung.

der bau von produktionsreifen llm-anwendungen geht nicht nur darum, die richtige antwort zu bekommen; es geht darum, die sichere und verantwortungsvolle antwort zu gewährleisten. organisationen, insbesondere in den bereichen finanzen, gesundheitswesen und öffentlicher sektor in ganz europa, kämpfen mit modellhalluzinationen, prompt-injection-angriffen, der generierung schädlicher inhalte und der verletzung von geistigem eigentum. dies sind keine abstrakten risiken; sie führen direkt zu behördlichen strafen, rufschädigung und einem vollständigen verlust des benutzervertrauens.

dieser leitfaden bietet einen umfassenden, code-first-ansatz zum aufbau einer robusten responsible ai-sicherheitsschicht auf azure. wir werden über marketingkonzepte hinausgehen und uns in konkrete engineering-kontrollen vertiefen, die zwei komplementäre pfade nutzen: die eigenständige azure ai content safety analyse-api für schnelles, richtlinienbasiertes screening von schadenskategorien (und optionalen jailbreak-artigen signalen über shield_prompt in dieser api) und azure openai service für kontrollen auf bereitstellungsebene – prompt shields, groundedness detection und protected material detection –, die sie aktivieren und aus der azure openai-vollständigkeitsantwort lesen, nicht nur aus contentsafetyclient. ich zeige ihnen, wie sie diese zu einer einzigen, modularen fastapi-middleware-kette zusammensetzen, den gesamten stack mit terraform bereitstellen und jede schutzmaßnahme ihrer entsprechenden verpflichtung gemäß dem eu-ki-gesetz zuordnen.

dies ist der säulenartikel für unsere serie „responsible ai-schutzmaßnahmen mit azure ai foundry“. er stellt alle wichtigen schutzmaßnahmen mit eigenständigen, kopierbaren codebeispielen vor und verlinkt zu speziellen ausführlichen artikeln.

wenn ich diese systeme auf azure architektonisch gestalte, behandle ich die llm-sicherheit nicht als einzelne komponente. es ist ein geschichtetes, tiefgehendes verteidigungsmodell. die kernidee besteht darin, eine reihe von prüfungen zu implementieren – einige, bevor das llm jemals aufgerufen wird, einige, nachdem es eine antwort generiert hat –, um sicherzustellen, dass sowohl benutzereingaben als auch modelloutputs unseren vordefinierten sicherheitsrichtlinien entsprechen. es ist eine pipeline des vertrauens.

unsere architektur verwendet zwei wichtige azure-dienste, die in einer bestimmten reihenfolge zusammengesetzt werden:

1. azure ai content safety: ein eigenständiger, hochleistungsfähiger dienst, den wir als erste verteidigungslinie nutzen. über contentsafetyclient.analyze_text bewertet er die eingabe des benutzers anhand von schadenskategorien (hass, sexuell, gewalt, selbstverletzung) und kann jailbreak- / indirekte angriffssignale auslösen, wenn shield_prompt aktiviert ist – bevor der text das teure llm erreicht.
2. azure openai service: das llm und seine filter auf bereitstellungsebene. prompt shields (benutzer-prompt-angriffe), groundedness und protected material sind in diesen dienst integriert: sie konfigurieren sie für die bereitstellung und interpretieren die in der azure openai api-antwort zusammen mit der vervollständigung zurückgegebenen anmerkungen.

das folgende diagramm veranschaulicht diesen geschichteten fluss von der benutzeranfrage bis zur endgültigen, sicheren anwendungsantwort.

dieses zusammensetzbare modell, das wir als fastapi-middleware implementieren werden, ist leistungsstark, da es umgebungsspezifische konfigurationen ermöglicht. ihre dev-umgebung kann nachsichtige schwellenwerte für tests haben, während ihre production-umgebung gesperrt und hochsicher bleibt.

bevor wir eine zeile code schreiben, richten wir unsere umgebung ein. dies ist das standard-toolkit, das ich für alle meine azure-basierten ki-projekte verwende.

• azure cli: stellen sie sicher, dass die cli installiert und sie beim richtigen azure-abonnement authentifiziert sind.

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

• terraform cli: wir verwenden terraform für die deklarative infrastruktur bereitstellung. ich verwende version 1.5+, aber jede neuere version sollte funktionieren.

terraform --version

• python 3.12+: unsere anwendungsschicht ist ausschließlich mit python erstellt. ich bestehe darauf, für jedes projekt eine virtuelle umgebung zu verwenden, um abhängigkeiten sauber zu verwalten.

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

• erforderliche python-pakete: installieren sie die notwendigen azure-sdks, fastapi für unsere webschicht und einige dienstprogramme.

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"

• umgebungsvariablen: wir verwenden umgebungsvariablen für die konfiguration. erstellen sie eine .env-datei in ihrem projektstammverzeichnis. defaultazurecredential verwendet diese für die lokale entwicklung und wechselt nahtlos zu 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"

mit unserer bereiten umgebung können wir nun die benötigte cloud-infrastruktur bereitstellen.

zuerst müssen wir die azure-ressourcen erstellen. ich verwende terraform dafür, um sicherzustellen, dass unsere infrastruktur wiederholbar, versionskontrolliert und als code dokumentiert ist. wir werden alles in francecentral bereitstellen. diese region steht auf der aktuellen liste von microsoft, wo die groundedness detection (grundlagenprüfung) verfügbar ist (neben regionen wie east us und canada east); mehrere angrenzende eu-regionen stehen nicht auf dieser liste, so dass die auswahl einer unterstützten region stille fehler vermeidet, wenn sie die grundlagenprüfung im code aktivieren.

diese konfiguration wird erstellen: 1. eine ressourcengruppe, um unsere dienste zu enthalten. 2. einen azure machine learning-arbeitsbereich, der als unser ki foundry-hub fungiert. 3. ein eigenständiges azure ai content safety-konto. 4. ein azure openai-konto mit einer gpt-4o-bereitstellung. 5. die notwendige rollen zuweisung, um dem ml-arbeitsbereich den zugriff auf den openai-dienst zu ermöglichen.

hier ist die vollständige main.tf-datei:

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

führen sie terraform init, terraform plan und terraform apply aus, um diese ressourcen zu erstellen. sobald dies abgeschlossen ist, kopieren sie die ausgabewerte in ihre .env-datei.

jetzt werden wir jede schutzmaßnahme als eine eigenständige komponente in python implementieren. dieser modulare ansatz macht das system einfacher zu testen, zu warten und zu konfigurieren.

jetzt bringen wir alles zusammen. eine fastapi-middleware ist der perfekte ort, um diese kette von schutzmaßnahmen zu orchestrieren. sie ermöglicht es uns, jede eingehende anfrage an unseren chat-endpunkt abzufangen, unsere sicherheitsprüfungen anzuwenden und die antwort zu ändern oder zu blockieren, bevor sie den benutzer überhaupt erreicht.

diese implementierung definiert eine responsibleaimiddleware-klasse, die unsere vor- und nachbearbeitungslogik ausführt.

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

mit diesem setup wird jede anfrage an /chat/invoke automatisch durch unsere gesamte sicherheitspipeline geleitet. dies ist eine saubere, skalierbare und nicht-intrusive methode, um responsible ai-richtlinien in ihrer anwendung durchzusetzen.

für organisationen in europa ist die dringendste frage: „wie hilft mir das bei der einhaltung des eu-ki-gesetzes?“ die antwort ist, dass diese technischen kontrollen direkt bestimmten rechtlichen verpflichtungen entsprechen. der bau dieser sicherheitsschicht ist nicht nur gutes engineering, sondern ein kernbestandteil ihrer compliance-strategie.

hier ist, wie jede schutzmaßnahme mit den schlüsselartikeln des gesetzes für hochrisiko-ki-systeme übereinstimmt:

die bereitstellung eines rohen llm in einer produktionsumgebung, insbesondere in einer regulierten branche, ist keine praktikable option mehr. die risiken schädlicher inhalte, katastrophaler halluzinationen und prompt-injection-angriffe sind zu groß, und die regulatorische landschaft, angeführt vom eu-ki-gesetz, erfordert konkrete, nachweisbare kontrollen.

wir haben ein vollständiges, praxiserprobtes muster zum aufbau einer mehrschichtigen verteidigung durchlaufen. durch die kombination von azure ai content safety für schnelles input-scanning und die nutzung der tief integrierten filter von azure openai für fortgeschrittene bedrohungen wie jailbreaks und unbegründetheit können sie eine robuste, konforme und vertrauenswürdige ki-anwendung konstruieren. das von mir gezeigte fastapi-middleware-muster bietet eine flexible und skalierbare möglichkeit, diese richtlinien zentral durchzusetzen und sicherzustellen, dass ihr llm sicher innerhalb der von ihnen definierten schutzmaßnahmen arbeitet.

meine empfehlung aus der praxis: versuchen sie nicht, das unmögliche zu erreichen. beginnen sie mit zwei schutzmaßnahmen: azure ai content safety für alle benutzereingaben mit konservativen schwellenwerten und groundedness detection (grundlagenprüfung) für alle rag-basierten ausgaben. diese beiden kontrollen allein mindern über 80 % der häufigsten sicherheits- und qualitätsprobleme in unternehmensbereitstellungen. aktivieren sie von dort aus azure openai prompt shields für die bereitstellung und fügen sie die protected material detection (erkennung geschützten materials) hinzu, je nach risikoprofil ihrer anwendung.

umsetzbarer nächster schritt: nehmen sie den fastapi-middleware-code aus diesem leitfaden und integrieren sie ihn in einen neuen zweig ihrer bestehenden llm-anwendung. konfigurieren sie ihn mit nachsichtigen schwellenwerten und stellen sie ihn in einer staging-umgebung bereit. beginnen sie mit dem sammeln von protokollen darüber, was er kennzeichnet und blockiert. diese daten werden für die feinabstimmung ihrer richtlinien von unschätzbarem wert sein, bevor sie sie in der produktion durchsetzen. so gelangen sie von der theorie zu einem greifbaren, unternehmenstauglichen sicherheitssystem.