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:
- Completa i prerequisiti
- (Facoltativo) Configura l'agente per il deployment
- Crea un'istanza di Gemini Enterprise Agent Platform
- (Facoltativo) Recupera l'ID risorsa dell'agente
- (Facoltativo) Elenca le operazioni supportate
- (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à:
(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 indeveloper_connect_source.dir.entrypoint_object(str): il nome dell'oggetto richiamabile all'interno dientrypoint_moduleche 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:
- Il servizio Agent Runtime recupera il codice sorgente dalla revisione del repository Git specificata.
- Il servizio installa le dipendenze da
requirements_file(se fornite). - Il servizio avvia l'applicazione dell'agente utilizzando i valori
entrypoint_moduleeentrypoint_objectspecificati.
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:
remote_agent.api_resourcecon informazioni sull'agente di cui è stato eseguito il deployment. Puoi anche chiamareremote_agent.operation_schemas()per restituire l'elenco delle operazioni supportate daremote_agent. Per maggiori dettagli, consulta Operazioni supportate.remote_agent.api_clientche consente interazioni sincrone tra i servizi.remote_agent.async_api_clientche consente interazioni asincrone tra i servizi.
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 esempiohttps://github.com/OWNER/REPO.git). L'URL non può contenere credenziali, comeuser: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 ingit_source.dir.entrypoint_object(str): il nome dell'oggetto richiamabile all'interno dientrypoint_moduleche 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 camponame,api_modee un campoparametersfacoltativo. 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 agit_source.dir(o alla directory root del repository sedirnon è impostato). Il valore predefinito èrequirements.txt.
Il deployment richiede alcuni minuti, durante i quali i seguenti passaggi vengono eseguiti in background:
- Il servizio Agent Runtime clona il repository alla revisione specificata.
- Il servizio installa le dipendenze da
requirements_file(se il file esiste). - Il servizio avvia l'applicazione dell'agente utilizzando i valori
entrypoint_moduleeentrypoint_objectspecificati.
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:
remote_agent.api_resourcecon informazioni sull'agente di cui è stato eseguito il deployment. Puoi anche chiamareremote_agent.operation_schemas()per restituire l'elenco delle operazioni supportate daremote_agent. Per maggiori dettagli, consulta Operazioni supportate.remote_agent.api_clientche consente interazioni sincrone tra i servizi.remote_agent.async_api_clientche consente interazioni asincrone tra i servizi.
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 insource_packagesnon 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 dientrypoint_moduleche 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 camponame,api_modee un campoparametersfacoltativo. 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 insource_packages. Il valore predefinito èrequirements.txtnella directory root dell'origine pacchettizzata.
Il deployment richiede alcuni minuti, durante i quali i seguenti passaggi vengono eseguiti in background:
- L'SDK Agent Platform crea un archivio
tar.gzdei percorsi specificati insource_packages. - Questo archivio viene codificato e inviato direttamente all'API Agent Platform.
- 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 valorientrypoint_moduleeentrypoint_objectspecificati.
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:
remote_agent.api_resourcecon informazioni sull'agente di cui è stato eseguito il deployment. Puoi anche chiamareremote_agent.operation_schemas()per restituire l'elenco delle operazioni supportate daremote_agent. Per maggiori dettagli, consulta Operazioni supportate.remote_agent.api_clientche consente interazioni sincrone tra i servizi.remote_agent.async_api_clientche consente interazioni asincrone tra i servizi.
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:
remote_agent.api_resourcecon informazioni sull'agente di cui è stato eseguito il deployment. Puoi anche chiamareremote_agent.operation_schemas()per restituire l'elenco delle operazioni supportate daremote_agent. Per maggiori dettagli, consulta Operazioni supportate.remote_agent.api_clientche consente interazioni sincrone tra i servizi.remote_agent.async_api_clientche consente interazioni asincrone tra i servizi.
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:
remote_agent.api_resourcecon informazioni sull'agente di cui è stato eseguito il deployment. Puoi anche chiamareremote_agent.operation_schemas()per restituire l'elenco delle operazioni supportate daremote_agent. Per maggiori dettagli, consulta Operazioni supportate.remote_agent.api_clientche consente interazioni sincrone tra i servizi.remote_agent.async_api_clientche consente interazioni asincrone tra i servizi.
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:
- Un bundle dei seguenti artefatti viene generato localmente:
*.pklun file pickle corrispondente a local_agent.requirements.txtun file di testo contenente i requisiti del pacchetto.dependencies.tar.gzun file tar contenente eventuali pacchetti aggiuntivi.
- Il bundle viene caricato su Cloud Storage (nella cartella corrispondente) per la gestione temporanea degli artefatti.
- Gli URI Cloud Storage per i rispettivi artefatti sono specificati in PackageSpec.
- 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:
remote_agent.api_resourcecon informazioni sull'agente di cui è stato eseguito il deployment. Puoi anche chiamareremote_agent.operation_schemas()per restituire l'elenco delle operazioni supportate daremote_agent. Per maggiori dettagli, consulta Operazioni supportate.remote_agent.api_clientche consente interazioni sincrone tra i servizi.remote_agent.async_api_clientche consente interazioni asincrone tra i servizi.
(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 risorsareasoningEngine.
(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
Gestisci gli agenti di cui è stato eseguito il deployment
Scopri come gestire gli agenti di cui è stato eseguito il deployment nel runtime gestito di Agent Platform.