Installer Agent Sandbox sur GKE

Ce document explique comment installer le contrôleur Agent Sandbox Open Source sur un cluster Google Kubernetes Engine (GKE) pour exécuter des charges de travail d'agent isolées dans des pods Kubernetes dédiés. Vous apprendrez également à créer une ressource Sandbox qui exécute du code non approuvé dans l'environnement d'exécution gVisor. Pour la plupart des charges de travail d'agent, utilisez plutôt Agent Substrate sur GKE, car il peut exécuter plus d'agents sur les mêmes nœuds. Utilisez Agent Sandbox sur GKE lorsque chaque agent a besoin d'un pod dédié, de GPU ou de TPU, d'un PodSpec Kubernetes complet ou d'un cluster GKE Autopilot. Pour comparer Agent Sandbox sur GKE avec Agent Substrate sur GKE et choisir une architecture pour vos charges de travail d'agent IA, consultez Planifier une architecture pour les charges de travail d'agent IA sur GKE.

Pour découvrir comment Agent Sandbox sur GKE isole le code non fiable généré par l'IA, consultez À propos d'Agent Sandbox sur GKE.

Coûts

Agent Sandbox sur GKE est un logiciel Open Source que vous pouvez utiliser sans frais supplémentaires. Les tarifs de GKE s'appliquent aux ressources que vous créez, y compris aux ressources de calcul utilisées par le contrôleur Agent Sandbox.

Pour éviter des frais inutiles, veillez à désactiver GKE ou à supprimer le projet une fois que vous avez terminé ce document.

Avant de commencer

  1. Dans la console Cloud de Confiance , sur la page de sélection du projet, sélectionnez ou créez un projet Cloud de Confiance .

    Rôles requis pour sélectionner ou créer un projet

    • Sélectionner un projet : la sélection d'un projet ne nécessite pas de rôle IAM spécifique. Vous pouvez sélectionner n'importe quel projet pour lequel un rôle vous a été attribué.
    • Créer un projet : pour créer un projet, vous devez disposer du rôle "Créateur de projet" (roles/resourcemanager.projectCreator), qui contient l'autorisation resourcemanager.projects.create. Découvrez comment attribuer des rôles.

    Accéder au sélecteur de projet

  2. Vérifiez que la facturation est activée pour votre projet Cloud de Confiance .

  3. Activez l'API Google Kubernetes Engine, si ce n'est pas déjà fait.

    Rôles requis pour activer les API

    Pour activer des API, vous devez disposer de l'autorisation serviceusage.services.enable. Si vous avez créé le projet, vous disposez probablement déjà de cette autorisation via le rôle Propriétaire (roles/owner). Sinon, vous pouvez l'obtenir via le rôle Administrateur Service Usage (roles/serviceusage.serviceUsageAdmin). Découvrez comment attribuer des rôles.

    Activer l'API

  4. Dans la console Cloud de Confiance , activez Cloud Shell.

    Activer Cloud Shell

Définir des variables d'environnement

Pour simplifier les commandes que vous exécutez dans ce document, vous pouvez définir des variables d'environnement dans Cloud Shell. Dans Cloud Shell, définissez les variables d'environnement utiles suivantes en exécutant les commandes ci-dessous :

export CLUSTER_NAME="agent-sandbox-cluster"
export LOCATION="us-central1"
export AGENT_SANDBOX_VERSION="v1.0.6"
export NODE_POOL_NAME="agent-sandbox-pool"
export MACHINE_TYPE="e2-standard-2"

Voici une explication de ces variables d'environnement :

  • CLUSTER_NAME : nom de votre cluster GKE, par exemple agent-sandbox-cluster.
  • LOCATION : région ou zone Cloud de Confiance by S3NS dans laquelle votre cluster GKE est créé. Si vous créez un cluster Autopilot, définissez cette valeur sur la région (par exemple, us-central1). Les clusters Autopilot sont toujours régionaux. Si vous créez un cluster Standard, définissez cette option sur la zone (par exemple, us-central1-a). Pour réduire les coûts, ce document crée un cluster zonal, qui utilise moins de nœuds qu'un cluster régional.
  • AGENT_SANDBOX_VERSION : version du contrôleur Agent Sandbox Open Source à installer. Ce document utilise la version 1.0.6. Pour voir les autres versions, accédez à la page des versions d'Agent Sandbox.
  • NODE_POOL_NAME : nom du pool de nœuds qui exécutera vos pods d'agent, par exemple agent-sandbox-pool. Cette variable n'est requise que si vous créez un cluster GKE Standard.
  • MACHINE_TYPE : type de machine des nœuds du pool de nœuds par défaut de votre cluster et du pool de nœuds gVisor (par exemple, e2-standard-2). Pour en savoir plus sur les différentes séries de machines et sur le choix entre les différentes options, consultez le guide des ressources de familles de machines et guide comparatif. Cette variable n'est requise que si vous créez un cluster GKE Standard.

Créer un cluster GKE

Agent Sandbox sur GKE isole les charges de travail des agents à l'aide de GKE Sandbox avec gVisor ou des microVMs. Si vous ne spécifiez pas d'environnement d'exécution GKE Sandbox (gVisor ou microVM), vos pods s'exécutent sans isolation du noyau. Ne les utilisez donc pas pour exécuter du code non approuvé. Ce document utilise gVisor. Les clusters Autopilot activent gVisor automatiquement. Dans les clusters standards, vous créez un pool de nœuds pour lequel gVisor est activé. Pour utiliser des microVM à la place, consultez Activer le type de bac à sable microVM. La règle de sécurité recommandée n'autorise que gVisor. Elle rejette donc les ressources Sandbox qui utilisent des microVM.

Autopilot

Pour créer un cluster Autopilot, assurez-vous que la variable d'environnement LOCATION est définie sur une région, telle que us-central1, puis exécutez la commande suivante :

gcloud container clusters create-auto ${CLUSTER_NAME} \
    --location=${LOCATION}

Standard

Pour créer un cluster standard, vous devez créer le cluster, puis ajouter un pool de nœuds avec gVisor activé. Pour réduire les coûts, ce document crée un cluster zonal avec un seul nœud par pool.

  1. Définissez la variable d'environnement LOCATION sur une zone, par exemple us-central1-a :

    export LOCATION="us-central1-a"
    
  2. Créez le cluster :

    gcloud container clusters create ${CLUSTER_NAME} \
        --location=${LOCATION} \
        --machine-type=${MACHINE_TYPE} \
        --num-nodes=1
    
  3. Créez un pool de nœuds distinct avec gVisor activé :

    gcloud container node-pools create ${NODE_POOL_NAME} \
        --cluster=${CLUSTER_NAME} \
        --machine-type=${MACHINE_TYPE} \
        --location=${LOCATION} \
        --num-nodes=1 \
        --image-type=cos_containerd \
        --sandbox=type=gvisor
    

    Pour utiliser des microVM au lieu de gVisor, créez le pool de nœuds comme décrit dans Activer le type de bac à sable microVM. Le reste de ce document utilise gVisor.

Pour utiliser un cluster Standard existant, assurez-vous qu'il inclut un pool de nœuds sur lequel gVisor est activé. Si le cluster ne dispose pas d'un tel pool de nœuds, créez-en un en exécutant la commande gcloud container node-pools create précédente.

Pour permettre à l'outil de ligne de commande kubectl de se connecter au cluster, obtenez les identifiants du cluster :

gcloud container clusters get-credentials ${CLUSTER_NAME} \
    --location=${LOCATION}

Installer Agent Sandbox

Pour installer Agent Sandbox, appliquez un fichier manifeste de version à partir du dépôt GitHub Agent Sandbox. Le fichier manifeste sandbox-with-extensions.yaml installe le contrôleur Agent Sandbox et les CustomResourceDefinitions pour la ressource Sandbox et pour les ressources d'extension SandboxTemplate, SandboxClaim et SandboxWarmPool.

  1. Appliquez le fichier manifeste de la version :

    kubectl apply -f https://github.com/kubernetes-sigs/agent-sandbox/releases/download/${AGENT_SANDBOX_VERSION}/sandbox-with-extensions.yaml
    

    Le fichier manifeste crée l'espace de noms agent-sandbox-system et déploie le contrôleur dans cet espace de noms.

  2. Attendez que le contrôleur soit prêt :

    kubectl rollout status deployment/agent-sandbox-controller \
        --namespace=agent-sandbox-system \
        --timeout=120s
    

Vous pouvez également installer Agent Sandbox à l'aide de Helm. Pour obtenir des instructions, consultez le fichier README du chart Helm Agent Sandbox.

Vérifier l'installation

  1. Vérifiez que les CustomResourceDefinitions d'Agent Sandbox sont installées :

    kubectl get crd \
        sandboxes.agents.x-k8s.io \
        sandboxtemplates.extensions.agents.x-k8s.io \
        sandboxclaims.extensions.agents.x-k8s.io \
        sandboxwarmpools.extensions.agents.x-k8s.io
    

    Le résultat liste les quatre CustomResourceDefinitions.

  2. Vérifiez que le contrôleur est en cours d'exécution :

    kubectl get deployment agent-sandbox-controller \
        --namespace=agent-sandbox-system
    

    Lorsque le contrôleur est en cours d'exécution, la colonne READY affiche 1/1.

Appliquer la stratégie de sécurité recommandée

Par défaut, Agent Sandbox sur GKE ne limite pas la configuration des pods qui exécutent vos agents. Pour appliquer les paramètres d'isolation de vos pods d'agent, appliquez la règle secure-sandbox-policy ValidatingAdmissionPolicy recommandée à partir du dépôt GitHub Agent Sandbox. Cette règle rejette toute ressource Sandbox qui ne répond pas aux exigences de déploiement d'Agent Sandbox sur GKE.

  1. Appliquez la règle :

    kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/examples/policy/vap/secure-sandbox-policy.yaml
    
  2. Appliquez la liaison de stratégie. La liaison applique la règle dans tous les espaces de noms, à l'exception des espaces de noms système, tels que kube-system :

    kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/examples/policy/vap/secure-sandbox-binding.yaml
    

La règle valide les ressources Sandbox. Lorsque vous créez une ressource SandboxWarmPool ou SandboxClaim, le contrôleur crée des ressources Sandbox à partir d'une ressource SandboxTemplate. Si le modèle ne répond pas aux exigences, la règle rejette la ressource Sandbox et l'erreur s'affiche dans les journaux du contrôleur. Pour afficher les journaux, exécutez la commande suivante :

kubectl logs deployment/agent-sandbox-controller \
    --namespace=agent-sandbox-system

Vous êtes propriétaire de cette stratégie et vous pouvez la modifier pour l'adapter à vos charges de travail. Pour en savoir plus, consultez Stratégies de sécurité du bac à sable.

Exigences de déploiement d'Agent Sandbox sur GKE

Si vous appliquez la règle de sécurité recommandée, les fichiers manifestes de votre charge de travail, tels qu'une ressource Sandbox ou SandboxTemplate, doivent inclure des paramètres de sécurité et de configuration spécifiques. Si une ressource Sandbox ne répond pas à ces exigences, le contrôleur d'admission la rejette. Les exigences de conteneur s'appliquent à tous les conteneurs du pod, y compris les conteneurs d'initialisation et les conteneurs éphémères.

Configuration requise

Votre fichier manifeste de déploiement doit inclure les paramètres suivants :

  • runtimeClassName: gvisor : exécute le pod dans l'environnement d'exécution gVisor de GKE Sandbox. La règle rejette les ressources Sandbox qui utilisent un autre environnement d'exécution, y compris les microVM.
  • automountServiceAccountToken: false : empêche le pod d'installer automatiquement le jeton du compte de service par défaut.
  • securityContext.runAsNonRoot: true : garantit que le conteneur ne s'exécute pas en tant qu'utilisateur racine.
  • securityContext.capabilities.drop: ["ALL"] : supprime toutes les fonctionnalités Linux du conteneur.
  • resources.limits : vous devez spécifier des limites de processeur et de mémoire pour éviter d'éventuels scénarios de déni de service (DoS).
  • nodeSelector : doit cibler sandbox.gke.io/runtime: gvisor.
  • tolerations : doit inclure une tolérance pour le rejet sandbox.gke.io/runtime=gvisor:NoSchedule.

Configuration interdite

Votre fichier manifeste de déploiement ne doit pas inclure les éléments suivants :

  • hostNetwork: true, hostPID: true ou hostIPC: true.
  • privileged: true dans les contextes de sécurité des conteneurs.
  • procMount: Unmasked dans les contextes de sécurité des conteneurs.
  • HostPath volumes.
  • Ajout de fonctionnalités (capabilities.add).
  • hostPort paramètre.
  • sysctls personnalisés.
  • Volumes projetés pour les jetons ou les certificats de compte de service.

Déployer le routeur de bac à sable (facultatif)

Le routeur Agent Sandbox est un proxy HTTP qui achemine les requêtes des clients, comme le client Python Agent Sandbox, vers les pods qui exécutent vos agents. Si vous prévoyez d'utiliser le client Python, par exemple comme décrit dans Isoler l'exécution du code d'IA avec Agent Sandbox sur GKE, déployez le routeur.

Vous déployez le routeur dans l'espace de noms agent-sandbox-system. Par défaut, la règle de réseau qu'Agent Sandbox sur GKE crée pour chaque ressource SandboxTemplate n'autorise le trafic entrant vers les pods d'agent que depuis les pods de routeur de cet espace de noms.

  1. Créez le compte de service du routeur et les autorisations RBAC qui permettent au routeur de rechercher les pods d'agent :

    kubectl apply \
        -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/sandbox-router/deploy/serviceaccount.yaml \
        -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/sandbox-router/deploy/rbac.yaml
    
  2. Déployez le routeur. La commande suivante définit l'image du routeur sur la même version que celle du contrôleur :

    curl -sSL https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/sandbox-router/deploy/deployment.yaml \
        | sed "s|sandbox-router-go:latest|sandbox-router-go:${AGENT_SANDBOX_VERSION}|" \
        | kubectl apply -f -
    
  3. Créez le service du routeur :

    kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/sandbox-router/deploy/service.yaml
    
  4. Attendez que le routeur soit prêt :

    kubectl rollout status deployment/sandbox-router \
        --namespace=agent-sandbox-system \
        --timeout=120s
    

Cette configuration de routeur est destinée au développement et aux tests. Pour connaître les paramètres de production, tels que TLS, le nombre d'instances répliquées et les règles de réseau pour le routeur, consultez le fichier README sur le déploiement du routeur de bac à sable.

Exporter les métriques du contrôleur (facultatif)

Le contrôleur Agent Sandbox exporte les métriques Prometheus sur le chemin d'accès /metrics sur le port metrics (port 8080). Pour collecter ces métriques à l'aide de Google Cloud Managed Service pour Prometheus et les interroger dans Cloud Monitoring, appliquez une ressource personnalisée PodMonitoring.

GKE active la collecte gérée par défaut sur les clusters Autopilot exécutant GKE version 1.25 ou ultérieure, et sur les clusters standards exécutant GKE version 1.27 ou ultérieure. Si la collecte gérée n'est pas activée sur votre cluster, consultez Activer la collecte gérée manuellement.

Étant donné que les compteurs et les histogrammes Prometheus n'enregistrent pas l'activité qui s'est produite avant le début de la collecte, appliquez la ressource PodMonitoring après avoir installé le contrôleur afin que Cloud Monitoring capture les événements de ressources de cluster et de bac à sable précoces.

  1. Dans Cloud Shell, créez un fichier nommé agent-sandbox-monitoring.yaml et contenant ce qui suit :

    apiVersion: monitoring.googleapis.com/v1
    kind: PodMonitoring
    metadata:
      name: agent-sandbox-controller
      namespace: agent-sandbox-system
    spec:
      selector:
        matchLabels:
          app: agent-sandbox-controller
      endpoints:
      - port: metrics
        path: /metrics
        interval: 30s
    
  2. Appliquez le fichier manifeste :

    kubectl apply -f agent-sandbox-monitoring.yaml
    

Après avoir appliqué la ressource PodMonitoring, Google Cloud Managed Service pour Prometheus extrait les métriques du contrôleur toutes les 30 secondes. Vous pouvez interroger ces métriques avec PromQL dans Cloud Monitoring à l'aide de l'explorateur de métriques.

Dans Cloud Monitoring, Google Cloud Managed Service pour Prometheus réserve l'étiquette namespace à l'espace de noms du pod du contrôleur extrait (agent-sandbox-system). Pour les métriques qui définissent leur propre étiquette namespace, Google Cloud Managed Service pour Prometheus renomme l'étiquette de métrique en exported_namespace. Pour filtrer ou regrouper les métriques par espace de noms de la ressource Sandbox, utilisez l'étiquette exported_namespace. Pour en savoir plus, consultez Libellés réservés.

Par exemple, vous pouvez interroger les métriques suivantes :

  • agent_sandbox_build_info : informations de compilation sur le contrôleur, telles que le commit et la version Git.

  • agent_sandboxes : nombre de ressources Sandbox dans le cluster à un moment précis. Cette métrique comporte des étiquettes pour l'aptitude, l'expiration, le type de lancement, le propriétaire, le créateur, le modèle et l'espace de noms de la ressource Sandbox (exported_namespace). Par exemple, la requête PromQL suivante regroupe les ressources Sandbox par espace de noms et par aptitude :

    sum by (exported_namespace, ready_condition) (agent_sandboxes)
    
  • agent_sandbox_claim_controller_startup_latency_ms : histogramme qui mesure la latence en millisecondes entre le moment où le contrôleur observe pour la première fois une ressource SandboxClaim et le moment où la revendication atteint l'état Ready. Comme cette métrique est un histogramme Prometheus, l'interrogation du nom de la métrique de base ne renvoie pas directement de données. Vous devez interroger sa série _bucket, _sum ou _count. Par exemple, la requête PromQL suivante calcule la latence de démarrage du 95e centile sur une fenêtre de taux de cinq minutes :

    histogram_quantile(
      0.95,
      sum by (le) (
        rate(agent_sandbox_claim_controller_startup_latency_ms_bucket[5m])
      )
    )
    

Pour en savoir plus sur les métriques exportées et les composants facultatifs dont elles dépendent, consultez la documentation de référence sur les métriques du contrôleur.

Déployer un environnement de bac à sable

Pour déployer un environnement de bac à sable, définissez une ressource SandboxTemplate et préparez des ressources Sandbox préchauffées à l'aide d'une ressource SandboxWarmPool. Vous pouvez ensuite demander une ressource Sandbox à partir de ce pool chaud à l'aide d'une ressource SandboxClaim. Vous pouvez également créer une ressource Sandbox directement, mais cette approche n'est pas compatible avec les pools de préchauffage.

SandboxTemplate, SandboxWarmPool, SandboxClaim et Sandbox sont des ressources personnalisées Kubernetes.

La ressource SandboxTemplate sert de modèle réutilisable. La ressource SandboxWarmPool gère un nombre spécifié de ressources Sandbox préprovisionnées avec des pods en cours d'exécution qui sont prêts à être revendiqués. Ce pool chaud réduit la latence de démarrage.

Pour déployer un environnement de bac à sable en créant des ressources SandboxTemplate et SandboxWarmPool, procédez comme suit :

  1. Dans Cloud Shell, créez un fichier nommé sandbox-template.yaml avec le contenu suivant :

    apiVersion: extensions.agents.x-k8s.io/v1beta1
    kind: SandboxTemplate
    metadata:
      name: python-runtime-template
      namespace: default
    spec:
      podTemplate:
        metadata:
          labels:
            sandbox-type: python-runtime
        spec:
          runtimeClassName: gvisor # Required
          automountServiceAccountToken: false # Required
          securityContext:
            runAsNonRoot: true # Required
          nodeSelector:
            sandbox.gke.io/runtime: gvisor # Required
          tolerations:
          - key: "sandbox.gke.io/runtime"
            value: "gvisor"
            effect: "NoSchedule" # Required
          containers:
          - name: runtime
            image: registry.k8s.io/agent-sandbox/python-runtime-sandbox:v0.1.0
            ports:
            - containerPort: 8888
            resources:
              requests:
                cpu: "250m"
                memory: "512Mi"
              limits:
                cpu: "500m"
                memory: "1Gi" # Required
            securityContext:
              capabilities:
                drop: ["ALL"] # Required
          restartPolicy: OnFailure
    
  2. Appliquez le fichier manifeste SandboxTemplate :

    kubectl apply -f sandbox-template.yaml
    
  3. Créez un fichier nommé sandbox-warmpool.yaml avec le contenu suivant :

    apiVersion: extensions.agents.x-k8s.io/v1beta1
    kind: SandboxWarmPool
    metadata:
      name: python-runtime-warmpool
      namespace: default
      labels:
        app: python-runtime-warmpool
    spec:
      replicas: 2
      sandboxTemplateRef:
        # This must match the name of the SandboxTemplate.
        name: python-runtime-template
    
  4. Appliquez le fichier manifeste SandboxWarmPool :

    kubectl apply -f sandbox-warmpool.yaml
    
  5. Attendez que les ressources Sandbox du pool préprovisionné et leurs pods soient prêts :

    kubectl wait sandboxwarmpool python-runtime-warmpool \
        --for=jsonpath='{.status.readyReplicas}'=2 \
        --timeout=600s
    

    Si vous créez une ressource SandboxClaim avant que les ressources Sandbox du pool et leurs pods ne soient prêts, le contrôleur crée une ressource Sandbox pour la revendication au lieu d'en attribuer une à partir du pool. Dans un cluster Autopilot, les pods peuvent mettre plusieurs minutes à être prêts, car GKE peut avoir besoin de créer des nœuds pour eux.

Créer une ressource SandboxClaim

La ressource SandboxClaim demande une ressource Sandbox au pool de préchauffage. Comme vous avez créé un pool chaud, le contrôleur attribue à la revendication une ressource Sandbox prête (et son pod en cours d'exécution) à partir du pool au lieu d'en créer une.

Pour demander une ressource Sandbox à partir du pool de préchauffage en créant une ressource SandboxClaim, procédez comme suit :

  1. Créez un fichier nommé sandbox-claim.yaml avec le contenu suivant :

    apiVersion: extensions.agents.x-k8s.io/v1beta1
    kind: SandboxClaim
    metadata:
      name: sandbox-claim
      namespace: default
    spec:
      warmPoolRef:
        # This must match the name of the SandboxWarmPool.
        name: python-runtime-warmpool
    
  2. Appliquez le fichier manifeste SandboxClaim :

    kubectl apply -f sandbox-claim.yaml
    
  3. Vérifiez que la ressource, la revendication et le pool de préchauffage du bac à sable sont prêts :

    kubectl get sandboxwarmpool,sandboxclaim,sandbox,pod
    

Alternative : créer une ressource Sandbox directement

Si vous n'avez pas besoin des temps de démarrage rapides fournis par les pools de préchauffage, vous pouvez déployer une ressource Sandbox directement sans utiliser de modèles.

Pour déployer un environnement de bac à sable en créant directement une ressource Sandbox, procédez comme suit :

  1. Créez un fichier nommé sandbox.yaml avec le contenu suivant :

    apiVersion: agents.x-k8s.io/v1beta1
    kind: Sandbox
    metadata:
      name: sandbox-example-2
    spec:
      podTemplate:
        metadata:
          labels:
            sandbox: sandbox-example
        spec:
          runtimeClassName: gvisor
          restartPolicy: OnFailure
          automountServiceAccountToken: false # Required
          securityContext:
            runAsNonRoot: true # Required
            runAsUser: 1000 # Required if image defaults to root (for example, busybox)
          nodeSelector:
            sandbox.gke.io/runtime: gvisor
          tolerations:
          - key: "sandbox.gke.io/runtime"
            value: "gvisor"
            effect: "NoSchedule" # Required
          containers:
          - name: my-container
            image: busybox
            command: ["/bin/sh", "-c"]
            args: ["sleep 3600000; echo 'Container finished successfully'; exit 0"]
            securityContext:
              capabilities:
                drop: ["ALL"] # Required
              allowPrivilegeEscalation: false
            resources:
              limits:
                cpu: "100m"
                memory: "128Mi" # Required
    
  2. Appliquez le fichier manifeste Sandbox :

    kubectl apply -f sandbox.yaml
    
  3. Vérifiez que la ressource Sandbox est en cours d'exécution :

    kubectl get sandbox
    

Mettre à niveau Agent Sandbox

Pour mettre à niveau Agent Sandbox, appliquez le fichier manifeste de la nouvelle version :

export AGENT_SANDBOX_VERSION="NEW_VERSION"
kubectl apply -f https://github.com/kubernetes-sigs/agent-sandbox/releases/download/${AGENT_SANDBOX_VERSION}/sandbox-with-extensions.yaml

Remplacez NEW_VERSION par la version que vous souhaitez installer, par exemple une version listée sur la page des versions d'Agent Sandbox.

Avant de procéder à la mise à niveau, consultez les notes de version de la nouvelle version. Si votre cluster exécute une version d'Agent Sandbox antérieure à la version 1.0.0, vous devez migrer vos ressources vers l'API v1beta1 avant d'effectuer la mise à niveau, car la version 1.0.0 a supprimé l'API v1alpha1. Pour obtenir des instructions, consultez le guide de migration de l'API.

Si vous avez déployé le routeur Sandbox ou appliqué la règle de sécurité recommandée, répétez ces étapes pour la nouvelle version.

Désinstaller Agent Sandbox

  1. Vérifiez si des ressources Agent Sandbox sont toujours utilisées :

    kubectl get sandboxes,sandboxclaims,sandboxwarmpools,sandboxtemplates \
        --all-namespaces
    
  2. Si vous avez appliqué la stratégie de sécurité recommandée, supprimez la liaison de stratégie et la stratégie :

    kubectl delete validatingadmissionpolicybinding secure-sandbox-binding
    kubectl delete validatingadmissionpolicy secure-sandbox-policy
    
  3. Si vous avez déployé le routeur Sandbox, supprimez ses ressources RBAC au niveau du cluster :

    kubectl delete -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/sandbox-router/deploy/rbac.yaml
    

    Les autres ressources du routeur se trouvent dans l'espace de noms agent-sandbox-system, qui sera supprimé à l'étape suivante.

  4. Pour supprimer le contrôleur Agent Sandbox, son espace de noms et ses CustomResourceDefinitions, supprimez le fichier manifeste de la version que vous avez installée :

    kubectl delete -f https://github.com/kubernetes-sigs/agent-sandbox/releases/download/${AGENT_SANDBOX_VERSION}/sandbox-with-extensions.yaml
    

Effectuer un nettoyage des ressources

Pour éviter que des frais ne soient facturés sur votre compte Cloud de Confiance by S3NS , supprimez le cluster GKE que vous avez créé.

gcloud container clusters delete ${CLUSTER_NAME} \
    --location=${LOCATION} \
    --quiet

Si vous avez créé un cluster Autopilot, l'emplacement correspond à la région (par exemple, us-central1). Si vous avez créé un cluster Standard, l'emplacement correspond à la zone (par exemple, us-central1-a).

Étapes suivantes