Déployez en toute sécurité des agents d'IA sur Google Cloud avec GitLab

Dans un contexte où l'IA agentique transforme notre façon de concevoir des applications intelligentes, le déploiement sécurisé et efficace d'agents d'IA peut s'avérer complexe. Dans ce tutoriel, vous apprendrez à déployer un agent d'IA développé avec l'Agent Development Kit (ADK) de Google sur Cloud Run au moyen des intégrations natives et des composants CI/CD de GitLab.

→ Essayez GitLab Ultimate et GitLab Duo Enterprise gratuitement.

Définition et rôle d'un agent d'IA

L'IA agentique représente une évolution majeure dans le domaine de l'intelligence artificielle. Contrairement aux outils d'IA générative traditionnels, qui nécessitent une supervision humaine constante, les agents d'IA utilisent des modèles de langage avancés et le traitement du langage naturel pour agir en toute autonomie. Ils peuvent comprendre des demandes, prendre des décisions et exécuter des plans en plusieurs étapes pour atteindre des objectifs de façon indépendante.

Ce tutoriel utilise l'ADK de Google, un framework flexible et modulaire pour développer et déployer des agents d'IA. Bien qu'optimisé pour Gemini et l'écosystème Google, l'ADK ne dépend pas d'un modèle ni d'un déploiement, et est conçu pour être compatible avec d'autres frameworks.

Notre application de démonstration : Canada City Advisor

Pour illustrer le processus de déploiement, nous utiliserons un exemple concret : Canada City Advisor. Cet agent d'IA aide les utilisateurs à trouver la ville canadienne qui leur convient en fonction de leurs préférences et restrictions.

Voici comment l'agent fonctionne :

• Les utilisateurs saisissent leur budget et leurs préférences en matière de style de vie.

• L'agent principal coordonne deux sous-agents :

  • Un agent dédié à l'analyse budgétaire qui évalue les contraintes financières. Il s'appuie sur des données obtenues auprès de la Société canadienne d'hypothèques et de logement.
  • Un agent dédié aux préférences en matière de style de vie qui associe les villes aux besoins des utilisateurs. Cet agent inclut un service météorologique qui utilise Open-Meteo pour obtenir des informations correctes sur les villes.

• Le système génère des recommandations de villes personnalisées.

Cette architecture multi-agents illustre la puissance de l'IA agentique : différents agents spécialisés collaborent pour résoudre un problème complexe. Les sous-agents ne sont sollicités que lorsque l'agent principal détermine qu'une analyse du budget et du style de vie est nécessaire.

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 Run
  • API Artifact Registry
  • API Vertex AI

• Un projet GitLab pour votre code source

• Les autorisations adéquates dans GitLab et Google Cloud

Étape 1 : configurer l'intégration IAM avec la fédération d'identité de charge de travail

La première étape consiste à établir une authentification sécurisée sans clé entre GitLab et Google Cloud à l'aide de la fédération d'identité de charge de travail. Cette approche élimine le besoin de clés de compte de service et renforce la sécurité.

Dans votre projet GitLab :

1. Accédez à Paramètres > Intégrations > Google Cloud IAM.

2. Indiquez les informations suivantes :

   • ID du projet : l'identifiant de votre projet Google Cloud
   • Numéro du projet : disponible dans votre console Google Cloud
   • ID du pool : un identifiant unique pour votre pool d'identité de charge de travail
   • ID du fournisseur : un identifiant unique pour votre fournisseur d'identité

GitLab génère un script pour vous. Copiez-le et exécutez-le dans votre Google Cloud Shell pour créer la fédération d'identité de charge de travail.

Étape 2 : configurer l'intégration Google Artifact Registry

Ensuite, nous allons configurer la connexion à Google Artifact Registry, où seront stockées nos images de conteneurs.

1. Dans GitLab, accédez à Paramètres > Intégrations > Google Artifact Registry.

2. Indiquez les données suivantes :

   • ID du projet Google Cloud : identique à l'étape 1
   • Nom du dépôt : nom d'un dépôt Artifact Registry existant
   • Emplacement : région où se trouve votre dépôt

Important : le dépôt doit déjà exister dans Artifact Registry, car GitLab ne créera pas de nouveau dépôt.

GitLab génère des commandes pour configurer les autorisations nécessaires. Exécutez-les dans Google Cloud Shell.

Ajoutez également ces rôles à l'identité du service pour le déploiement Cloud Run :

• roles/run.admin
• roles/iam.serviceAccountUser
• roles/cloudbuild.builds.editor

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

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

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/run.admin'

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/iam.serviceAccountUser'

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/cloudbuild.builds.editor'

Étape 3 : créer le pipeline CI/CD

Passons maintenant à la partie la plus intéressante : la création de notre pipeline de déploiement, une tâche particulièrement simple grâce aux composants CI/CD de GitLab.

Créez un fichier .gitlab-ci.yml à la racine de votre projet :

stages:
  - build
  - test
  - upload
  - deploy

variables:
  GITLAB_IMAGE: $CI_REGISTRY_IMAGE/main:$CI_COMMIT_SHORT_SHA
  AR_IMAGE: $GOOGLE_ARTIFACT_REGISTRY_REPOSITORY_LOCATION-docker.pkg.dev/$GOOGLE_ARTIFACT_REGISTRY_PROJECT_ID/$GOOGLE_ARTIFACT_REGISTRY_REPOSITORY_NAME/main:$CI_COMMIT_SHORT_SHA

build:
  image: docker:24.0.5
  stage: build
  services:
    - docker:24.0.5-dind
  before_script:
    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
  script:
    - docker build -t $GITLAB_IMAGE .
    - docker push $GITLAB_IMAGE

include:
  - template: Jobs/Dependency-Scanning.gitlab-ci.yml  # https://gitlab.com/gitlab-org/gitlab/blob/master/lib/gitlab/ci/templates/Jobs/Dependency-Scanning.gitlab-ci.yml
  - template: Jobs/SAST.gitlab-ci.yml  # https://gitlab.com/gitlab-org/gitlab/blob/master/lib/gitlab/ci/templates/Jobs/SAST.gitlab-ci.yml
  - template: Jobs/Secret-Detection.gitlab-ci.yml  # https://gitlab.com/gitlab-org/gitlab/blob/master/lib/gitlab/ci/templates/Jobs/Secret-Detection.gitlab-ci.yml
  - component: gitlab.com/google-gitlab-components/artifact-registry/upload-artifact-registry@main
    inputs:
      stage: upload
      source: $GITLAB_IMAGE
      target: $AR_IMAGE
  - component: gitlab.com/google-gitlab-components/cloud-run/deploy-cloud-run@main
    inputs:
      stage: deploy
      project_id: "<your-project-id>" #replace
      service: "canadian-city"
      region: "us-central1"
      image: $AR_IMAGE

Le pipeline se compose de quatre étapes :

1. Build : crée le conteneur Docker avec votre agent d'IA
2. Test : exécute des scans de sécurité (analyse des conteneurs, analyse des dépendances, test statique de sécurité des applications)
3. Importation : transfère le conteneur vers Artifact Registry
4. Déploiement : déploie sur Cloud Run

Les composants CI/CD de GitLab possèdent un avantage indéniable : vous n'avez qu'à fournir quelques paramètres, et ils se chargent de gérer toute la logique complexe d'authentification et de déploiement.

Étape 4 : déployer et tester

Une fois que tout est configuré, il est temps de déployer :

1. Validez votre code et le fichier .gitlab-ci.yml dans votre dépôt GitLab.
2. Le pipeline se déclenche automatiquement.
3. Surveillez la progression du pipeline dans l'interface CI/CD de GitLab.
4. Une fois terminé, accédez à l'URL de votre Cloud Run dans la console Google Cloud.

Vous y verrez chaque étape s'exécuter :

• L'étape Build crée votre conteneur.
• L'étape Test exécute des scans de sécurité complets.
• L'étape Importation effectue un push vers Artifact Registry.
• L'étape Déploiement crée ou met à jour votre service Cloud Run.

Avantages en matière de sécurité

Cette approche offre plusieurs avantages en matière de sécurité :

• Aucun identifiant à longue durée de vie : la fédération d'identité de charge de travail élimine les clés de compte de service.
• Scanning de sécurité automatisé : chaque déploiement fait l'objet d'une analyse des vulnérabilités.
• Piste d'audit : vous profitez d'une visibilité complète sur qui a déployé quoi et quand.
• Principe du moindre privilège : des rôles Identity and Access Management (IAM) précis limitent l'accès.

Résumé

En combinant les fonctionnalités de sécurité de GitLab avec les puissantes plateformes d'IA sans serveur de Google Cloud, vous pouvez déployer des agents d'IA à la fois sécurisés et évolutifs. L'intégration entre GitLab et Google Cloud élimine une grande partie de la complexité généralement associée à ce type de déploiements.

Utilisez l'exemple de code complet de ce tutoriel pour vous lancer dès maintenant.

→ Essayez GitLab Ultimate et GitLab Duo Enterprise gratuitement.