Le déploiement d'un agent sur Agent Runtime le rend disponible à distance pour traiter les requêtes. Ce document explique comment déployer un agent en fonction de votre workflow de développement : à partir d'un objet d'exécution, de fichiers sources locaux, d'un Dockerfile, d'une image de conteneur hébergée dans Artifact Registry, d'un dépôt Git public ou directement via un dépôt Git connecté.
Pour déployer un agent sur Agent Runtime, choisissez l'une des méthodes suivantes :
Developer Connect
Recommandé pour les projets gérés dans un dépôt Git et associés via Developer Connect. Cette méthode simplifie le déploiement des agents directement à partir de votre code source et accepte de manière native le contrôle des versions, la collaboration en équipe et les pipelines CI/CD. Avant d'utiliser cette méthode, configurez votre lien de dépôt Git en suivant les instructions de la section Configurer un lien de dépôt Git Developer Connect.
Vous ne pouvez utiliser cette méthode de déploiement qu'avec Python.
Dépôt Git public
Adapté aux projets d'un dépôt Git public auquel vous pouvez accéder via HTTPS. Cette méthode vous permet de déployer directement à partir de l'URL du dépôt sans configurer de connexion Developer Connect ni de lien vers un dépôt Git. Cette méthode n'est compatible qu'avec les dépôts publics. Pour déployer à partir d'un dépôt privé, utilisez Developer Connect.
Vous ne pouvez utiliser cette méthode de déploiement qu'avec Python.
Fichiers sources
Idéal pour les workflows automatisés tels que les pipelines CI/CD et les outils d'infrastructure as code comme Terraform, permettant des déploiements entièrement déclaratifs et automatisés. Il déploie votre agent directement à partir du code source local et ne nécessite pas de bucket Cloud Storage.
Vous ne pouvez utiliser cette méthode de déploiement qu'avec Python.
Dockerfile
Semblable au déploiement à partir de fichiers sources. Vous déployez votre agent directement à partir du code source local sans avoir besoin d'un bucket Cloud Storage. Cette méthode est appropriée si vous devez définir et contrôler le serveur d'API déployé. Le conteneur déployé doit respecter le contrat d'exécution.
Vous pouvez utiliser cette méthode de déploiement avec n'importe quel langage.
Image de conteneur
Semblable au déploiement à partir d'un Dockerfile. Vous déployez une image de conteneur hébergée dans Artifact Registry. Utilisez cette méthode si vous souhaitez contrôler le processus de compilation de l'image de conteneur et réduire la latence de déploiement. L'image de conteneur doit respecter le contrat d'exécution.
Vous pouvez utiliser cette méthode de déploiement avec n'importe quel langage.
SDK Agent Platform
Idéal pour le développement interactif dans des environnements tels que Colab, permettant le déploiement d'objets local_agent en mémoire. Cette méthode est particulièrement adaptée aux agents dont les structures ne contiennent pas de composants complexes non sérialisables.
Pour commencer, procédez comme suit :
- Effectuer les opérations prérequises
- Facultatif : Configurer votre agent pour le déploiement
- Créer une instance Gemini Enterprise Agent Platform
- (Facultatif) Obtenir l'ID de ressource de l'agent
- Facultatif : Répertorier les opérations compatibles
- Facultatif : Accordez des autorisations à l'agent déployé
Prérequis
Avant de déployer un agent, assurez-vous d'avoir effectué les tâches suivantes :
Facultatif : Configurer votre agent pour le déploiement
Vous pouvez configurer des paramètres facultatifs pour votre agent. Les exemples de cette section utilisent Python.
Créer une instance Agent Platform
Cette section explique comment créer une instance Agent Platform pour déployer un agent. Vous avez le choix entre les méthodes suivantes :
Developer Connect
Pour déployer depuis Developer Connect sur Agent Platform, utilisez client.runtimes.create en fournissant developer_connect_source, entrypoint_module et entrypoint_object dans le dictionnaire de configuration, ainsi que d'autres configurations facultatives. Cette méthode vous permet de déployer du code directement depuis un dépôt Git connecté.
Vous ne pouvez utiliser cette méthode de déploiement qu'avec 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": "...", }, )
Les paramètres du déploiement Developer Connect sont les suivants :
developer_connect_source(dict) : configuration pour récupérer le code source. Pour en savoir plus, consultez Configurer un lien de dépôt Git Developer Connect.git_repository_link(str) : nom de ressource du lien du dépôt Git Developer Connect.revision(str) : révision à récupérer (branche, tag ou SHA de commit).dir(str) : répertoire racine du code de l'agent dans le dépôt.
entrypoint_module(str) : nom du module Python contenant le point d'entrée de l'agent, par rapport au répertoire spécifié dansdeveloper_connect_source.dir.entrypoint_object(str) : nom de l'objet appelable dans leentrypoint_modulequi représente l'application de l'agent (par exemple,root_agent).requirements_file(str) : (facultatif) chemin d'accès à un fichier d'exigences pip par rapport à la racine source. La valeur par défaut estrequirements.txt.
Le déploiement prend quelques minutes, pendant lesquelles les étapes suivantes se déroulent en arrière-plan :
- Le service Agent Runtime récupère le code source à partir de la révision du dépôt Git spécifiée.
- Le service installe les dépendances à partir de
requirements_file(si fourni). - Le service démarre l'application de l'agent à l'aide des valeurs
entrypoint_moduleetentrypoint_objectspécifiées.
La latence de déploiement dépend du temps total nécessaire à l'installation des packages requis. Une fois déployé, remote_agent correspond à une instance de local_agent qui s'exécute sur Agent Platform et peut être interrogée ou supprimée.
L'objet remote_agent correspond à une classe AgentRuntime qui contient les éléments suivants :
remote_agent.api_resourceavec des informations sur l'agent déployé. Vous pouvez également appelerremote_agent.operation_schemas()pour renvoyer la liste des opérations compatibles avecremote_agent. Pour en savoir plus, consultez Opérations compatibles.remote_agent.api_clientqui permet des interactions de service synchrones.remote_agent.async_api_clientqui permet des interactions de service asynchrones.
Dépôt Git public
Pour déployer à partir d'un dépôt Git public sur Agent Platform, utilisez client.runtimes.create en fournissant git_source, entrypoint_module, entrypoint_object et class_methods dans le dictionnaire de configuration, ainsi que d'autres configurations facultatives. Pour déployer à partir d'un dépôt privé, utilisez Developer Connect.
Vous ne pouvez utiliser cette méthode de déploiement qu'avec 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": "...", }, )
Les paramètres de déploiement d'un dépôt Git public sont les suivants :
git_source(dict) : configuration permettant de récupérer le code source à partir d'un dépôt Git public.url(str) : URL HTTPS d'un dépôt Git public (par exemple,https://github.com/OWNER/REPO.git). L'URL ne peut pas contenir d'identifiants, tels queuser:password@.revision(str) : branche, tag ou SHA de commit complet à récupérer. Les SHA de commit abrégés ne sont pas acceptés.dir(str) : (facultatif) répertoire, relatif à la racine du dépôt, dans lequel la compilation est exécutée. Seul le contenu de ce répertoire est déployé. Si ce paramètre n'est pas défini, la racine du dépôt est utilisée. Le chemin d'accès ne peut pas commencer par/ni contenir de segments...
entrypoint_module(str) : nom du module Python contenant le point d'entrée de l'agent, par rapport au répertoire spécifié dansgit_source.dir.entrypoint_object(str) : nom de l'objet appelable dans leentrypoint_modulequi représente l'application de l'agent (par exemple,root_agent).class_methods(list[dict]) : liste de dictionnaires qui définissent les méthodes exposées de l'agent. Chaque dictionnaire inclut un champname, un champapi_modeet un champparametersfacultatif. Pour en savoir plus sur les méthodes d'un agent personnalisé, consultez Répertorier les opérations compatibles.requirements_file(str) : (facultatif) chemin d'accès à un fichier d'exigences pip par rapport àgit_source.dir(ou à la racine du dépôt sidirn'est pas défini). La valeur par défaut estrequirements.txt.
Le déploiement prend quelques minutes, pendant lesquelles les étapes suivantes se déroulent en arrière-plan :
- Le service Agent Runtime clone le dépôt à la révision spécifiée.
- Le service installe les dépendances à partir de
requirements_file(si le fichier existe). - Le service démarre l'application de l'agent à l'aide des valeurs
entrypoint_moduleetentrypoint_objectspécifiées.
La latence de déploiement dépend du temps total nécessaire à l'installation des packages requis. Une fois déployé, remote_agent correspond à votre agent exécuté sur Agent Platform et peut être interrogé ou supprimé.
L'objet remote_agent correspond à une classe AgentRuntime qui contient les éléments suivants :
remote_agent.api_resourceavec des informations sur l'agent déployé. Vous pouvez également appelerremote_agent.operation_schemas()pour renvoyer la liste des opérations compatibles avecremote_agent. Pour en savoir plus, consultez Opérations compatibles.remote_agent.api_clientqui permet des interactions de service synchrones.remote_agent.async_api_clientqui permet des interactions de service asynchrones.
Fichiers sources
Pour déployer à partir de fichiers sources sur Agent Platform, utilisez client.runtimes.create en fournissant source_packages, entrypoint_module, entrypoint_object et class_methods dans le dictionnaire de configuration, ainsi que d'autres configurations facultatives. Avec cette méthode, vous n'avez pas besoin de transmettre un objet d'agent ni un bucket Cloud Storage.
Vous ne pouvez utiliser cette méthode de déploiement qu'avec 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. }, )
Les paramètres du déploiement de source intégrée sont les suivants :
source_packages(list[str]) : liste des chemins d'accès aux fichiers ou répertoires locaux à inclure dans le déploiement. La taille totale des fichiers et des répertoires danssource_packagesne doit pas dépasser 8 Mo.entrypoint_module(str) : nom complet du module Python contenant le point d'entrée de l'agent (par exemple,agent_dir.agent).entrypoint_object(str) : nom de l'objet appelable dans leentrypoint_modulequi représente l'application de l'agent (par exemple,root_agent).class_methods(list[dict]) : liste de dictionnaires qui définissent les méthodes exposées de l'agent. Chaque dictionnaire inclut un champname, un champapi_modeet un champparametersfacultatif. Pour en savoir plus sur les méthodes d'un agent personnalisé, consultez Répertorier les opérations compatibles.Exemple :
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) : (facultatif) chemin d'accès à un fichier d'exigences pip dans les chemins d'accès spécifiés danssource_packages. La valeur par défaut estrequirements.txtdans le répertoire racine de la source empaquetée.
Le déploiement prend quelques minutes, pendant lesquelles les étapes suivantes se déroulent en arrière-plan :
- Le SDK Agent Platform crée une archive
tar.gzdes chemins d'accès spécifiés danssource_packages. - Cette archive est encodée et envoyée directement à l'API Agent Platform.
- Le service Agent Runtime reçoit l'archive, l'extrait, installe les dépendances à partir de
requirements_file(si fourni) et démarre l'application de l'agent à l'aide desentrypoint_moduleetentrypoint_objectspécifiés.
La latence de déploiement dépend du temps total nécessaire à l'installation des packages requis. Une fois déployé, remote_agent correspond à une instance de local_agent qui s'exécute sur Agent Platform et peut être interrogée ou supprimée.
L'objet remote_agent correspond à une classe AgentRuntime qui contient les éléments suivants :
remote_agent.api_resourceavec des informations sur l'agent déployé. Vous pouvez également appelerremote_agent.operation_schemas()pour renvoyer la liste des opérations compatibles avecremote_agent. Pour en savoir plus, consultez Opérations compatibles.remote_agent.api_clientqui permet des interactions de service synchrones.remote_agent.async_api_clientqui permet des interactions de service asynchrones.
Dockerfile
Le déploiement à partir d'un Dockerfile sur la plate-forme de l'agent suit une approche similaire au déploiement à partir de fichiers sources, sauf que vous incluez un Dockerfile dans vos fichiers sources et que vous spécifiez image_spec dans la configuration au lieu de entrypoint_module, entrypoint_object et requirements_file. Le conteneur créé à partir du fichier Dockerfile doit écouter les requêtes HTTP sur 0.0.0.0 sur le port 8080 et respecter le contrat d'exécution.
Vous pouvez utiliser cette méthode de déploiement avec n'importe quel langage.
Tout d'abord, créez un fichier Dockerfile à la racine du répertoire de votre projet qui installe les dépendances et démarre votre serveur HTTP sur 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"]
Go
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"]
Si votre conteneur implémente les points de terminaison de routage du contrat d'exécution (/api/reasoning_engine et /api/stream_reasoning_engine, que le lanceur ADK Go agentengine expose également), déclarez les opérations compatibles dans class_methods (ou spec.classMethods dans REST) afin de pouvoir appeler l'agent via des requêtes query et streamQuery standards. Si votre conteneur exécute le serveur d'API ADK (tel que npx adk api_server pour TypeScript ou AdkWebServer pour Java), appelez ses points de terminaison /run et /run_sse via le proxy d'API sous-jacent (/api/run et /api/run_sse).
Ensuite, déployez l'agent à partir de vos fichiers sources locaux et de Dockerfile à l'aide du SDK Agent Platform, de l'API REST ou de 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 latence de déploiement dépend du temps total nécessaire pour créer l'image de conteneur et installer les packages requis. Une fois déployé, remote_agent correspond à votre agent exécuté sur Agent Platform et peut être interrogé ou supprimé.
L'objet remote_agent correspond à une classe AgentRuntime qui contient les éléments suivants :
remote_agent.api_resourceavec des informations sur l'agent déployé. Vous pouvez également appelerremote_agent.operation_schemas()pour renvoyer la liste des opérations compatibles avecremote_agent. Pour en savoir plus, consultez Opérations compatibles.remote_agent.api_clientqui permet des interactions de service synchrones.remote_agent.async_api_clientqui permet des interactions de service asynchrones.
REST
Empaquetez votre fichier Dockerfile et les fichiers sources de l'application au niveau racine d'une archive .tar.gz (8 Mo maximum), encodez l'archive en base64 et envoyez une requête POST à la méthode 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 requête renvoie une Operation de longue durée qui se résout en ressource ReasoningEngine déployée une fois la compilation et le déploiement du conteneur terminés.
Image de conteneur
Pour effectuer un déploiement à partir d'une image de conteneur, suivez d'abord les instructions de configuration de la section Utiliser votre propre conteneur pour créer et transférer votre image vers Artifact Registry. Si vous utilisez le SDK Agent Platform pour créer l'instance Agent Platform, veillez à installer une version de google-cloud-aiplatform satisfaisant >=1.144. L'image de conteneur doit écouter les requêtes HTTP sur 0.0.0.0 sur le port 8080 et respecter le contrat d'exécution.
Vous pouvez utiliser cette méthode de déploiement avec n'importe quel langage.
Les exemples suivants montrent un Dockerfile pour créer une image de conteneur qui écoute sur 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"]
Go
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"]
Si votre conteneur implémente les points de terminaison de routage du contrat d'exécution (/api/reasoning_engine et /api/stream_reasoning_engine, que le lanceur ADK Go agentengine expose également), déclarez les opérations compatibles dans class_methods (ou spec.classMethods dans REST) afin de pouvoir appeler l'agent via des requêtes query et streamQuery standards. Si votre conteneur exécute le serveur d'API ADK (tel que npx adk api_server pour TypeScript ou AdkWebServer pour Java), appelez ses points de terminaison /run et /run_sse via le proxy d'API sous-jacent (/api/run et /api/run_sse).
Après avoir créé et transféré votre image de conteneur vers Artifact Registry, déployez l'agent à l'aide du SDK Agent Platform, de l'API REST ou de 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", }, )
Où CONTAINER_IMAGE_URI correspond à l'URI de l'image de conteneur dans Artifact Registry (par exemple, us-central1-docker.pkg.dev/my-project/my-repo/my-image:tag).
Une fois déployé, remote_agent correspond à votre agent exécuté sur Agent Platform et peut être interrogé ou supprimé.
L'objet remote_agent correspond à une classe AgentRuntime qui contient les éléments suivants :
remote_agent.api_resourceavec des informations sur l'agent déployé. Vous pouvez également appelerremote_agent.operation_schemas()pour renvoyer la liste des opérations compatibles avecremote_agent. Pour en savoir plus, consultez Opérations compatibles.remote_agent.api_clientqui permet des interactions de service synchrones.remote_agent.async_api_clientqui permet des interactions de service asynchrones.
REST
Envoyez une requête POST à la méthode 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" } } }'
Où CONTAINER_IMAGE_URI correspond à l'URI de l'image de conteneur dans Artifact Registry (par exemple, us-central1-docker.pkg.dev/my-project/my-repo/my-image:tag). La requête renvoie une opération de longue durée Operation qui se résout en ressource ReasoningEngine déployée une fois le déploiement terminé.
SDK Agent Platform
Pour déployer l'agent sur Agent Platform, utilisez client.runtimes.create pour transmettre l'objet local_agent ainsi que toutes les configurations facultatives :
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. }, )
Le déploiement prend quelques minutes, pendant lesquelles les étapes suivantes se déroulent en arrière-plan :
- Un ensemble des artefacts suivants est généré localement :
*.pkl: fichier pickle correspondant à local_agent.requirements.txt: fichier texte contenant les dépendances de package.dependencies.tar.gz: fichier tar contenant les éventuels packages supplémentaires.
- Le bundle est importé dans Cloud Storage (dans le dossier correspondant) pour la préproduction des artefacts.
- Les URI Cloud Storage des artefacts respectifs sont spécifiés dans PackageSpec.
- Le service Agent Runtime reçoit la requête, crée des conteneurs et lance des serveurs HTTP sur le backend.
La latence de déploiement dépend du temps total nécessaire à l'installation des packages requis. Une fois déployé, remote_agent correspond à une instance de local_agent qui s'exécute sur Agent Platform et peut être interrogée ou supprimée.
L'objet remote_agent correspond à une classe AgentRuntime qui contient les éléments suivants :
remote_agent.api_resourceavec des informations sur l'agent déployé. Vous pouvez également appelerremote_agent.operation_schemas()pour renvoyer la liste des opérations compatibles avecremote_agent. Pour en savoir plus, consultez Opérations compatibles.remote_agent.api_clientqui permet des interactions de service synchrones.remote_agent.async_api_clientqui permet des interactions de service asynchrones.
Facultatif : Obtenir l'ID de ressource de l'agent
Chaque agent déployé possède un identifiant unique. Vous pouvez exécuter la commande suivante pour obtenir le nom de ressource de votre agent déployé :
remote_agent.api_resource.name
La réponse doit ressembler à la chaîne suivante :
"projects/PROJECT_NUMBER/locations/LOCATION/reasoningEngines/RESOURCE_ID"
Où :
PROJECT_IDest l'ID du projet Google Cloud dans lequel l'agent déployé s'exécute.LOCATIONest la région dans laquelle l'agent déployé s'exécute.RESOURCE_IDest l'ID de l'agent déployé en tant que ressourcereasoningEngine.
Facultatif : Lister les opérations compatibles
Chaque agent déployé dispose d'une liste d'opérations compatibles. Vous pouvez utiliser AgentRuntime.operation_schemas pour obtenir la liste des opérations compatibles avec l'agent déployé :
remote_agent.operation_schemas()
Le schéma de chaque opération est un dictionnaire qui documente les informations d'une méthode pour l'agent que vous pouvez appeler. L'ensemble des opérations compatibles dépend du framework que vous avez utilisé pour développer votre agent :
Facultatif : Accorder des autorisations à l'agent déployé
Si l'agent déployé doit disposer d'autorisations supplémentaires, suivez les instructions de la section Configurer l'identité et les autorisations de votre agent.
Facultatif : Déployer des agents avec une infrastructure d'entreprise
Pour déployer votre agent avec un environnement complet incluant des couches de sécurité et de gouvernance, copiez et personnalisez les modèles Application Design Center suivants :
Étapes suivantes
Gérer les agents déployés
Découvrez comment gérer les agents déployés sur l'environnement d'exécution géré Agent Platform.