Déploiements sécurisés et rapides vers Google Agent Engine avec GitLab

Dans ce tutoriel, vous apprendrez à déployer un agent d'IA créé avec l'Agent Development Kit de Google (ADK) sur Agent Engine en utilisant l'intégration native de GitLab avec Google Cloud et des pipelines CI/CD. Nous aborderons la configuration de l'Identity and Access Management (IAM), la mise en place des pipelines et le test de votre agent déployé.

Qu'est-ce que Google Agent Engine ?

Agent Engine est l'environnement d'exécution géré de Google Cloud, spécialement conçu pour les agents d'IA. Il s'agit de l'environnement de production de vos agents : l'endroit où ils vivent, s'exécutent et évoluent sans que vous ayez à gérer l'infrastructure sous-jacente. Agent Engine prend en charge l'infrastructure, la mise à l'échelle, la gestion des sessions et le stockage en mémoire, afin que vous puissiez vous concentrer sur la création de votre agent plutôt que sur la gestion des serveurs. Il s'intègre également de manière native avec les outils de journalisation, de surveillance et d'IAM de Google Cloud.

Pourquoi utiliser GitLab pour déployer sur Agent Engine ?

Le déploiement d'agents d'IA est généralement difficile à configurer correctement. Les considérations de sécurité, l'orchestration CI/CD et les autorisations cloud créent des frictions qui ralentissent les cycles de développement.

GitLab simplifie l'ensemble de ce processus tout en renforçant la sécurité :

• Scans de sécurité intégrés : chaque déploiement est automatiquement analysé afin de rechercher des vulnérabilités, sans configuration supplémentaire.
• Intégration native avec Google Cloud : la fédération d'identité de charge de travail élimine le recours aux clés de compte de service.
• CI/CD simplifié : les templates GitLab gèrent la logique de déploiement complexe.

Prérequis

Avant de commencer, assurez-vous de disposer des éléments suivants :

• Un projet Google Cloud avec les API suivantes activées :
  • API Cloud Storage
  • API Vertex AI
• Un projet GitLab pour votre code source et votre pipeline CI/CD
• Un bucket Google Cloud Storage pour les déploiements dans l'environnement de préproduction
• L'intégration IAM Google Cloud configurée dans GitLab (voir l'étape 1)

Voici les étapes à suivre.

1. Configurer l'intégration IAM

La base d'un déploiement sécurisé repose sur une configuration IAM appropriée entre GitLab et Google Cloud via la fédération d'identité de charge de travail.

Dans votre projet GitLab :

1. Accédez à Paramètres > Intégrations.
2. Recherchez l'intégration Google Cloud IAM.
3. Renseignez les informations suivantes :
   • ID de projet : l'identifiant de votre projet Google Cloud
   • Numéro du projet : disponible dans votre console Google Cloud
   • ID du pool d'identités de charge de travail : un identifiant unique pour votre pool d'identités
   • ID du fournisseur : un identifiant unique pour votre fournisseur d'identité

GitLab génère un script pour vous. Copiez et exécutez ce script dans Google Cloud Shell pour établir la fédération d'identité de charge de travail entre les deux plateformes.

Important : ajoutez ces rôles supplémentaires à votre identité de service de compte principal pour le déploiement sur Agent Engine :

• roles/aiplatform.user
• roles/storage.objectAdmin

Vous pouvez ajouter ces rôles à l'aide des commandes gcloud suivantes :

      GCP_PROJECT_ID="<your-project-id>"
GCP_PROJECT_NUMBER="<your-project-number>"
GCP_WORKLOAD_IDENTITY_POOL="<your-pool-id>"

gcloud projects add-iam-policy-binding ${GCP_PROJECT_ID} \
  --member="principalSet://iam.googleapis.com/projects/${GCP_PROJECT_NUMBER}/locations/global/workloadIdentityPools/${GCP_WORKLOAD_IDENTITY_POOL}/attribute.developer_access/true" \
  --role='roles/aiplatform.user'

gcloud projects add-iam-policy-binding ${GCP_PROJECT_ID} \
  --member="principalSet://iam.googleapis.com/projects/${GCP_PROJECT_NUMBER}/locations/global/workloadIdentityPools/${GCP_WORKLOAD_IDENTITY_POOL}/attribute.developer_access/true" \
  --role='roles/storage.objectAdmin'

    

2. Créer le pipeline CI/CD

Passons maintenant au cœur du déploiement : le pipeline CI/CD. Créez un fichier .gitlab-ci.yml à la racine de votre projet :

      stages:
  - test
  - deploy

cache:
  paths:
    - .cache/pip
  key: ${CI_COMMIT_REF_SLUG}

variables:
  GCP_PROJECT_ID: "<your-project-id>"
  GCP_REGION: "us-central1"
  STORAGE_BUCKET: "<your-staging-bucket>"
  AGENT_NAME: "Canada City Advisor"
  AGENT_ENTRY: "canada_city_advisor"

image: google/cloud-sdk:slim

# Security scanning templates
include:
  - template: Jobs/Dependency-Scanning.gitlab-ci.yml
  - template: Jobs/SAST.gitlab-ci.yml
  - template: Jobs/Secret-Detection.gitlab-ci.yml

deploy-agent:
  stage: deploy
  identity: google_cloud
  rules:
    - if: $CI_COMMIT_BRANCH == "main"
  before_script:
    - gcloud config set core/disable_usage_reporting true
    - gcloud config set component_manager/disable_update_check true
    - pip install -q --no-cache-dir --upgrade pip google-genai google-cloud-aiplatform -r requirements.txt --break-system-packages
  script:
    - gcloud config set project $GCP_PROJECT_ID
    - adk deploy agent_engine 
        --project=$GCP_PROJECT_ID 
        --region=$GCP_REGION 
        --staging_bucket=gs://$STORAGE_BUCKET 
        --display_name="$AGENT_NAME" 
        $AGENT_ENTRY

    

Le pipeline se compose de deux étapes :

Étape de test : les scanners de sécurité de GitLab s'exécutent automatiquement. Les templates inclus fournissent l'analyse des dépendances, les tests statiques de sécurité des applications (SAST) et la détection des secrets, sans aucune configuration supplémentaire.

Étape de déploiement : cette étape utilise l'interface de ligne de commande ADK pour déployer votre agent directement sur Agent Engine. Le bucket d'environnement de préproduction stocke temporairement votre charge de travail applicative avant qu'Agent Engine ne la récupère pour le déploiement.

Points clés de configuration

• Le paramètre identity: google_cloud active l'authentification sans clé via la fédération d'identité de charge de travail.
• Les scanners de sécurité sont inclus sous forme de templates : ils s'exécutent par défaut sans aucune configuration requise.
• La commande adk deploy agent_engine gère toute la complexité de l'empaquetage et du déploiement de votre agent.
• La mise en cache du pipeline accélère les déploiements suivants en préservant les dépendances pip.

3. Déployer et vérifier

Une fois votre pipeline configuré :

1. Validez votre code d'agent et le fichier .gitlab-ci.yml dans GitLab.
2. Accédez à Complication > Pipelines pour suivre l'exécution.
3. Observez l'étape de test effectuer les scans de sécurité.
4. Observez l'étape de déploiement envoyer votre agent sur Agent Engine.

Une fois le pipeline terminé avec succès, vérifiez votre déploiement dans la console Google Cloud :

1. Accédez à Vertex AI > Agent Engine.
2. Localisez votre agent déployé.
3. Notez le nom de la ressource : vous en aurez besoin pour les tests.

4. Tester votre agent déployé

Testez votre agent à l'aide d'une commande curl. Vous aurez besoin des trois informations suivantes :

• L'ID de l'agent : depuis la console Agent Engine (l'identifiant numérique du nom de la ressource)
• L'ID du projet : votre projet Google Cloud
• L'emplacement : la région où vous avez effectué le déploiement (par ex., us-central1)

      PROJECT_ID="<your-project-id>"
LOCATION="us-central1"
AGENT_ID="<your-agent-id>"
TOKEN=$(gcloud auth print-access-token)

curl -X POST \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  "https://${LOCATION}-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/${LOCATION}/reasoningEngines/${AGENT_ID}:streamQuery" \
  -d '{
    "input": {
      "message": "I make $85,000 per year and I prefer cities with mild winters and a vibrant cultural scene. I also want to be near the coast if possible. What Canadian cities would you recommend?",
      "user_id": "demo-user"
    }
  }' | jq -r '.content.parts[0].text'

    

Si tout est correctement configuré, votre agent répondra avec des recommandations de villes personnalisées en fonction du budget et des préférences de style de vie fournis.

Avantages de cette approche en matière de sécurité

Ce modèle de déploiement offre plusieurs avantages en matière de sécurité :

• Aucune information d'identification de longue durée : la fédération d'identité de charge de travail élimine totalement les clés de compte de service.
• Analyse automatisée des vulnérabilités : chaque déploiement est analysé avant d'atteindre la production.
• Traçabilité complète : GitLab assure une visibilité totale sur qui a déployé quoi et quand.
• Principe du moindre privilège : les rôles IAM granulaires limitent l'accès au strict nécessaire.

Résumé

Déployer des agents d'IA en production ne doit pas nécessairement être complexe. En combinant la plateforme DevSecOps de GitLab avec Agent Engine de Google Cloud, vous bénéficiez :

• D'un environnement d'exécution géré qui prend en charge la mise à l'échelle et l'infrastructure
• De scans de sécurité intégrés sans outils supplémentaires
• D'une authentification sans clé via l'intégration native avec le cloud
• D'un processus de déploiement simplifié, adapté aux workflows de développement d'IA modernes

Visionnez la démonstration complète :

Prêt à essayer ? Utilisez l'exemple de code complet de ce tutoriel pour démarrer dès maintenant. Vous n'êtes pas encore client GitLab ? Commencez un essai gratuit.