Eseguire l'agente di intelligenza artificiale per il red teaming 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:

  • Il "red teaming" dell'intelligenza artificiale pre-distribuzione viene eseguito su combinazioni più ampie di strategie d'attacco e categorie di rischio per un'analisi più completa,
  • Esecuzioni di red teaming di intelligenza artificiale continua post-distribuzione che possono essere pianificate per l'esecuzione a intervalli di tempo impostati
  • Scenari di rischio specifici dell'agente per supportare un ambiente in modalità sandbox minima per l'esecuzione del red teaming di intelligenza artificiale

Prerequisiti

  • Progetto Foundry.
  • Ruolo di Utente Azure AI nel progetto Foundry.
  • 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 Microsoft Foundry SDK, che esegue l'agente di red teaming dell'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

Attualmente, soltanto i seguenti elementi sono supportati dall'agente di red teaming per l'intelligenza artificiale nel cloud:

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

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, eseguire 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 degli strumenti OpenAI/Foundry su Azure

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

  1. Creare una connessione: seguire le istruzioni riportate in Aggiungi una nuova connessione al progetto per connettere la risorsa Azure OpenAI o AI Services 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 condurre 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 una squadra rossa 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 il red team che si occupa della categoria di rischio agentico delle azioni vietate, è necessario essere in grado di confermare, modificare o aggiornare la tassonomia di valutazione generata dal workflow di red teaming delle azioni vietate. 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, verrà quindi usata per creare un'esecuzione di red teaming e valutare il tasso 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 esso

  • con un file_id URI nella richiesta Create Run.

Creare un'esecuzione in un team rosso

Un'esecuzione genera elementi da un'origine (ad esempio, una tassonomia) e valuta l'agente di destinazione con strategie di attacco selezionate.

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

Ottieni un'esecuzione di red-teaming per ID

Usare questa opzione per controllare lo stato dell'esecuzione del red teaming, ad esempio accodato, in esecuzione, riuscito e 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 e i risultati di un'esecuzione di red teaming

Usare questa opzione per verificare le metriche di riepilogo dopo il completamento della sessione di 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