Déploiement sécurisé d'agents d'IA sur GKE

Créer des agents d'IA est passionnant, mais leur déploiement sécurisé en production est parfois compliqué. Dans ce tutoriel, vous découvrirez comment l'intégration native de GitLab avec Google Cloud facilite le déploiement d'agents d'IA vers Google Kubernetes Engine (GKE), avec scans de sécurité intégrés et sans clés de compte de service.

Pourquoi choisir GKE pour déployer vos agents d'IA ?

GKE offre une orchestration d'entreprise qui s'intègre parfaitement aux pipelines CI/CD de GitLab grâce à l'authentification OpenID Connect (OIDC). Votre équipe de développement peut déployer des agents d'IA tout en conservant une visibilité, une conformité et un contrôle complets sur votre infrastructure cloud. Ce guide utilise l'Agent Development Kit (ADK) de Google afin de créer l'application, ce qui garantit une intégration fluide lors du déploiement avec GitLab.

Voici trois avantages clés de cette approche :

Contrôle total de l'infrastructure : vos données, vos règles, votre environnement. Vous conservez un contrôle complet sur l'emplacement d'exécution de vos agents d'IA et de leur configuration.

Intégration native avec GitLab : pas de solution de contournement complexe. Vos pipelines existants fonctionnent immédiatement grâce à l'intégration native de GitLab avec Google Cloud.

Mise à l'échelle de niveau production : GKE gère automatiquement la mise à l'échelle et l'orchestration interne à mesure que vos charges de travail d'IA augmentent.

Avec GKE, GitLab offre la fiabilité d'entreprise dont vos déploiements d'IA ont besoin sans sacrifier l'expérience développeur que vos équipes attendent.

Prérequis

Avant de commencer, assurez-vous d'avoir activé ces API :

• API GKE
• API Artifact Registry
• API Vertex AI

Assurez-vous également de disposer des éléments suivant :

• Un projet GitLab créé
• Un cluster GKE provisionné
• Un dépôt Artifact Registry créé

Le processus de déploiement

1. Configurer IAM et les autorisations sur GitLab

Accédez à vos intégrations GitLab afin de configurer l'authentification Google Cloud (IAM).

Accédez à Paramètres > Intégrations et configurez l'intégration Google Cloud. Si vous utilisez une intégration au niveau du groupe, notez que les paramètres par défaut sont déjà hérités par les projets. Il vous suffit donc de configurer vos paramètres une fois au niveau du groupe pour que tous les projets en bénéficient et les héritent.

Pour configurer les paramètres, vous devez fournir les éléments suivants :

• ID du projet
• Numéro du projet
• ID du pool d'identités de charge de travail
• ID du fournisseur

Une fois ces informations renseignées, GitLab fournit un script à exécuter dans Google Cloud Console via Cloud Shell. Le résultat de l'exécution de ce script est un pool de fédération d'identité de charge de travail avec l'identité de service de compte principal nécessaire pour permettre l'accès approprié.

2. Configurer l'intégration à Artifact Registry

Toujours dans les paramètres d'intégration de GitLab, configurez la gestion des artefacts :

1. Cliquez sur Gestion des artefacts.
2. Sélectionnez Google Artifact Registry.
3. Indiquez les éléments suivants :
   • ID du projet
   • Nom du dépôt (créé au préalable)
   • Emplacement du dépôt

GitLab fournit un autre script à exécuter dans Google Cloud Console.

Important : avant de continuer, ajoutez ces rôles supplémentaires au pool de fédération d'identité de charge de travail :

• Utilisateur de compte de service
• Développeur Kubernetes
• Observateur de cluster Kubernetes

Ces autorisations permettent à GitLab de déployer vers GKE dans les étapes suivantes.

3. Créer le pipeline CI/CD

Voici maintenant la partie essentielle : la création du pipeline CI/CD pour le déploiement.

Accédez à Compilation > Éditeur de pipeline et définissez votre pipeline en quatre étapes :

• Build : Docker crée l'image de conteneur.
• Test : GitLab Auto DevOps fournit des scans de sécurité intégrés afin de garantir l'absence de vulnérabilités.
• Importation : utilise le composant CI/CD intégré de GitLab pour effectuer un push vers Google Artifact Registry.
• Déploiement : utilise la configuration Kubernetes pour déployer vers GKE.

Voici le fichier .gitlab-ci.yml complet :

      


default:
  tags: [ saas-linux-2xlarge-amd64 ]

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
  GCP_PROJECT_ID: "your-project-id"
  GKE_CLUSTER: "your-cluster"
  GKE_REGION: "us-central1"
  KSA_NAME: "ai-agent-ksa"

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
  - template: Jobs/Container-Scanning.gitlab-ci.yml
  - template: 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

deploy:
  stage: deploy
  image: google/cloud-sdk:slim
  identity: google_cloud
  before_script:
    - apt-get update && apt-get install -y kubectl google-cloud-sdk-gke-gcloud-auth-plugin
    - gcloud container clusters get-credentials $GKE_CLUSTER --region $GKE_REGION --project $GCP_PROJECT_ID
  script:
    - |
      kubectl apply -f - <<EOF
      apiVersion: apps/v1
      kind: Deployment
      metadata:
        name: ai-agent
        namespace: default
      spec:
        replicas: 2
        selector:
          matchLabels:
            app: ai-agent
        template:
          metadata:
            labels:
              app: ai-agent
          spec:
            serviceAccountName: $KSA_NAME
            containers:
            - name: ai-agent
              image: $AR_IMAGE
              ports:
              - containerPort: 8080
              resources:
                requests: {cpu: 500m, memory: 1Gi}
                limits: {cpu: 2000m, memory: 4Gi}
              livenessProbe:
                httpGet: {path: /health, port: 8080}
                initialDelaySeconds: 60
              readinessProbe:
                httpGet: {path: /health, port: 8080}
                initialDelaySeconds: 30
      ---
      apiVersion: v1
      kind: Service
      metadata:
        name: ai-agent-service
        namespace: default
      spec:
        type: LoadBalancer
        ports:
        - port: 80
          targetPort: 8080
        selector:
          app: ai-agent
      ---
      apiVersion: autoscaling/v2
      kind: HorizontalPodAutoscaler
      metadata:
        name: ai-agent-hpa
        namespace: default
      spec:
        scaleTargetRef:
          apiVersion: apps/v1
          kind: Deployment
          name: ai-agent
        minReplicas: 2
        maxReplicas: 10
        metrics:
        - type: Resource
          resource:
            name: cpu
            target: {type: Utilization, averageUtilization: 70}
      EOF

      kubectl rollout status deployment/ai-agent -n default --timeout=5m
      EXTERNAL_IP=$(kubectl get service ai-agent-service -n default -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
      echo "Deployed at: http://$EXTERNAL_IP"
  only:
    - main

    

Configuration essentielle pour GKE

Pour que tout fonctionne, et c'est la raison pour laquelle nous avons besoin de cette configuration supplémentaire pour GKE, nous devons disposer d'un compte de service Kubernetes dans le cluster qui peut fonctionner avec Vertex AI. Ce compte de service doit être autorisé à accéder aux capacités d'IA de Google Cloud.

Sans cela, nous pouvons déployer l'application, mais l'agent d'IA ne fonctionnera pas. Nous devons créer un compte de service Kubernetes capable d'accéder à Vertex AI.

Exécutez cette configuration ponctuelle :

      


#!/bin/bash



PROJECT_ID="your-project-id"



GSA_NAME="ai-agent-vertex"



GSA_EMAIL="${GSA_NAME}@${PROJECT_ID}.iam.gserviceaccount.com"



KSA_NAME="ai-agent-ksa"



CLUSTER_NAME="your-cluster"



REGION="us-central1"




# Create GCP Service Account



gcloud iam service-accounts create $GSA_NAME \
    --display-name="AI Agent Vertex AI" \
    --project=$PROJECT_ID

# Grant Vertex AI permissions



gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member="serviceAccount:${GSA_EMAIL}" \
    --role="roles/aiplatform.user"

# Get cluster credentials



gcloud container clusters get-credentials $CLUSTER_NAME \
    --region $REGION --project $PROJECT_ID

# Create Kubernetes Service Account



kubectl create serviceaccount $KSA_NAME -n default




# Link accounts



kubectl annotate serviceaccount $KSA_NAME -n default \
    iam.gke.io/gcp-service-account=${GSA_EMAIL}

gcloud iam service-accounts add-iam-policy-binding ${GSA_EMAIL} \
    --role=roles/iam.workloadIdentityUser \
    --member="serviceAccount:${PROJECT_ID}.svc.id.goog[default/${KSA_NAME}]" \
    --project=$PROJECT_ID

    

4. Déployer vers GKE

Une fois que vous avez terminé, effectuez un push vers le pipeline et le tour est joué.

Le pipeline vient d'être déployé. Accédez à CI/CD > Pipelines pour voir les quatre étapes :

• Build
• Test (avec tous les scans de sécurité définis)
• Importation vers Artifact Registry (réussie)
• Déploiement vers Kubernetes dans GKE (réussi)

Résumé

Avec GitLab et Google Cloud, vous êtes en mesure de déployer votre agent d'IA vers GKE en toute simplicité et sécurité en quelques étapes seulement grâce à l'intégration native de GitLab avec Google Cloud.

Regardez cette démo :

Utilisez l'exemple de code complet de ce tutoriel pour commencer dès maintenant. Vous n’utilisez pas encore GitLab ? Découvrez la plateforme DevSecOps et profitez d'un essai gratuit. Les startups hébergées sur Google Cloud disposent d'une offre spéciale pour essayer et utiliser GitLab.