Esegui il deployment di un agente

Il deployment di un agente su Agent Runtime lo rende disponibile da remoto per gestire le richieste. Questo documento spiega i modi per eseguire il deployment di un agente in base al tuo flusso di lavoro di sviluppo: da un oggetto di esecuzione, file di origine locali, un Dockerfile, un'immagine container ospitata in Artifact Registry, un repository Git pubblico o direttamente tramite un repository Git connesso.

Per eseguire il deployment di un agente su Agent Runtime, scegli tra i seguenti metodi:

Developer Connect

Consigliato per i progetti gestiti in un repository Git collegato tramite Developer Connect. Questo metodo semplifica il deployment degli agenti direttamente dal codice sorgente e supporta in modo nativo il controllo della versione, la collaborazione tra team e le pipeline CI/CD. Prima di utilizzare questo metodo, configura il link al repository Git seguendo le istruzioni riportate in Configura il link al repository Git di Developer Connect.

Puoi utilizzare questo metodo di deployment solo con Python.

Repository Git pubblico

Adatto per i progetti in un repository Git pubblico a cui puoi accedere tramite HTTPS. Questo metodo consente di eseguire il deployment direttamente dall'URL del repository senza configurare una connessione Developer Connect o un link al repository Git. Questo metodo supporta solo i repository pubblici. Per eseguire il deployment da un repository privato, utilizza Developer Connect.

Puoi utilizzare questo metodo di deployment solo con Python.

File di origine

Ideale per workflow automatizzati come pipeline CI/CD e strumenti di infrastructure as code come Terraform, che consentono deployment completamente dichiarativi e automatizzati. Esegue il deployment dell'agente direttamente dal codice sorgente locale e non richiede un bucket Cloud Storage.

Puoi utilizzare questo metodo di deployment solo con Python.

Dockerfile

Simile al deployment dai file di origine. Esegui il deployment dell'agente direttamente dal codice sorgente locale senza bisogno di un bucket Cloud Storage. Questo metodo è appropriato se devi definire e controllare il server API di cui viene eseguito il deployment. Il container di cui è stato eseguito il deployment deve rispettare il contratto runtime.

Puoi utilizzare questo metodo di deployment con qualsiasi linguaggio.

Immagine container

Simile al deployment da Dockerfile. Esegui il deployment di un'immagine container ospitata in Artifact Registry. Utilizza questo metodo se hai bisogno di controllare il processo di build per l'immagine container e di una latenza di deployment inferiore. L'immagine container deve rispettare il contratto di runtime.

Puoi utilizzare questo metodo di deployment con qualsiasi linguaggio.

SDK Agent Platform

Ideale per lo sviluppo interattivo in ambienti come Colab, consente il deployment di oggetti local_agent in memoria. Questo metodo funziona meglio per gli agenti con strutture che non contengono componenti complessi e non serializzabili.

Per iniziare, segui questi passaggi:

  1. Completa i prerequisiti
  2. (Facoltativo) Configura l'agente per il deployment
  3. Crea un'istanza di Gemini Enterprise Agent Platform
  4. (Facoltativo) Recupera l'ID risorsa dell'agente
  5. (Facoltativo) Elenca le operazioni supportate
  6. (Facoltativo) Concedi le autorizzazioni all'agente di cui è stato eseguito il deployment

Prerequisiti

Prima di eseguire il deployment di un agente, assicurati di aver completato le seguenti attività:

  1. Configura l'ambiente
  2. Crea un agente

(Facoltativo) Configura l'agente per il deployment

Puoi configurare impostazioni facoltative per l'agente. Gli esempi in questa sezione utilizzano Python.

Crea un'istanza di Agent Platform

Questa sezione descrive come creare un'istanza di Agent Platform per il deployment di un agente. Puoi scegliere tra i seguenti metodi:

Developer Connect

Per eseguire il deployment da Developer Connect su Agent Platform, utilizza client.runtimes.create fornendo developer_connect_source, entrypoint_module e entrypoint_object nel dizionario di configurazione, insieme ad altre configurazioni facoltative. Questo metodo ti consente di eseguire il deployment del codice direttamente da un repository Git connesso.

Puoi utilizzare questo metodo di deployment solo con Python.

remote_agent = client.runtimes.create(
    config={
        "developer_connect_source": {                   # Required.
            "git_repository_link": "projects/PROJECT_ID/locations/LOCATION/connections/CONNECTION_ID/gitRepositoryLinks/REPO_ID",
            "revision": "main",
            "dir": "path/to/dir",
        },
        "entrypoint_module": "agent",                   # Required.
        "entrypoint_object": "root_agent",              # Required.
        "requirements_file": "requirements.txt",        # Optional.
        # Other optional configs:
        # "env_vars": {...},
        # "service_account": "...",
    },
)

I parametri per il deployment di Developer Connect sono:

  • developer_connect_source (dict): la configurazione per il recupero del codice sorgente. Per maggiori dettagli, consulta Configura il link al repository Git di Developer Connect.
    • git_repository_link (str): il nome della risorsa del link al repository Git di Developer Connect.
    • revision (str): la revisione da recuperare (branch, tag o SHA di commit).
    • dir (str): la directory root del codice dell'agente all'interno del repository.
  • entrypoint_module (str): il nome del modulo Python contenente l'entrypoint dell'agente, relativo alla directory specificata in developer_connect_source.dir.
  • entrypoint_object (str): il nome dell'oggetto richiamabile all'interno di entrypoint_module che rappresenta l'applicazione dell'agente (ad esempio, root_agent).
  • requirements_file (str): facoltativo. Il percorso di un file dei requisiti pip relativo alla root sorgente. Il valore predefinito è requirements.txt.

Il deployment richiede alcuni minuti, durante i quali i seguenti passaggi vengono eseguiti in background:

  1. Il servizio Agent Runtime recupera il codice sorgente dalla revisione del repository Git specificata.
  2. Il servizio installa le dipendenze da requirements_file (se fornite).
  3. Il servizio avvia l'applicazione dell'agente utilizzando i valori entrypoint_module e entrypoint_object specificati.

La latenza di deployment dipende dal tempo totale necessario per installare i pacchetti richiesti. Una volta eseguito il deployment, remote_agent corrisponde a un'istanza di local_agent in esecuzione su Agent Platform e può essere sottoposta a query o eliminata.

L'oggetto remote_agent corrisponde a una classe AgentRuntime che contiene quanto segue:

Repository Git pubblico

Per eseguire il deployment da un repository Git pubblico su Agent Platform, utilizza client.runtimes.create fornendo git_source, entrypoint_module, entrypoint_object e class_methods nel dizionario di configurazione, insieme ad altre configurazioni facoltative. Per eseguire il deployment da un repository privato, utilizza Developer Connect.

Puoi utilizzare questo metodo di deployment solo con Python.

remote_agent = client.runtimes.create(
    config={
        "git_source": {                                 # Required.
            "url": "https://github.com/OWNER/REPO.git", # Required.
            "revision": "main",                         # Required.
            "dir": "path/to/dir",                       # Optional.
        },
        "entrypoint_module": "agent",                   # Required.
        "entrypoint_object": "root_agent",              # Required.
        "class_methods": class_methods,                 # Required.
        "requirements_file": "requirements.txt",        # Optional.
        # Other optional configs:
        # "env_vars": {...},
        # "service_account": "...",
    },
)

I parametri per il deployment del repository Git pubblico sono:

  • git_source (dict): la configurazione per il recupero del codice sorgente da un repository Git pubblico.
    • url (str): l'URL HTTPS di un repository Git pubblico (ad esempio https://github.com/OWNER/REPO.git). L'URL non può contenere credenziali, come user:password@.
    • revision (str): un branch, un tag o un SHA di commit completo da recuperare. Gli SHA dei commit abbreviati non sono supportati.
    • dir (str): (facoltativo) la directory, relativa alla directory root del repository, in cui viene eseguita la build. Viene eseguito il deployment solo dei contenuti di questa directory. Se non viene impostata, viene utilizzata la directory root del repository. Il percorso non può iniziare con / o contenere segmenti ...
  • entrypoint_module (str): il nome del modulo Python contenente l'entrypoint dell'agente, relativo alla directory specificata in git_source.dir.
  • entrypoint_object (str): il nome dell'oggetto richiamabile all'interno di entrypoint_module che rappresenta l'applicazione dell'agente (ad esempio, root_agent).
  • class_methods (list[dict]): un elenco di dizionari che definiscono i metodi esposti dell'agente. Ogni dizionario include un campo name, api_mode e un campo parameters facoltativo. Per saperne di più sui metodi per un agente personalizzato, consulta Elenco delle operazioni supportate.
  • requirements_file (str): (facoltativo) il percorso di un file dei requisiti pip relativo a git_source.dir (o alla directory root del repository se dir non è impostato). Il valore predefinito è requirements.txt.

Il deployment richiede alcuni minuti, durante i quali i seguenti passaggi vengono eseguiti in background:

  1. Il servizio Agent Runtime clona il repository alla revisione specificata.
  2. Il servizio installa le dipendenze da requirements_file (se il file esiste).
  3. Il servizio avvia l'applicazione dell'agente utilizzando i valori entrypoint_module e entrypoint_object specificati.

La latenza di deployment dipende dal tempo totale necessario per installare i pacchetti richiesti. Una volta eseguito il deployment, remote_agent corrisponde all'agente in esecuzione su Agent Platform e può essere sottoposto a query o eliminato.

L'oggetto remote_agent corrisponde a una classe AgentRuntime che contiene quanto segue:

File di origine

Per eseguire il deployment dai file di origine su Agent Platform, utilizza client.runtimes.create fornendo source_packages, entrypoint_module, entrypoint_object e class_methods nel dizionario di configurazione, insieme ad altre configurazioni facoltative. Con questo metodo, non è necessario passare un oggetto agente o un bucket Cloud Storage.

Puoi utilizzare questo metodo di deployment solo con Python.

# Example file structure:
# /agent_directory
#     ├── agent.py
#     ├── requirements.txt

# Example agent_directory/agent.py:
# class MyAgent:
#     def ask(self, question: str) -> str:
#         return f"Answer to {question}"
# root_agent = MyAgent()

remote_agent = client.runtimes.create(
    config={
        "source_packages": source_packages,             # Required.
        "entrypoint_module": entrypoint_module,         # Required.
        "entrypoint_object": entrypoint_object,         # Required.
        "class_methods": class_methods,                 # Required.
        "requirements_file": requirements_file,         # Optional.
        "display_name": display_name,                   # Optional.
        "description": description,                     # Optional.
        "labels": labels,                               # Optional.
        "env_vars": env_vars,                           # Optional.
        "build_options": build_options,                 # Optional.
        "identity_type": identity_type,                 # Optional.
        "service_account": service_account,             # Optional.
        "min_instances": min_instances,                 # Optional.
        "max_instances": max_instances,                 # Optional.
        "resource_limits": resource_limits,             # Optional.
        "container_concurrency": container_concurrency, # Optional
        "encryption_spec": encryption_spec,             # Optional.
        "agent_framework": agent_framework,             # Optional.
    },
)

I parametri per il deployment dell'origine incorporata sono:

  • source_packages (list[str]): un elenco di percorsi di file o directory locali da includere nel deployment. Le dimensioni totali dei file e delle directory in source_packages non devono superare gli 8 MB.
  • entrypoint_module (str): il nome completo del modulo Python contenente l'entrypoint dell'agente (ad esempio, agent_dir.agent).
  • entrypoint_object (str): il nome dell'oggetto richiamabile all'interno di entrypoint_module che rappresenta l'applicazione dell'agente (ad esempio, root_agent).
  • class_methods (list[dict]): un elenco di dizionari che definiscono i metodi esposti dell'agente. Ogni dizionario include un campo name, api_mode e un campo parameters facoltativo. Per saperne di più sui metodi per un agente personalizzato, consulta Elenco delle operazioni supportate.

    Ad esempio:

    class_methods = [
        {
            "name": "method_name",
            "api_mode": "",  # Options: "", "async", "async_stream", "stream", "bidi_stream"
            "parameters": {
                "type": "object",
                "properties": {
                    "param1": {"type": "string", "description": "Description of param1"},
                    "param2": {"type": "integer"}
                },
                "required": ["param1"]
            }
        }
    ]
  • requirements_file (str): facoltativo. Il percorso di un file dei requisiti pip all'interno dei percorsi specificati in source_packages. Il valore predefinito è requirements.txt nella directory root dell'origine pacchettizzata.

Il deployment richiede alcuni minuti, durante i quali i seguenti passaggi vengono eseguiti in background:

  1. L'SDK Agent Platform crea un archivio tar.gz dei percorsi specificati in source_packages.
  2. Questo archivio viene codificato e inviato direttamente all'API Agent Platform.
  3. Il servizio Agent Runtime riceve l'archivio, lo estrae, installa le dipendenze da requirements_file (se fornite) e avvia l'applicazione dell'agente utilizzando i valori entrypoint_module e entrypoint_object specificati.

La latenza di deployment dipende dal tempo totale necessario per installare i pacchetti richiesti. Una volta eseguito il deployment, remote_agent corrisponde a un'istanza di local_agent in esecuzione su Agent Platform e può essere sottoposta a query o eliminata.

L'oggetto remote_agent corrisponde a una classe AgentRuntime che contiene quanto segue:

Dockerfile

Il deployment da un Dockerfile su Agent Platform segue un approccio simile a quello del deployment dai file di origine, con la differenza che includi un Dockerfile nei file di origine e specifichi image_spec nella configurazione anziché entrypoint_module, entrypoint_object e requirements_file. Il container creato dal Dockerfile deve rimanere in ascolto delle richieste HTTP su 0.0.0.0 sulla porta 8080 e rispettare il contratto di runtime.

Puoi utilizzare questo metodo di deployment con qualsiasi linguaggio.

Innanzitutto, crea un Dockerfile nella directory root del progetto che installi le dipendenze e avvii il server HTTP su 0.0.0.0:8080:

Python

FROM python:3.13-slim
WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

EXPOSE 8080

# Start an ADK API server or custom FastAPI server on 0.0.0.0:8080:
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8080"]

Vai

FROM golang:1.24 AS builder
WORKDIR /app

COPY go.mod go.sum ./
RUN go mod download

COPY . .
RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o /app/server .

FROM gcr.io/distroless/static-debian12
WORKDIR /app
COPY --from=builder /app/server /app/server

EXPOSE 8080

# For an ADK Go agent using the built-in launcher:
# CMD ["/app/server", "web", "-host", "0.0.0.0", "-port", "8080", "agentengine"]
# For a custom Go HTTP server listening on 0.0.0.0:8080:
CMD ["/app/server"]

TypeScript

FROM node:22-slim
WORKDIR /app

COPY package*.json ./
RUN npm ci

COPY . .
RUN npm run build

EXPOSE 8080

# For an ADK TypeScript agent (with @google/adk-devtools in package.json):
# CMD ["npx", "adk", "api_server", "/app/agents/my_agent", "--host=0.0.0.0", "--port=8080"]
# For a custom Node.js HTTP server listening on 0.0.0.0:8080:
CMD ["node", "dist/index.js"]

Java

FROM maven:3.9-eclipse-temurin-17
WORKDIR /app

COPY pom.xml .
COPY src ./src
RUN mvn package -DskipTests

EXPOSE 8080

# For an ADK Java agent using AdkWebServer (set --server.address=0.0.0.0):
# CMD ["sh", "-c", "mvn exec:java -Dexec.mainClass=com.google.adk.web.AdkWebServer -Dexec.args='--server.address=0.0.0.0 --server.port=${PORT:-8080} --adk.agents.source-dir=.'"]
# For a packaged Java HTTP server JAR listening on 0.0.0.0:8080:
CMD ["java", "-jar", "target/app.jar"]

Se il tuo container implementa gli endpoint di routing del contratto di runtime (/api/reasoning_engine e /api/stream_reasoning_engine, esposti anche dal launcher ADK Go agentengine), dichiara le operazioni supportate in class_methods (o spec.classMethods in REST) in modo da poter richiamare l'agente tramite richieste query e streamQuery standard. Se il container esegue il server API ADK (ad esempio npx adk api_server per TypeScript o AdkWebServer per Java), richiama i relativi endpoint /run e /run_sse tramite il proxy API sottostante (/api/run e /api/run_sse).

Successivamente, esegui il deployment dell'agente dai file di origine locali e da Dockerfile utilizzando l'SDK Agent Platform, l'API REST o Terraform:

SDK Agent Platform

# Example file structure:
# /current_directory
#     ├── agent.py
#     ├── main.py
#     ├── requirements.txt
#     ├── Dockerfile
#
# For other languages, pass your project's source files and Dockerfile in source_packages:
#   Go:         ["main.go", "go.mod", "go.sum", "Dockerfile"]
#   TypeScript: ["src", "package.json", "package-lock.json", "tsconfig.json", "Dockerfile"]
#   Java:       ["src", "pom.xml", "Dockerfile"]

remote_agent = client.runtimes.create(
    config={
        "source_packages": [
            "agent.py",
            "main.py",
            "requirements.txt",
            "Dockerfile",
        ],
        "image_spec": {},  # tells Agent Runtime to use the Dockerfile
        # Optional: declare class_methods if your container implements /api/reasoning_engine or /api/stream_reasoning_engine
        # "class_methods": class_methods,
        # Other optional configs
        "display_name": "Dockerfile agent",
    }
)

La latenza di deployment dipende dal tempo totale necessario per creare l'immagine container e installare i pacchetti richiesti. Una volta eseguito il deployment, remote_agent corrisponde al tuo agente in esecuzione sulla piattaforma dell'agente e può essere sottoposto a query o eliminato.

L'oggetto remote_agent corrisponde a una classe AgentRuntime che contiene quanto segue:

REST

Crea un pacchetto dei file di origine Dockerfile e dell'applicazione a livello root di un archivio .tar.gz (massimo 8 MB), codifica l'archivio in base64 e invia una richiesta POST al metodo reasoningEngines.create:

# Package your Dockerfile and source files at the root of a tar.gz archive
# (replace main.py and requirements.txt with your project's source files):
tar -czf /tmp/source.tar.gz Dockerfile main.py requirements.txt

curl -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/reasoningEngines" \
  -d "{
    \"displayName\": \"Dockerfile agent\",
    \"spec\": {
      \"sourceCodeSpec\": {
        \"inlineSource\": {
          \"sourceArchive\": \"$(base64 < /tmp/source.tar.gz | tr -d '\n')\"
        },
        \"imageSpec\": {}
      }
    }
  }"

La richiesta restituisce un Operation di lunga durata che si risolve nella risorsa ReasoningEngine di cui è stato eseguito il deployment una volta completati la build e il deployment del container.

Immagine container

Per eseguire il deployment da un'immagine container, segui innanzitutto le istruzioni di configurazione per Porta il tuo container per creare l'immagine ed eseguirne il push ad Artifact Registry. Se utilizzi l'SDK Agent Platform per creare l'istanza Agent Platform, assicurati di installare una versione di google-cloud-aiplatform che soddisfi >=1.144. L'immagine container deve rimanere in ascolto delle richieste HTTP su 0.0.0.0 sulla porta 8080 e rispettare il contratto runtime.

Puoi utilizzare questo metodo di deployment con qualsiasi linguaggio.

Gli esempi seguenti mostrano un Dockerfile per la creazione di un'immagine container che rimane in ascolto su 0.0.0.0:8080:

Python

FROM python:3.13-slim
WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

EXPOSE 8080

# Start an ADK API server or custom FastAPI server on 0.0.0.0:8080:
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8080"]

Vai

FROM golang:1.24 AS builder
WORKDIR /app

COPY go.mod go.sum ./
RUN go mod download

COPY . .
RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o /app/server .

FROM gcr.io/distroless/static-debian12
WORKDIR /app
COPY --from=builder /app/server /app/server

EXPOSE 8080

# For an ADK Go agent using the built-in launcher:
# CMD ["/app/server", "web", "-host", "0.0.0.0", "-port", "8080", "agentengine"]
# For a custom Go HTTP server listening on 0.0.0.0:8080:
CMD ["/app/server"]

TypeScript

FROM node:22-slim
WORKDIR /app

COPY package*.json ./
RUN npm ci

COPY . .
RUN npm run build

EXPOSE 8080

# For an ADK TypeScript agent (with @google/adk-devtools in package.json):
# CMD ["npx", "adk", "api_server", "/app/agents/my_agent", "--host=0.0.0.0", "--port=8080"]
# For a custom Node.js HTTP server listening on 0.0.0.0:8080:
CMD ["node", "dist/index.js"]

Java

FROM maven:3.9-eclipse-temurin-17
WORKDIR /app

COPY pom.xml .
COPY src ./src
RUN mvn package -DskipTests

EXPOSE 8080

# For an ADK Java agent using AdkWebServer (set --server.address=0.0.0.0):
# CMD ["sh", "-c", "mvn exec:java -Dexec.mainClass=com.google.adk.web.AdkWebServer -Dexec.args='--server.address=0.0.0.0 --server.port=${PORT:-8080} --adk.agents.source-dir=.'"]
# For a packaged Java HTTP server JAR listening on 0.0.0.0:8080:
CMD ["java", "-jar", "target/app.jar"]

Se il tuo container implementa gli endpoint di routing del contratto di runtime (/api/reasoning_engine e /api/stream_reasoning_engine, esposti anche dal launcher ADK Go agentengine), dichiara le operazioni supportate in class_methods (o spec.classMethods in REST) in modo da poter richiamare l'agente tramite richieste query e streamQuery standard. Se il container esegue il server API ADK (ad esempio npx adk api_server per TypeScript o AdkWebServer per Java), richiama i relativi endpoint /run e /run_sse tramite il proxy API sottostante (/api/run e /api/run_sse).

Dopo aver creato l'immagine container e averla caricata su Artifact Registry, esegui il deployment dell'agente utilizzando l'SDK Agent Platform, l'API REST o Terraform:

SDK Agent Platform

remote_agent = client.runtimes.create(
    config={
        "container_spec": {
            "image_uri": "CONTAINER_IMAGE_URI",
        },
        # Optional: declare class_methods if your container implements /api/reasoning_engine or /api/stream_reasoning_engine
        # "class_methods": class_methods,
        # Other optional configs
        "display_name": "Container image agent",
    },
)

Dove CONTAINER_IMAGE_URI corrisponde all'URI dell'immagine container in Artifact Registry (ad esempio us-central1-docker.pkg.dev/my-project/my-repo/my-image:tag).

Una volta eseguito il deployment, remote_agent corrisponde al tuo agente in esecuzione sulla piattaforma dell'agente e può essere sottoposto a query o eliminato.

L'oggetto remote_agent corrisponde a una classe AgentRuntime che contiene quanto segue:

REST

Invia una richiesta POST al metodo reasoningEngines.create:

curl -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/reasoningEngines" \
  -d '{
    "displayName": "Container image agent",
    "spec": {
      "containerSpec": {
        "imageUri": "CONTAINER_IMAGE_URI"
      }
    }
  }'

Dove CONTAINER_IMAGE_URI corrisponde all'URI dell'immagine container in Artifact Registry (ad esempio us-central1-docker.pkg.dev/my-project/my-repo/my-image:tag). La richiesta restituisce un Operation a lunga esecuzione che si risolve nella risorsa ReasoningEngine di cui è stato eseguito il deployment una volta completato il deployment.

SDK Agent Platform

Per eseguire il deployment dell'agente su Agent Platform, utilizza client.runtimes.create per passare l'oggetto local_agent insieme a eventuali configurazioni facoltative:

remote_agent = client.runtimes.create(
    agent=local_agent,                                  # Optional.
    config={
        "requirements": requirements,                   # Optional.
        "extra_packages": extra_packages,               # Optional.
        "gcs_dir_name": gcs_dir_name,                   # Optional.
        "display_name": display_name,                   # Optional.
        "description": description,                     # Optional.
        "labels": labels,                               # Optional.
        "env_vars": env_vars,                           # Optional.
        "build_options": build_options,                 # Optional.
        "identity_type": identity_type,                 # Optional.
        "service_account": service_account,             # Optional.
        "min_instances": min_instances,                 # Optional.
        "max_instances": max_instances,                 # Optional.
        "resource_limits": resource_limits,             # Optional.
        "container_concurrency": container_concurrency, # Optional
        "encryption_spec": encryption_spec,             # Optional.
        "agent_framework": agent_framework,             # Optional.
    },
)

Il deployment richiede alcuni minuti, durante i quali i seguenti passaggi vengono eseguiti in background:

  1. Un bundle dei seguenti artefatti viene generato localmente:
  2. Il bundle viene caricato su Cloud Storage (nella cartella corrispondente) per la gestione temporanea degli artefatti.
  3. Gli URI Cloud Storage per i rispettivi artefatti sono specificati in PackageSpec.
  4. Il servizio Agent Runtime riceve la richiesta, crea i container e avvia i server HTTP sul backend.

La latenza di deployment dipende dal tempo totale necessario per installare i pacchetti richiesti. Una volta eseguito il deployment, remote_agent corrisponde a un'istanza di local_agent in esecuzione su Agent Platform e può essere sottoposta a query o eliminata.

L'oggetto remote_agent corrisponde a una classe AgentRuntime che contiene quanto segue:

(Facoltativo) Ottieni l'ID risorsa dell'agente

Ogni agente di cui è stato eseguito il deployment ha un identificatore univoco. Puoi eseguire il comando seguente per ottenere il nome della risorsa per l'agente di cui hai eseguito il deployment:

remote_agent.api_resource.name

La risposta dovrebbe essere simile alla seguente stringa:

"projects/PROJECT_NUMBER/locations/LOCATION/reasoningEngines/RESOURCE_ID"

dove

  • PROJECT_ID è l'ID progetto Google Cloud in cui viene eseguito l'agente di cui è stato eseguito il deployment.

  • LOCATION è la regione in cui viene eseguito l'agente di cui è stato eseguito il deployment.

  • RESOURCE_ID è l'ID dell'agente di cui è stato eseguito il deployment come risorsa reasoningEngine.

(Facoltativo) Elenca le operazioni supportate

Ogni agente di cui è stato eseguito il deployment ha un elenco di operazioni supportate. Puoi utilizzare AgentRuntime.operation_schemas per ottenere l'elenco delle operazioni supportate dall'agente di cui è stato eseguito il deployment:

remote_agent.operation_schemas()

Lo schema di ogni operazione è un dizionario che documenta le informazioni di un metodo per l'agente che puoi chiamare. L'insieme di operazioni supportate dipende dal framework utilizzato per sviluppare l'agente:

(Facoltativo) Concedi le autorizzazioni all'agente di cui è stato eseguito il deployment

Se all'agente di cui è stato eseguito il deployment devono essere concesse autorizzazioni aggiuntive, segui le istruzioni riportate in Configura l'identità e le autorizzazioni per l'agente.

(Facoltativo) Esegui il deployment degli agenti con l'infrastruttura aziendale

Per eseguire il deployment dell'agente con un ambiente completo che include livelli di sicurezza e governance, copia e personalizza i seguenti template di Application Design Center:

Passaggi successivi

Guida

Scopri come gestire gli agenti di cui è stato eseguito il deployment nel runtime gestito di Agent Platform.

Guida

Utilizza un agente con Agent Platform Runtime.