AI Red Teaming Agent uitvoeren in de cloud

Hoewel de AI Red Teaming Agent lokaal kan worden uitgevoerd tijdens het maken van prototypen en ontwikkeling om veiligheidsrisico's te identificeren, kunnen ze in de cloud worden uitgevoerd voor de volgende scenario's:

  • Voor een grondigere analyse wordt AI red teaming uitgevoerd op grotere combinaties van aanvalsstrategieën en risicocategorieën.
  • Doorlopende AI red team-activiteiten na de uitrol die gepland kunnen worden om op vooraf ingestelde tijdsintervallen uitgevoerd te worden.
  • Agentspecifieke risicoscenario's ter ondersteuning van een minimaal gesandboxte omgeving voor het uitvoeren van AI red teaming

Voorwaarden

  • Een Foundry-project.
  • Azure AI-gebruiker rol in het Foundry-project.
  • Python 3,9 of hoger.
  • Voor agentische scenario's: een bestaande Foundry-agent die in uw project is geïmplementeerd. De naam van de agent is vereist als AZURE_AI_AGENT_NAME.

Aan de slag gaan

Installeer eerst de projectclient van Microsoft Foundry SDK, waarop de AI Red Teaming Agent in de cloud wordt uitgevoerd.

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

Stel vervolgens uw omgevingsvariabelen in voor uw Microsoft Foundry-resources

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.

Ondersteunde doelen

Het uitvoeren van de AI Red Teaming Agent in de cloud ondersteunt momenteel alleen het volgende:

  • Foundry-projectuitrol
  • Azure OpenAI-modelimplementaties
  • Foundry Agents (prompt en container agents) in uw Microsoft Foundry project als doel instellen.

Uw doelmodel configureren

U kunt de implementatie van uw doelmodel op twee manieren configureren:

Optie 1: Foundry-project-implementaties

Als u modelimplementaties gebruikt die deel uitmaken van uw Foundry-project, geeft u de implementatienaam rechtstreeks in het initialization_parameters.deployment_name veld door wanneer u een rood team maakt. Microsoft raadt sleutelloze verificatie aan via DefaultAzureCredential: voer az login uit voordat u deze uitvoert.

Als voor uw scenario in plaats daarvan API-sleutelverificatie is vereist:

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

Optie 2: implementaties van OpenAI/Foundry Tools Azure

Als u implementaties wilt gebruiken vanuit uw Azure OpenAI- of Foundry Tools-accounts, moet u deze resources eerst verbinden met uw Foundry-project via verbindingen.

  1. Maak een verbinding: volg de instructies in Add een nieuwe verbinding met uw project om uw Azure OpenAI- of AI Services-resource te verbinden met uw Foundry-project.

  2. Haal de verbindingsnaam op: nadat u het account hebt verbonden, ziet u de verbinding die is gemaakt met een gegenereerde naam in uw Foundry-project.

  3. Configureer het doel: gebruik de indeling "connectionName/deploymentName" voor de configuratie van uw modelimplementatie:

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

Een rood AI-team maken

Maak een ‘red team’ voor een of meer sessies die een gegevensbron en risicocategorieën delen.

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

Wat het doet:

  • Met deze actie maakt u een rood team voor alle red teaming sessies
  • Hiermee configureert u het rode team met drie ingebouwde evaluators (verboden acties, taaknavolging, gevoelige gegevenslekken).

U ontvangt het volgende:

  • Een JSON-body met de metagegevens van de groep, inclusief ID (bewaar het als {{red_team_id}} voor later).

Een rood team krijgen

Gebruik dit om te controleren of het rode team bestaat en controleer de configuratie (criteria, gegevensbron, tijdstempels).

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)

Een evaluatietaxonomie maken (of bijwerken)

Als u een rood team wilt gebruiken voor de categorie met agentische risico's van verboden acties, moet u de evaluatietaxonomie kunnen bevestigen, bewerken of bijwerken van verboden acties die zijn gegenereerd door de werkstroom voor verboden actie rood. In het volgende voorbeeld wordt een JSON-bestand gegenereerd met een gegenereerde taxonomie van verboden acties die moeten worden gebruikt bij het dynamisch genereren van de aanvalsprompts om agentisch gedrag te testen op basis van door de gebruiker goedgekeurd beleid. Zodra u de taxonomie hebt gecontroleerd en bevestigd, wordt deze gebruikt om een rode teamuitvoering te maken en de ASR (Attack Success Rate) van de agentuitvoer te beoordelen.

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

Wat het doet:

  • Een taxonomieresource met de naam {{name}} wordt hiermee gemaakt of bijgewerkt die:
    • Definieert een agentdoel en beschrijvingen van hulpprogramma's
    • Hiermee geeft u de risicocategorieën van ProhibitedActions

U verwijst ernaar

  • via een file_id URI in het uitvoeringsverzoek.

Een run uitvoeren binnen een red team

Een uitvoering genereert items van een bron (bijvoorbeeld taxonomie) en rode teams de doelagent met gekozen aanvalsstrategieën.

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

Sleutelvelden voor het configureren van uw uitvoering:

  • attack_strategies: Bijvoorbeeld "Flip", "Base64", "IndirectJailbreak" (kies de waarden die u wilt testen)
  • num_turns: diepte van meerdere bochten voor gegenereerde rode teamitems
  • source.id: verwijst naar uw taxonomie op bestands-ID-URI
  • target: de agent onder test (naam, versie, hulpprogramma's)

U ontvangt

  • Een run-object met inbegrip van id (opslaan als {{eval_run_id}})

Een red teaming-actie ophalen (via ID)

Gebruik dit om de status van uw red teaming-uitvoering te controleren (bijvoorbeeld in de wachtrij geplaatst, uitgevoerd, geslaagd, mislukt).

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)

Opmerking

De API is per aanvraag synchroon, maar bewerkingen worden aan de serverzijde verwerkt; controleer dit eindpunt totdat het is voltooid voordat u uitvoeritems ophaalt.

Uitvoeritems en resultaten van de redteaming uitvoering vermelden

Gebruik dit om samenvattingsmetriek te controleren na voltooiing van de red teaming run.

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

Verwante inhoud

  • Last updated on