Eseguire l'Agente di red teaming per intelligenza artificiale nel cloud

Anche se l'agente di red teaming di intelligenza artificiale può essere eseguito in locale durante la creazione di prototipi e lo sviluppo per identificare i rischi di sicurezza, l'esecuzione nel cloud consente gli scenari seguenti:

  • Esecuzioni di red teaming IA pre-distribuzione su combinazioni più ampie di strategie di attacco e categorie di rischio per un'analisi più completa,
  • Esecuzioni di red teaming IA continuo post-distribuzione che possono essere pianificate per l'esecuzione a intervalli di tempo impostati
  • Scenari di rischio agentico-specifici per supportare un ambiente in modalità sandbox minima per l'esecuzione del red teaming IA

Prerequisiti

  • Progetto Foundry.

  • Ruolo di utente Foundry nel progetto Foundry.

    Importante

    I ruoli RBAC di Foundry sono stati recentemente rinominati. Foundry User, Foundry Owner, Foundry Account Owner e Foundry Project Manager erano precedentemente denominati Azure AI User, Azure AI Owner, Azure AI Account Owner e Azure AI Project Manager. È possibile che i nomi precedenti vengano visualizzati in alcune posizioni durante l'esecuzione della ridenominazione. Gli ID ruolo e le autorizzazioni di base sono invariati dalla ridenominazione.

  • Python 3.9 o versione successiva.

  • Per gli scenari agentici: un agente Foundry esistente distribuito nel tuo progetto. Il nome dell'agente è obbligatorio come AZURE_AI_AGENT_NAME.

Per iniziare

Prima di tutto, installare il client del progetto dell'SDK Microsoft Foundry, che esegue Agente di red teaming per intelligenza artificiale nel cloud.

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

Impostare quindi le variabili di ambiente per le risorse di Microsoft Foundry

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.

Destinazioni supportate

L'esecuzione dell'agente di red teaming per intelligenza artificiale nel cloud attualmente supporta solo gli elementi seguenti:

  • Distribuzioni di progetti Foundry
  • Distribuzioni di modelli OpenAI di Azure
  • Agenti Foundry (agenti prompt e contenitore) nel progetto Microsoft Foundry come obiettivo.

Configurare il modello di destinazione

È possibile configurare la distribuzione del modello di destinazione in due modi:

Opzione 1: Distribuzione dei progetti Foundry

Se si usano distribuzioni di modelli che fanno parte del progetto Foundry, passare il nome della distribuzione direttamente nel initialization_parameters.deployment_name campo quando si crea un team rosso. Microsoft consiglia l'autenticazione senza chiave tramite DefaultAzureCredential , eseguita az login prima dell'esecuzione.

Se invece lo scenario richiede l'autenticazione con chiave API:

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

Opzione 2: Distribuzioni di Azure OpenAI/Foundry Tools

Se si vogliono usare le distribuzioni dagli account Azure OpenAI o Foundry Tools, è prima necessario connettere queste risorse al progetto Foundry tramite connessioni.

  1. Creare una connessione: seguire le istruzioni in Aggiungere una nuova connessione al progetto per connettere la risorsa Di Azure OpenAI o ai Servizi di intelligenza artificiale al progetto Foundry.

  2. Ottenere il nome della connessione: dopo aver connesso l'account, verrà visualizzata la connessione creata con un nome generato nel progetto Foundry.

  3. Configurare la destinazione: usare il formato "connectionName/deploymentName" per la configurazione della distribuzione del modello:

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

Creare un team rosso di intelligenza artificiale

Creare un red team per mantenere una o più esecuzioni che condividono un'origine dati e categorie di rischio.

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

Che cosa fa:

  • Crea un red team per condurre tutte le esecuzioni di red teaming
  • Configura il red team con tre analizzatori predefiniti (azioni vietate, conformità delle attività, perdita di dati sensibili).

Riceverai:

  • Corpo JSON con i metadati del gruppo, incluso l'ID (salvarlo come {{red_team_id}} per un secondo momento).

Ottenere una squadra rossa

Usare questa opzione per verificare che il team rosso esista e rivedere la configurazione (criteri, origine dati, timestamp).

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)

Creare (o aggiornare) una tassonomia di valutazione

Per ottenere un red team per la categoria di rischio agentico di azioni proibite, è necessario poter confermare, modificare o aggiornare la tassonomia di valutazione delle azioni proibite generate dal flusso di lavoro del red teaming delle azioni proibite. L'esempio successivo genererà un file JSON con una tassonomia generata di azioni proibite da usare per generare dinamicamente le richieste di attacco per testare il comportamento agente in base ai criteri approvati dall'utente. Dopo aver esaminato e confermato la tassonomia, questa verrà usata per creare un'esecuzione di red teaming e per valutare la percentuale di successo degli attacchi (ASR) degli output dell'agente.

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

Che cosa fa:

  • Crea/aggiorna una risorsa tassonomia denominata {{name}} :
    • Definisce una destinazione dell'agente e le descrizioni degli strumenti
    • Specifica le categorie di rischio di ProhibitedActions

Si farà riferimento a tale elemento

  • con un file_id URI nella richiesta Create Run.

Creare un'esecuzione in un red team

Un'esecuzione genera elementi da un'origine (ad esempio tassonomia) ed esegue il red teaming dell'agente di destinazione con strategie di attacco scelte.

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

Campi chiave per configurare l'esecuzione:

  • attack_strategies: ad esempio, "Flip", "Base64", "IndirectJailbreak" (scegliere quelli da testare)
  • num_turns: profondità a più turni per gli elementi red-team generati
  • source.id: punta alla tassonomia in base all'URI dell'ID file
  • target: agente sottoposto a test (nome, versione, strumenti)

Riceverai

  • Oggetto di esecuzione che include id (salva come {{eval_run_id}})

Ottenere un'esecuzione di red teaming (per ID)

Usarlo per verificare lo stato dell'esecuzione di red teaming, ad esempio accodato, in esecuzione, riuscito, non riuscito.

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)

Nota

L'API è sincrona per ogni richiesta, ma le esecuzioni sono elaborate lato server; eseguire il polling dell'endpoint fino al completamento dell'elaborazione prima di ottenere gli elementi di output.

Elencare gli elementi di output dell'esecuzione del red teaming e i risultati

Usarlo per ispezionare le metriche di riepilogo dopo il completamento dell'esecuzione del red teaming.

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

Contenuto correlato

  • Last updated on