Exécuter l’agent AI Red Teaming dans le cloud

Bien que l’agent d’équipe Red Teaming d’IA puisse être exécuté localement pendant le prototypage et le développement pour aider à identifier les risques de sécurité, l’exécution dans le cloud permet les scénarios suivants :

  • L'équipe rouge d'IA de prédéploiement s'appuie sur des combinaisons plus larges de stratégies d'attaque et de catégories de risques pour une analyse plus complète.
  • Exécutions continues de l’IA en red teaming après le déploiement, qui peuvent être programmées pour fonctionner à des intervalles réguliers
  • Scénarios de risque spécifiques aux agents autonomes pour prendre en charge un environnement de bac à sable minimal lors d'un exercice de red teaming IA

Conditions préalables

  • Un projet Foundry.
  • rôle d'utilisateur Azure IA sur le projet Foundry.
  • Python 3.9 ou version ultérieure.
  • Pour les scénarios agentiques : un agent Foundry existant déployé dans votre projet. Le nom de l’agent est requis en tant que AZURE_AI_AGENT_NAME.

Commencer

Tout d'abord, installez le client de projet du Kit de développement logiciel (SDK) Microsoft Foundry, qui exécute l'agent de red teaming IA sur le cloud.

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

Ensuite, définissez vos variables d’environnement pour vos ressources 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.

Cibles prises en charge

Actuellement, l’exécution de l’agent RED Teaming d’IA dans le cloud prend uniquement en charge les éléments suivants :

  • Déploiements de projets Foundry
  • Azure déploiements de modèles OpenAI
  • Agents Foundry (prompts et agents de conteneur) dans votre projet Microsoft Foundry comme cible.

Configurer votre modèle cible

Vous pouvez configurer votre déploiement de modèle cible de deux façons :

Option 1 : Déploiements de projets Foundry

Si vous utilisez des déploiements de modèles qui font partie de votre projet Foundry, transmettez le nom de déploiement directement dans le initialization_parameters.deployment_name champ lorsque vous créez une équipe rouge. Microsoft recommande l’authentification sans clé via DefaultAzureCredential : exécutez az login avant d’exécuter.

Si votre scénario nécessite l’authentification par clé API à la place :

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

Option 2 : déploiements des outils Azure OpenAI/Foundry

Si vous souhaitez utiliser des déploiements à partir de vos comptes OpenAI ou Foundry Tools Azure, vous devez d’abord connecter ces ressources à votre projet Foundry via des connexions.

  1. Créer une connexion : suivez les instructions de Add une nouvelle connexion à votre projet pour connecter votre ressource Azure OpenAI ou AI Services à votre projet Foundry.

  2. Obtenez le nom de la connexion : après avoir connecté le compte, vous verrez la connexion créée avec un nom généré dans votre projet Foundry.

  3. Configurez la cible : utilisez le format "connectionName/deploymentName" de votre configuration de déploiement de modèle :

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

Créer une équipe rouge IA

Créez une équipe rouge pour mener une ou plusieurs séances qui partagent une source de données et des catégories de risques.

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

Qu’est-ce qu’il fait :

  • Crée une équipe de cyberattaque pour effectuer tous les exercices de type red teaming.
  • Configure l’équipe rouge avec trois évaluateurs intégrés (Actions interdites, Respect des tâches, Fuites de données sensibles).

Vous recevrez :

  • Corps JSON avec les métadonnées du groupe, y compris l’ID (enregistrez-le comme {{red_team_id}} pour les versions ultérieures).

Obtenir une équipe rouge

Utilisez cette option pour vérifier que l’équipe rouge existe et passer en revue la configuration (critères, source de données, horodatages).

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)

Créer (ou mettre à jour) une taxonomie d’évaluation

Pour mener une analyse de type "red team" pour la catégorie de risque agentique des actions interdites, vous devez être en mesure de confirmer, éditer ou mettre à jour la taxonomie d'évaluation des actions interdites générée par le flux de travail de red teaming des actions interdites. L’exemple suivant génère un fichier JSON avec une taxonomie générée d’actions interdites à utiliser pour générer dynamiquement les invites d’attaque pour tester le comportement agentique en fonction de la stratégie approuvée par l’utilisateur. Une fois que vous avez examiné et confirmé la taxonomie, elle sera ensuite utilisée pour créer une mise en œuvre d'un exercice d'équipe rouge, ainsi que pour évaluer le taux de réussite des attaques (ASR) des résultats de l'agent.

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

Qu’est-ce qu’il fait :

  • Crée/met à jour une ressource de taxonomie nommée {{name}} :
    • Définit une description de la cible et de l’outil de l’agent
    • Spécifie les catégories de risques de ProhibitedActions

Vous allez vous y référer

  • via un file_id URI dans la requête Créer une exécution .

Créer une opération au sein d'une équipe Red Team

Une exécution génère des éléments à partir d’une source (par exemple, taxonomie) et simule des attaques sur l’agent cible à l'aide de stratégies d’attaque choisies.

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

Champs clés pour configurer votre exécution :

  • attack_strategies: par exemple, « Flip », « Base64 », « IndirectJailbreak » (choisissez celles que vous souhaitez tester)
  • num_turns: profondeur à plusieurs tour pour les éléments d’équipe rouge générés
  • source.id: pointe vers votre taxonomie par URI d’ID de fichier
  • target: l’agent sous test (nom, version, outils)

Vous recevrez

  • Objet d’exécution incluant id (enregistrer sous {{eval_run_id}})

Obtenir un processus de red teaming (par ID)

Utilisez ceci pour vérifier l’état de votre exécution de red teaming (par exemple, en file d’attente, en cours d’exécution, réussite, échec).

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)

Note

L’API est synchrone par requête, mais les exécutions elles-mêmes sont traitées côté serveur ; interrogez ce point de terminaison jusqu’à la fin avant d’extraire les éléments de sortie.

Répertorier les éléments de sortie et les résultats de l'exécution de red teaming

Utilisez ceci pour inspecter les métriques récapitulatives après l'exécution de l'évaluation de la red team.

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

Contenu connexe

  • Last updated on