Uruchamianie agenta Red Teaming AI w chmurze

Chociaż agent red teamingu sztucznej inteligencji może być uruchamiany lokalnie podczas tworzenia prototypów i rozwoju w celu ułatwienia identyfikowania zagrożeń bezpieczeństwa, uruchamianie ich w chmurze umożliwia realizację następujących scenariuszy:

  • Testowanie zespołu ds. przeciwdziałania zagrożeniom przez AI przed wdrożeniem odbywa się na podstawie większych kombinacji strategii ataków i kategorii ryzyka w celu pełniejszej analizy.
  • Ciągłe uruchamianie testów AI „red teaming” po wdrożeniu, które można zaplanować do uruchomienia w określonych odstępach czasu
  • Scenariusze ryzyka specyficzne dla działań samodzielnych w celu wspierania środowiska z minimalnym zastosowaniem piaskownicy przy realizacji ofensywnych testów zespołowych sztucznej inteligencji

Wymagania wstępne

  • Projekt Foundry.

  • Rola użytkownika usługi Foundry w projekcie Foundry.

    Ważna

    Niedawno zmieniono nazwy ról RBAC w usłudze Foundry. Użytkownik Foundry, właściciel Foundry, właściciel konta Foundry i menedżer projektu Foundry były wcześniej nazywane odpowiednio użytkownikiem Azure AI, właścicielem Azure AI, właścicielem konta Azure AI i menedżerem projektu Azure AI. Poprzednie nazwy mogą być nadal widoczne w niektórych miejscach, podczas gdy zmiana nazwy jest wdrażana. Identyfikatory ról i uprawnienia podstawowe są niezmienione przez zmianę nazwy.

  • Python 3.10 lub nowszy.

  • W przypadku scenariuszy agenta: istniejący agent Foundry wdrożony w projekcie. Nazwa agenta jest wymagana jako AZURE_AI_AGENT_NAME.

Wprowadzenie

Najpierw zainstaluj klienta projektu SDK Microsoft Foundry, który uruchamia agenta AI Red Teaming w chmurze.

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

Następnie ustaw zmienne środowiskowe dla zasobów 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.

Obsługiwane obiekty docelowe

Uruchamianie agenta AI Red Teaming Agent w chmurze obecnie obsługuje tylko następujące elementy:

  • Wdrożenia projektów typu foundry
  • Azure wdrożenia modeli OpenAI
  • Agenci Foundry (agenci prompt i agenci kontenera) w projekcie Microsoft Foundry jako cel.

Konfigurowanie modelu docelowego

Wdrożenie modelu docelowego można skonfigurować na dwa sposoby:

Opcja 1: Wdrożenia projektu Foundry

Jeśli korzystasz z wdrożeń modeli będących częścią projektu Foundry, wpisz nazwę wdrożenia bezpośrednio w polu initialization_parameters.deployment_name podczas tworzenia zespołu red team. Microsoft zaleca uwierzytelnianie bez klucza za pośrednictwem DefaultAzureCredential — uruchom az login przed wykonaniem.

Jeśli Twój scenariusz wymaga uwierzytelniania za pomocą klucza 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

Opcja 2: Wdrożenia Azure OpenAI/Foundry Tools

Jeśli chcesz używać wdrożeń z kont Azure OpenAI lub Foundry Tools, najpierw musisz połączyć te zasoby z projektem Foundry za pośrednictwem połączeń.

  1. Utwórz połączenie: Postępuj zgodnie z instrukcjami w Dodaj nowe połączenie z projektem aby połączyć zasób Azure OpenAI lub AI Services z projektem Foundry.

  2. Pobierz nazwę połączenia: po nawiązaniu połączenia z kontem zobaczysz połączenie utworzone z wygenerowaną nazwą w projekcie Foundry.

  3. Skonfiguruj cel: użyj formatu "connectionName/deploymentName" do konfiguracji wdrożenia modelu.

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

Tworzenie czerwonego zespołu sztucznej inteligencji

Utwórz czerwony zespół do przeprowadzenia jednej lub więcej operacji, które dzielą źródło danych i kategorie ryzyka.

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

Co to robi:

  • Tworzy zespół red team do realizacji wszystkich operacji zespołu red team
  • Konfiguruje czerwony zespół z trzema wbudowanymi ewaluatorami (Zabronione działania, Przestrzeganie zadań, Wyciek poufnych danych).

Otrzymasz następujące informacje:

  • Treść JSON z metadanymi grupy, w tym identyfikatorem (zapisz ją jako {{red_team_id}} później).

Zaangażuj czerwony zespół

Użyj tego polecenia, aby sprawdzić, czy czerwony zespół istnieje i przejrzyj konfigurację (kryteria, źródło danych, znaczniki czasu).

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)

Tworzenie (lub aktualizowanie) taksonomii ewaluacyjnej

Aby przeprowadzić czerwony teaming dla kategorii ryzyka agentowych działań zabronionych, musisz mieć możliwość potwierdzenia, edycji lub zaktualizowania taksonomii oceny działań zabronionych generowanych przez przepływ pracy czerwonego teamingu. W następnym przykładzie zostanie wygenerowany plik JSON z wygenerowaną taksonomią zabronionych akcji, które mają być używane w dynamicznym generowaniu monitów o atak w celu przetestowania zachowania agenta na podstawie zasad zatwierdzonych przez użytkownika. Po przejrzeniu i potwierdzeniu taksonomii zostanie ona wykorzystana do utworzenia przebiegu zespołu atakującego, a także oceny współczynnika powodzenia ataku (ASR) wyników działania agenta.

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

Co to robi:

  • Tworzy/aktualizuje zasób taksonomii o nazwie {{name}} :
    • Definiuje docelowy obiekt agenta i opisy narzędzi
    • Określa kategorie ryzyka ProhibitedActions

Odwołujesz się do niego

  • za pośrednictwem identyfikatora file_id URI w żądaniu utworzenia uruchomienia .

Tworzenie przebiegu w czerwonym zespole

Przebieg generuje elementy z określonego źródła (na przykład taksonomii) i angażuje red teams do symulowania ataków na agenta docelowego za pomocą wybranych strategii ataku.

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

Pola klucza do skonfigurowania przebiegu:

  • attack_strategies: Na przykład "Flip", "Base64", "IndirectJailbreak" (wybierz te, które chcesz przetestować)
  • num_turns: głębokość wieloełowa dla wygenerowanych elementów red-team
  • source.id: wskazuje taksonomię według identyfikatora URI pliku
  • target: agent testowy (nazwa, wersja, narzędzia)

Otrzymasz

  • Obiekt uruchomienia, w tym id (zapisz jako {{eval_run_id}})

Pobieranie czerwonego przebiegu tworzenia zespołu (według identyfikatora)

Użyj tego polecenia, aby sprawdzić status operacji red team (na przykład w kolejce, uruchomiono, zakończono sukcesem, zakończono niepowodzeniem).

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)

Uwaga

API jest synchroniczne na żądanie, ale procesy same w sobie są przetwarzane po stronie serwera; odpytywuj ten punkt końcowy do momentu zakończenia przed pobraniem elementów wyjściowych.

Wymień elementy wyjściowe i wyniki red teamingu

Użyj tego, aby sprawdzić metryki podsumowujące po zakończeniu przeprowadzenia testów 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}")

Powiązana zawartość

  • Last updated on