Kör AI Red Teaming Agent i molnet

Även om AI Red Teaming Agent kan köras lokalt under prototyper och utveckling för att identifiera säkerhetsrisker kan du köra dem i molnet för följande scenarier:

  • AI-red-team-arbete före implementering körs på större kombinationer av attackstrategier och riskkategorier för en grundligare analys.
  • Fortlöpande AI-red team-aktiviteter efter distribution som kan schemaläggas för att köras med angivna tidsintervall.
  • Agent-specifika riskscenarier för att stödja en minimalt sandboxad miljö för AI-red teaming-körning

Förutsättningar

  • Ett Foundry-projekt.
  • Azure AI User roll i Foundry-projektet.
  • Python 3.9 eller senare.
  • För scenarion med agentkontroll: en existerande Foundry Agent som installerats i ditt projekt. Agentens namn krävs som AZURE_AI_AGENT_NAME.

Komma igång

Installera först Microsoft Foundry SDK:s projektklient, som kör AI Red Teaming Agent i molnet.

pip install "azure-ai-projects>=2.0.0"

Ange sedan miljövariablerna för dina Microsoft Foundry-resurser

import os

endpoint = os.environ["AZURE_AI_PROJECT_ENDPOINT"]  # Example: 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 red team.

Mål som stöds

Att köra AI Red Teaming Agent i molnet stöder för närvarande endast följande:

  • Foundry-projektimplementeringar
  • Azure OpenAI-modelldistributioner
  • Foundry-agenter (prompt och containeragenter) i ditt Microsoft Foundry-projekt som mål.

Konfigurera målmodellen

Du kan konfigurera målmodelldistributionen på två sätt:

Alternativ 1: Foundry-projektutplaceringar

Om du använder modelldistributioner som ingår i ditt Foundry-projekt skickar du distributionsnamnet direkt i fältet initialization_parameters.deployment_name när du skapar ett rött team. Microsoft rekommenderar nyckellös autentisering via DefaultAzureCredential – kör az login innan du kör.

Om ditt scenario kräver API-nyckelautentisering i stället:

import os

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

Alternativ 2: Azure Implementeringar av OpenAI/Foundry Tools

Om du vill använda distributioner från dina Azure OpenAI- eller Foundry Tools-konton måste du först ansluta dessa resurser till ditt Foundry-projekt via anslutningar.

  1. Skapa en anslutning: Följ anvisningarna i Lägg till en ny anslutning till projektet för att ansluta din Azure OpenAI- eller AI Services-resurs till ditt Foundry-projekt.

  2. Hämta anslutningsnamnet: När du har anslutit kontot visas anslutningen som skapats med ett genererat namn i foundry-projektet.

  3. Konfigurera målet: Använd formatet "connectionName/deploymentName" för din modelldistributionskonfiguration:

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

Skapa ett rött AI-team

Skapa ett red team för att genomföra en eller flera körningar som delar en datakälla och riskkategorier.

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}")

Vad den gör:

  • Skapar ett Red Team för att hantera alla red teaming-övningar
  • Konfigurerar det röda teamet med tre inbyggda utvärderare (otillåtna åtgärder, uppgiftsefterlevnad, läckage av känsliga data).

Du får:

  • En JSON-brödtext med gruppens metadata, inklusive ID (spara det som {{red_team_id}} för senare).

Skaffa ett rött team

Använd detta för att kontrollera att det röda teamet finns och granska konfigurationen (villkor, datakälla, tidsstämplar).

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)

Skapa (eller uppdatera) en utvärderingstaxonomi

För att utföra en red team-analys för den agentiska riskkategorin av förbjudna handlingar måste du kunna bekräfta, redigera eller uppdatera värderingstaxonomin av förbjudna handlingar som genereras av arbetsflödet för red teaming av förbjudna handlingar. Nästa exempel genererar en JSON-fil med en genererad taxonomi av förbjudna åtgärder som ska användas för att dynamiskt generera angreppsprompter för att testa agentiskt beteende baserat på användargodkänd princip. När du har granskat och bekräftat taxonomin används den för att utföra en red teaming-run samt utvärdera agentutdatas Attack Success Rate (ASR).

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}")

Vad den gör:

  • Skapar/uppdaterar en taxonomiresurs med namnet {{name}} som:
    • Definierar ett agentmål och verktygsbeskrivningar
    • Anger riskkategorierna för ProhibitedActions

Du kommer att referera till det

  • via en file_id URI i begäran Skapa körning .

Skapa en övning i ett red team

En körning genererar objekt från en källa (till exempel taxonomi) och röda grupper målagenten med valda attackstrategier.

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

Viktiga fält för att konfigurera körningen:

  • attack_strategies: Till exempel "Flip", "Base64", "IndirectJailbreak" (välj de som du vill testa)
  • num_turns: djup för flera svängar för genererade red-team-objekt
  • source.id: pekar på din taxonomi efter fil-ID-URI
  • target: agenten som testas (namn, version, verktyg)

Du kommer att få

  • Ett körningsobjekt inklusive id (spara som {{eval_run_id}})

Hämta en red teaming-körning (med ID)

Använd det här alternativet för att kontrollera statusen för din red teaming-operation (till exempel i kö, körs, framgångsrik, misslyckades).

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)

Observera

API:et är synkront per begäran, men själva processerna bearbetas på serversidan; kontrollera denna slutpunkt tills den är klar innan du hämtar utdataobjekt.

Lista red teaming-körningens resultat och objekt

Använd detta för att granska sammanfattande mätvärden efter att red team-övningen har slutförts.

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}")

Relaterat innehåll

  • Last updated on