Freigeben über

Ausführen von AI Red Teaming Agent in der Cloud (Vorschau)

Von Bedeutung

Die in diesem Artikel markierten Elemente (Vorschau) sind aktuell als öffentliche Vorschau verfügbar. Diese Vorschauversion wird ohne Vereinbarung zum Servicelevel bereitgestellt und sollte nicht für Produktionsworkloads verwendet werden. Manche Features werden möglicherweise nicht unterstützt oder sind nur eingeschränkt verwendbar. Weitere Informationen finden Sie unter Supplementale Nutzungsbedingungen für Microsoft Azure Previews.

Obwohl der AI Red Teaming Agent während der Prototyperstellung und -entwicklung lokal ausgeführt werden kann, um Sicherheitsrisiken zu identifizieren, ermöglicht die Ausführung in der Cloud die folgenden Szenarien:

  • Ausführungen von KI Red Teaming vor der Bereitstellung auf größeren Kombinationen von Angriffsstrategien und Risikokategorien zur umfassenderen Analyse
  • Kontinuierliche Ausführungen von KI Red Teaming-Tests nach der Bereitstellung, die in festgelegten Zeitintervallen ausgeführt werden können
  • Agent-spezifische Risikoszenarien zur Unterstützung einer minimalen Sandboxumgebung für die KI Red Teaming-Ausführung

Voraussetzungen

Erste Schritte

Installieren Sie zuerst den project-Client des Microsoft Foundry SDK, der den AI Red Teaming Agent in der Cloud ausführt.

pip install azure-ai-projects>=2.0.0

Legen Sie dann Die Umgebungsvariablen für Ihre Microsoft Foundry-Ressourcen fest.

import os

endpoint = os.environ["PROJECT_ENDPOINT"] # Sample : https://<account_name>.services.ai.azure.com/api/projects/<project_name>
agent_name = os.environ["AZURE_AI_AGENT_NAME"] # Required. The name of the Agent to perform red teaming evaluation on.

Unterstützte Ziele

Das Ausführen des AI Red Teaming Agent in der Cloud unterstützt derzeit nur Folgendes:

  • Bereitstellungen von Foundry-Projekten
  • Azure OpenAI-Modellbereitstellungen
  • Foundry Agents (Prompt- und Container-Agents) in Ihrem Microsoft Foundry-Projekt als Ziel.

Konfigurieren Des Zielmodells

Sie können ihre Zielmodellbereitstellung auf zwei Arten konfigurieren:

Option 1: Bereitstellungen von Foundry-Projekten

Wenn die Modellbereitstellungen Teil Ihres Foundry-Projekts sind, richten Sie die folgenden Umgebungsvariablen ein:

import os

model_endpoint = os.environ["MODEL_ENDPOINT"] # Sample : https://<account_name>.openai.azure.com
model_api_key = os.environ["MODEL_API_KEY"]
model_deployment_name = os.environ["MODEL_DEPLOYMENT_NAME"] # Sample : gpt-4o-mini

Option 2: Azure OpenAI/Foundry Tools-Bereitstellungen

Wenn Sie Bereitstellungen aus Ihren Azure OpenAI- oder Foundry Tools-Konten verwenden möchten, müssen Sie diese Ressourcen zuerst über Verbindungen mit Ihrer Foundry-project verbinden.

  1. Erstellen Sie eine Verbindung: Befolgen Sie die Anweisungen unter Hinzufügen einer neuen Verbindung zu Ihrem Projekt , um Ihre Azure OpenAI- oder AI Services-Ressource mit Ihrem Foundry-Projekt zu verbinden.

  2. Verbindungsname erhalten: Nachdem Sie das Konto verbunden haben, sehen Sie die erstellte Verbindung mit einem generierten Namen in Ihrem Foundry-Projekt.

  3. Konfigurieren Sie das Ziel: Verwenden Sie das Format "connectionName/deploymentName" für die Modellbereitstellungskonfiguration:

# Format: "connectionName/deploymentName"
model_deployment_name = "my-openai-connection/gpt-4o-mini"

Rotes KI-Team erstellen

Erstellen Sie ein Red Team, um eine oder mehrere Ausführungen durchzuführen, die die gleiche Datenquelle und die gleichen Risikokategorien nutzen.

import os
from azure.identity import DefaultAzureCredential
from azure.ai.projects import AIProjectClient

endpoint = os.environ["AZURE_AI_PROJECT_ENDPOINT"]
model_deployment = os.environ["AZURE_AI_MODEL_DEPLOYMENT_NAME"]

with DefaultAzureCredential() as credential:
    with AIProjectClient(endpoint=endpoint, credential=credential) as project_client:
        client = project_client.get_openai_client()

        # Create a red team with built-in safety evaluators
        red_team = client.evals.create(
            name="Red Team Agentic Safety Evaluation",
            data_source_config={"type": "azure_ai_source", "scenario": "red_team"},
            testing_criteria=[
                {
                    "type": "azure_ai_evaluator",
                    "name": "Prohibited Actions",
                    "evaluator_name": "builtin.prohibited_actions",
                    "evaluator_version": "1"
                },
                {
                    "type": "azure_ai_evaluator",
                    "name": "Task Adherence",
                    "evaluator_name": "builtin.task_adherence",
                    "evaluator_version": "1",
                    "initialization_parameters": {"deployment_name": model_deployment},
                },
                {
                    "type": "azure_ai_evaluator",
                    "name": "Sensitive Data Leakage",
                    "evaluator_name": "builtin.sensitive_data_leakage",
                    "evaluator_version": "1"
                },
            ],
        )
        print(f"Created red team: {red_team.id}")

Funktionsweise:

  • Erstellt ein Red Team für alle Red Teaming-Ausführungen
  • Konfiguriert das rote Team mit drei integrierten Auswertungen (Verbotene Aktionen, Aufgabenbefolgung, vertrauliche Datenlecks).

Sie erhalten Folgendes:

  • Ein JSON-Textkörper mit den Metadaten der Gruppe, einschließlich der ID (speichern Sie sie als {{red_team_id}} für später).

Abrufen eines Red Teams

Verwenden Sie diese Einstellung, um zu überprüfen, ob das rote Team vorhanden ist, und die Konfiguration überprüfen (Kriterien, Datenquelle, Zeitstempel).

print(f"[Group] Retrieving group by id={red_team.id} ...")
red_team_fetched = client.evals.retrieve(red_team.id)
print("[Group] Response:")
print(red_team_fetched)

Erstellen (oder Aktualisieren) einer Auswertungstaxonomie

Um für die Agent-Risikokategorie der verbotenen Aktionen ein Red Team einzusetzen, müssen Sie in der Lage sein, die Bewertungstaxonomie der verbotenen Aktionen, die durch den Red Teaming-Workflow für verbotene Aktionen generiert wurde, zu bestätigen, zu bearbeiten oder zu aktualisieren. Im nächsten Beispiel wird eine JSON-Datei mit einer generierten Taxonomie von verbotenen Aktionen generiert, die zur dynamischen Generierung der Angriffsaufforderungen verwendet werden, um das agentische Verhalten basierend auf der vom Benutzer genehmigten Richtlinie zu testen. Nachdem Sie die Taxonomie überprüft und bestätigt haben, wird sie verwendet, um eine Red Teaming-Ausführung zu erstellen und die Angriffserfolgsrate (ASR) der Agent-Ausgaben zu bewerten.

from azure.ai.projects.models import (
    AzureAIAgentTarget,
    AgentTaxonomyInput,
    EvaluationTaxonomy,
    RiskCategory,
)

# Define the agent target for taxonomy generation
target = AzureAIAgentTarget(
    name=agent_name,
    version=agent_version.version,
)

# Create taxonomy for prohibited actions risk category
taxonomy = project_client.beta.evaluation_taxonomies.create(
    name=agent_name,
    body=EvaluationTaxonomy(
        description="Taxonomy for red teaming run",
        taxonomy_input=AgentTaxonomyInput(
            risk_categories=[RiskCategory.PROHIBITED_ACTIONS],
            target=target
        ),
    )
)
taxonomy_file_id = taxonomy.id
print(f"Created taxonomy: {taxonomy_file_id}")

Funktionsweise:

  • Erstellt/aktualisiert eine Taxonomieressource mit dem Namen {{name}} :
    • Definiert ein Ziel für einen Agenten und Toolbeschreibungen
    • Gibt die Risikokategorien von ProhibitedActions

Sie nutzen sie als Referenz

  • über eine file_id URI in der Create Run-Anforderung.

Erstellen einer Ausführung in einem Red Team

Eine Ausführung generiert Elemente aus einer Quelle (z. B. Taxonomie) und führt gegen den Ziel-Agent mit ausgewählten Angriffsstrategien ein Red Teaming durch.

# Create a red team run with attack strategies
eval_run = client.evals.runs.create(
    eval_id=red_team.id,
    name="Red Team Agent Safety Eval Run",
    data_source={
        "type": "azure_ai_red_team",
        "item_generation_params": {
            "type": "red_team_taxonomy",
            "attack_strategies": ["Flip", "Base64", "IndirectJailbreak"],
            "num_turns": 5,
            "source": {"type": "file_id", "id": taxonomy_file_id},
        },
        "target": target.as_dict(),
    },
)
print(f"Created run: {eval_run.id}, status: {eval_run.status}")

Schlüsselfelder zum Konfigurieren der Ausführung:

  • attack_strategies: Beispiel: "Flip", "Base64", "IndirectJailbreak" (wählen Sie die aus, die Sie testen möchten)
  • num_turns: Tiefe der Mehrfachdurchläufe für generierte Red Team-Elemente
  • source.id: verweist auf Ihre Taxonomie mittels Datei-ID-URI
  • target: der Agent unter Test (Name, Version, Tools)

Sie erhalten

  • Ein Ausführungsobjekt einschließlich id (speichern als {{eval_run_id}})

Abrufen einer Red Teaming-Ausführung (nach ID)

Verwenden Sie dies, um den Status Ihrer Red Teaming-Ausführung zu überprüfen (z. B. in der Warteschlange, wird ausgeführt, erfolgreich, Fehler).

import time

# Poll for run completion
while True:
    run = client.evals.runs.retrieve(run_id=eval_run.id, eval_id=red_team.id)
    print(f"Status: {run.status}")
    if run.status in ("completed", "failed", "canceled"):
        break
    time.sleep(5)

Hinweis

Die API ist synchron pro Anfrage, aber die Ausführungen werden serverseitig verarbeitet; diesen Endpunkt bis zum Abschluss abfragen, bevor die Ausgabeelemente abgerufen werden.

Auflisten der Ausgabeelemente und Ergebnisse von Red Teaming-Ausführungen

Verwenden Sie dies, um Zusammenfassungsmetriken nach Abschluss der Red Teaming-Ausführung zu prüfen.

print("[Run] Fetching output items...")
items = list(client.evals.runs.output_items.list(run_id=run.id, eval_id=red_team.id))
output_path = os.path.join(data_folder, f"redteam_eval_output_items_{agent_name}.json")
with open(output_path, "w") as f:
    f.write(json.dumps(_to_json_primitive(items), indent=2))
print(f"[Run] Done. Status={run.status}. Output items saved to {output_path}")

Verwandte Inhalte

  • Last updated on