Ejecutar AI Red Teaming Agent en la nube

Aunque ai Red Teaming Agent se puede ejecutar localmente durante la creación de prototipos y el desarrollo para ayudar a identificar los riesgos de seguridad, ejecutarlos en la nube permite los siguientes escenarios:

  • Los ejercicios de simulación adversaria de IA previo a la implementación se ejecutan en combinaciones más amplias de estrategias de ataque y categorías de riesgo para un análisis más completo,
  • Ejecuciones de continuous red teaming de IA después de la implementación, programables para ejecutarse en intervalos de tiempo establecidos.
  • Escenarios de riesgo específicos del agente para admitir un entorno mínimamente sandboxeado en la ejecución de red team de IA.

Requisitos previos

  • Un proyecto de fundición.
  • Rol de Usuario de Azure AI en el proyecto Foundry.
  • Python 3.9 o posterior.
  • Para escenarios de tipo agente: un agente de Foundry existente implementado en tu proyecto. Se requiere que el nombre del agente esté en el formato AZURE_AI_AGENT_NAME.

Introducción

En primer lugar, instale el cliente del proyecto SDK de Microsoft Foundry, que ejecuta el AI Red Teaming Agent en la nube.

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

A continuación, establezca las variables de entorno para los recursos de 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.

Objetivos admitidos

La ejecución de AI Red Teaming Agent en la nube actualmente solo admite lo siguiente:

  • Despliegues de proyectos de Foundry
  • Implementaciones de modelos de OpenAI en Azure
  • Foundry Agents (prompt y container agents) como destino en tu proyecto de Microsoft Foundry.

Configuración del modelo de destino

Puede configurar la implementación del modelo de destino de dos maneras:

Opción 1: Implementaciones de proyectos de Foundry

Si usa implementaciones de modelos que son parte de su proyecto Foundry, pase el nombre de implementación directamente en el initialization_parameters.deployment_name campo cuando crea un equipo rojo. Microsoft recomienda la autenticación sin claves a través de DefaultAzureCredential: ejecute az login antes de ejecutarse.

Si el escenario requiere autenticación de clave de API en su lugar:

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

Opción 2: Implementaciones de OpenAI/Foundry Tools en Azure

Si quiere usar implementaciones de las cuentas de OpenAI o Foundry Tools de Azure, primero debe conectar estos recursos al proyecto de Foundry a través de conexiones.

  1. Crear una conexión: siga las instrucciones de Agregar una nueva conexión al proyecto para conectar el recurso de OpenAI o AI Services de Azure al proyecto foundry.

  2. Obtenga el nombre de conexión: Una vez que haya conectado la cuenta, verá la conexión creada con un nombre generado en su proyecto Foundry.

  3. Configure el destino: use el formato "connectionName/deploymentName" para la configuración de implementación del modelo:

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

Creación de un equipo rojo de IA

Cree un equipo rojo para realizar una o varias ejecuciones que compartan una fuente de datos y categorías de riesgo.

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

Lo que hace:

  • Crea un equipo rojo para realizar todas las actividades de red teaming.
  • Configura el equipo rojo con tres evaluadores integrados (acciones prohibidas, cumplimiento de tareas, pérdida de datos confidenciales).

Recibirá lo siguiente:

  • Un cuerpo JSON con los metadatos del grupo, incluido el identificador (guárdelo como {{red_team_id}} para más adelante).

Obtener un equipo rojo

Úselo para comprobar que el equipo rojo existe y revisar la configuración (criterios, origen de datos, marcas de tiempo).

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)

Crear (o actualizar) una taxonomía de evaluación

Para realizar un red teaming en la categoría de riesgo agentivo de acciones prohibidas, debe poder confirmar, editar o actualizar la taxonomía de evaluación de las acciones prohibidas generada por el flujo de trabajo de red teaming de acciones prohibidas. En el ejemplo siguiente se generará un archivo JSON con una taxonomía generada de acciones prohibidas que se usarán para generar dinámicamente las indicaciones de ataque para probar el comportamiento agente en función de la directiva aprobada por el usuario. Una vez que haya revisado y confirmado la taxonomía, se empleará para crear un ejercicio de red team (equipo rojo) y para evaluar la tasa de éxito de ataque (ASR) de los resultados del 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}")

Lo que hace:

  • Crea o actualiza un recurso de taxonomía denominado {{name}} que:
    • Define un objetivo para el agente y descripciones de herramientas
    • Especifica las categorías de riesgo de ProhibitedActions

Lo referenciarás.

  • a través de un file_id URI en la Crear Ejecutar solicitud.

Crea una ejecución en un equipo rojo

Una ejecución genera elementos de un origen (por ejemplo, taxonomía) y realiza simulaciones de ataque al agente de destino con estrategias de ataque elegidas.

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

Campos clave para configurar la ejecución:

  • attack_strategies: por ejemplo, "Flip", "Base64", "IndirectJailbreak" (elija los que desea probar).
  • num_turns: profundidad de varios turnos para los elementos de equipo rojo generados
  • source.id: apunta a tu taxonomía por URI de ID de archivo
  • target: el agente sometido a prueba (nombre, versión, herramientas)

Recibirá

  • Objeto de ejecución que incluye id (guardar como {{eval_run_id}})

Recuperar una ejecución de red teaming (por ID)

Úselo para comprobar el estado de su ejecución de red teaming (por ejemplo, en cola, en ejecución, exitoso, fallido).

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

La API es sincrónica por solicitud, pero las ejecuciones se procesan en el lado servidor; sondee este punto de conexión hasta la finalización antes de capturar elementos de salida.

Lista de elementos obtenidos y resultados del equipo rojo

Úselo para inspeccionar las métricas resumidas después de completar la ejecución de las pruebas críticas de seguridad.

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

Contenido relacionado

  • Last updated on