Aller au contenu principal

Agent Hermes sur GKE Autopilot

Agent Hermes sur GKE Autopilot

L'agent Hermes est un agent IA personnel auto-hébergé et auto-améliorant, open source (licence MIT) de Nous Research : il apprend des compétences par l'expérience, conserve sa mémoire entre les sessions et se connecte aux plateformes de messagerie ainsi qu'à une API compatible OpenAI à partir d'un processus de passerelle unique (documentation). Ce module déploie l'image officielle nousresearch/hermes-agent sur GKE Autopilot par-dessus la fondation App_GKE, qui provisionne et gère l'infrastructure partagée de Google Cloud et Kubernetes.

Ce guide se concentre sur les services cloud utilisés par Hermes et sur la manière de les explorer et de les exploiter depuis la console Google Cloud et la ligne de commande. Pour les mécanismes communs à chaque application GKE — Workload Identity, ingress, autoscaling, CI/CD, Cloud Armor, IAP, Binary Authorization, VPC Service Controls, sauvegardes et cycle de vie du déploiement —, reportez-vous au guide de la fondation App_GKE plutôt que de les répéter ici.


Coût d'Hermes sur RAD et comparaison​

L'exécution d'Hermes sur un pod GKE Autopilot dans votre propre projet Google Cloud coûte environ 142,62 $/mois en frais Google Cloud, en plus d'un frais de module RAD unique de 110 crédits facturé une fois au moment du déploiement. L'agent Hermes est un agent IA personnel auto-hébergé avec une mémoire persistante, ce déploiement comprend donc à la fois une base de données pour cette mémoire et un petit serveur de fichiers pour son état de fonctionnement — il n'existe pas de version commerciale hébergée de ce projet exact pour comparer. Dans un projet géré par RAD, les frais de module tombent à 99 crédits (10 % de moins) et le coût d'exécution est mesuré à l'heure en crédits au lieu d'être facturé directement par Google — voir Mettre en pause gratuitement ci-dessous pour le seul avantage géré par RAD qu'un VPS auto-hébergé ne peut égaler — ou voir le guide Cloud Run pour l'option la moins chère.

Ce que vous payez sur RAD​

Votre propre projetProjet géré par RAD
Frais de module (unique)110 crédits99 crédits (10 % de moins)
BuildsInclus dans le prix : pas de frais de build pour la création, 5 mises à jour par mois (mois calendaire UTC) gratuites puis 2 crédits chacune, et rien pour la suppression ou pour un build échoué, dans la limite de 10 builds échoués par jour (UTC). Les sessions de lab et les projets clients sont l'exception : ils sont toujours facturés à la minute pour le temps de buildIdentique
Coût d'exécution Google Cloud142,62 $/mois, facturé par Google au prix catalogue~138 crédits/jour, mesuré au prix catalogue plus la marge de RAD

Votre premier déploiement réussi sur RAD est exempt de frais de module, quel que soit le montant : une fois par compte, pour un module que vous déployez et payez vous-même (dans une solution, les frais d'une application : la première à réussir ; jamais une session de lab ou un projet client).

Coût d'exécution par défaut dans votre propre projet

RessourceUS$/mois (prix catalogue Google, us-central1)
Pod GKE Autopilot, 2 vCPU / 2 Gio72,16 $
Cloud SQL pour PostgreSQL, 1 vCPU / 3,75 Go, zonal, 10 Go SSD51,02 $
Serveur de fichiers NFS/cache (petite VM)13,43 $
Cloud NAT et réseau5,00 $
Cloud Storage (modules complémentaires, sauvegardes)1,00 $
Frais de gestion de cluster GKEpartagés entre toutes les applications GKE du projet ; 0 $ si c'est votre seul cluster, sinon ~73 $
Total142,62 $

Les frais de gestion de cluster GKE sont exclus du total ci-dessus car ils sont partagés entre toutes les applications GKE du projet — 0 $ si c'est la seule, sinon environ 73 $/mois répartis entre le nombre d'applications que vous exécutez.

Comparaison​

  • Une comparaison auto-gérée : Hetzner CPX22 (2 vCPU/4 Go) coûte environ 24 $/mois, un Droplet DigitalOcean 2 vCPU/4 Go coûte le même prix de 24 $/mois, et un GCP Compute Engine e2-standard-2 (2 vCPU/8 Go) coûte environ 49 $/mois — sur l'empreinte 1 vCPU/2 Gio de la variante Cloud Run, une classe plus petite ferait également l'affaire ; les 2 vCPU de la variante GKE correspondent plus étroitement aux boîtiers cités.
  • Ce qu'un VPS nu ne vous offre pas ici est plus important que d'habitude pour un agent qui conserve sa mémoire entre les sessions : sauvegardes Postgres automatiques, rotation des secrets pour ses clés API et surveillance si le processus se bloque — tout cela est couvert par la pile gérée de RAD.
  • Les coûts d'exécution de votre propre API LLM ne sont pas affectés dans les deux cas — cette comparaison ne concerne que l'infrastructure d'hébergement sur laquelle Hermes s'exécute, pas les appels de modèle qu'il effectue.

Mettre en pause gratuitement : supprimer un projet géré par RAD, le restaurer quand vous en avez besoin​

C'est l'avantage principal d'un projet géré par RAD, et il ne coûte rien lorsqu'il est en pause. La suppression d'un projet géré par RAD délie d'abord sa facturation, puis demande à Google de supprimer purement et simplement le projet — la propre suppression logicielle récupérable de 30 jours de Google. Contrairement à la suppression d'un module, cela ne supprime pas Cloud SQL, aucune VM ou la ressource de calcul une par une : l'ensemble du projet s'arrête simplement, et rien n'est facturé pendant qu'il attend, car la facturation est déjà déliée.

Une restauration n'est pas garantie — conservez vos propres sauvegardes. Les conditions de Google Cloud ne garantissent pas qu'un projet restauré, ou les ressources qu'il contient, seront utilisables après sa restauration, de sorte que la restauration ne peut pas être invoquée comme moyen de récupérer un projet supprimé. Avant de supprimer, assurez-vous d'avoir effectué des sauvegardes appropriées des données et de la configuration de l'application et de les avoir stockées en dehors du projet. Si une restauration échoue, ou si le projet restauré ne fonctionne pas, la solution de repli consiste à redéployer l'application (voir la section suivante) et à restaurer sa configuration et ses données à partir de ces sauvegardes.

La restauration, dans les 30 jours et uniquement par le propriétaire du projet, demande à Google de récupérer le projet et de rattacher son compte de facturation, puis vous demande d'exécuter « Update » sur chaque déploiement pour confirmer que tout est revenu. Comme rien n'a été détruit individuellement, cette mise à jour trouve les mêmes ressources déjà présentes — c'est une vérification, pas une reconstruction, et une mise à jour ne facture jamais les frais de module à nouveau. Les mises à jour sont incluses dans le prix (5 par mois pour chaque déploiement), donc une restauration ne coûte normalement aucun crédit.

Ce qu'il faut : vous devez être propriétaire du projet (pas un projet dont RAD gère uniquement la facturation), vous devez le restaurer vous-même dans les 30 jours — après cela, Google le supprime définitivement — et la restauration est admise comme la création d'un nouveau projet, donc votre solde de crédits achetés doit toujours dépasser le seuil du palier (100 crédits pour le palier sandbox qui convient à la plupart des utilisations d'étude/démo). Google indique que la plupart des services sont à nouveau pleinement fonctionnels dans les 36 heures suivant une restauration.

Un véritable manque : les sauvegardes nocturnes sont écrites dans un bucket à l'intérieur du projet, et ce bucket a la suppression logicielle de Cloud Storage explicitement désactivée, il est donc très probable qu'il disparaisse dès que vous supprimez le projet — même si le projet lui-même est récupérable pendant 30 jours. Si vous avez personnalisé Hermes et que vous souhaitez conserver ce travail, copiez une sauvegarde (vers Google Drive, ou un bucket en dehors du projet) avant de supprimer. Pour une installation par défaut sans rien d'irremplaçable, cela n'a pas d'importance.

Payer uniquement pendant l'utilisation, l'autre méthode : supprimer et redéployer​

Dans votre propre projet, ou une fois que 30 jours se sont écoulés sur un projet géré par RAD, il n'y a pas de pause gratuite — la suppression supprime les ressources définitivement, et ramener Hermes signifie redéployer à partir de zéro. Cela coûte 110 crédits (les frais de module ; les builds sont inclus).

La suppression ne permet d'économiser de l'argent que si Hermes reste inutilisé assez longtemps pour que le coût de redéploiement soit compensé par son propre coût d'exécution — pour Hermes, c'est environ 3 jours ou plus. La majeure partie de ce coût d'exécution est généralement la base de données (et, lorsque ce module en utilise un, la VM de serveur de fichiers partagé ou le cluster GKE) — ceux-ci ne s'arrêtent que lorsque rien d'autre dans le projet ne les utilise, donc la suppression de cette application alors que quelque chose d'autre partage le projet n'économise que sa propre part de calcul.

Conservez d'abord les données : les sauvegardes nocturnes vont dans un bucket à l'intérieur du déploiement et sont supprimées avec lui, alors copiez la dernière sauvegarde avant de supprimer si vous voulez la conserver.

Sessions de lab et environnements gérés​

Sessions de lab, pour la formation : un formateur anime une session pour une classe. Chaque participant obtient l'application dans son propre projet Google Cloud pendant 15 minutes à 24 heures, dans la limite d'une allocation définie par le formateur. Le formateur peut aussi créer un seul environnement partagé pour toute la classe, et chacun utilise alors la même application et ses données. Soit le formateur finance toutes les places, soit chaque participant paie la sienne. Tout est supprimé à la fin de la session et les crédits inutilisés sont reversés au formateur.

Environnements gérés, pour les sociétés de conseil : un partenaire exécute l'application pour un client à partir d'un portefeuille cloisonné qu'il finance, et règle directement avec le client. Si le portefeuille est faible, la facturation est suspendue et les données sont conservées, de sorte que personne ne reçoit de frais inattendus. À la fin, le partenaire transfère le projet et les déploiements deviennent la propriété du client.

Les crédits peuvent être achetés dans plus de 20 devises, y compris XAF, XOF, NGN, GHS, KES et ZAR, par carte, virement bancaire ou argent mobile.

Sources (8 octobre 2026) : Prix catalogue de l'API Google Cloud Billing Catalog ; radmodules.dev/pricing pour les propres frais de RAD et les estimations de crédits quotidiens ; documentation de Google sur la suppression/restauration de projets pour les affirmations de pause/restauration.

1. Vue d'ensemble​

Hermes s'exécute comme un pod de passerelle à réplica unique sur GKE Autopilot. Le déploiement relie un ensemble délibérément restreint de services Google Cloud :

CapacitéService Google CloudNotes
CalculGKE AutopilotPod de passerelle, 2 vCPU / 2 Gio par défaut, min=1 / max=1 réplicas
État de l'agentNFS auto-géré (Services_GCP)Monté à /opt/data — configuration SQLite, sessions, compétences, mémoires. Pas de Cloud SQL
SecretsSecret Manager (+ SecretSync)ANTHROPIC_API_KEY, API_SERVER_KEY et mot de passe du tableau de bord auto-générés, OPENAI_API_KEY / TELEGRAM_BOT_TOKEN optionnels
Image de conteneurArtifact Registry (miroir)Image pré-construite officielle mise en miroir ; pas de build personnalisé, pas d'étape Cloud Build
RéseauVPC + Cloud Load BalancingService LoadBalancer externe avec IP statique réservée par défaut
Base de données / cache—Pas de Cloud SQL, pas de Redis — Hermes est entièrement SQLite-sur-NFS

Valeurs par défaut judicieuses à connaître d'emblée :

  • Tout l'état de l'agent se trouve à /opt/data, et ce chemin est fixe à l'intérieur de l'image. Le NFS de la plateforme partagée est monté directement par-dessus (enable_nfs = true, nfs_mount_path = "/opt/data", tous deux par défaut et appliqués par une validation au moment du plan). Sans le montage, chaque redémarrage de pod ou redéploiement efface silencieusement l'identité accumulée de l'agent.
  • max_instance_count est validé à 1. L'état d'Hermes est SQLite, qui a un modèle à un seul rédacteur — un second réplica concurrent corrompt la base de données. La fondation déploie en outre des applications basées sur NFS avec la stratégie Recreate, de sorte que les mises à jour n'exécutent jamais brièvement deux pods sur le volume.
  • Le serveur API compatible OpenAI écoute sur le port 8642 et nécessite le jeton porteur API_SERVER_KEY auto-généré.
  • Les sondes sont par défaut des écoutes de port TCP — le serveur API nécessite une authentification, donc une sonde HTTP contre celui-ci renverrait 401 et bloquerait le déploiement.
  • Le tableau de bord web (port 9119, authentification basique) n'est pas exposé par le Service — accédez-y avec kubectl port-forward.
  • API_SERVER_KEY est injecté comme un Secret Kubernetes explicite plutôt que via SecretSync, qui peut matérialiser une valeur vide lors du premier déploiement avant que la réplication de Secret Manager ne soit terminée. Tous les autres secrets sont basés sur SecretSync.
  • Au moins une clé de fournisseur de modèle est requise lors du déploiement initial (anthropic_api_key, ou enable_openai + openai_api_key) ; une vérification au moment du plan avertit lorsqu'aucune n'est fournie.
  • Pas de jobs d'initialisation, pas de bootstrap de base de données — le premier démarrage initialise uniquement /opt/data sur le partage NFS.

2. Services Google Cloud et comment les explorer​

Toutes les commandes supposent que vous avez exécuté gcloud container clusters get-credentials <cluster> --region <region> --project <project> et que PROJECT, REGION et NAMESPACE sont définis. L'espace de noms et les autres identifiants sont rapportés dans les Sorties du déploiement.

A. GKE Autopilot — la charge de travail Hermes​

Le pod de passerelle Hermes est planifié sur Autopilot, qui facture le CPU/la mémoire que le pod demande réellement. Les réplicas sont fixés à un ; les signaux intéressants sont la disponibilité du pod, les redémarrages et le montage du volume NFS.

  • Console : Kubernetes Engine → Workloads → sélectionnez la charge de travail Hermes pour les pods et les événements ; Services & Ingress affiche l'adresse IP externe.
  • CLI :
    kubectl get pods,svc -n "$NAMESPACE"
    kubectl describe pod -n "$NAMESPACE" <pod> # events: probes, mounts
    kubectl logs -n "$NAMESPACE" deploy/<service-name> --tail=100

Voir App_GKE pour Autopilot, les types de charges de travail et le cycle de vie du déploiement.

B. Stockage partagé NFS — l'identité de l'agent​

L'état complet de l'agent (base de données de configuration SQLite, clés API, sessions, compétences apprises, mémoires) réside sur le serveur NFS partagé auto-géré provisionné par Services_GCP (create_network_filesystem = true), monté à /opt/data dans le pod. La VM NFS doit être RUNNING avant que ce module ne soit déployé — la découverte la trouve par étiquette.

  • Console : Compute Engine → Instances de VM (la VM du serveur NFS).
  • CLI :
    gcloud compute instances list --project "$PROJECT" \
    --filter="name~nfs" --format="table(name,zone,status)"
    # Confirm the mount inside the pod:
    kubectl exec -n "$NAMESPACE" deploy/<service-name> -- df -h /opt/data
    kubectl exec -n "$NAMESPACE" deploy/<service-name> -- ls /opt/data

Le partage et ses données sont détenus par Services_GCP — la destruction du déploiement Hermes ne supprime pas l'état de l'agent sur l'exportation NFS.

C. Secret Manager​

Cinq secrets peuvent exister par déploiement : ANTHROPIC_API_KEY (fourni par l'opérateur), API_SERVER_KEY (hexadécimal de 64 caractères auto-généré — le jeton porteur de l'API de passerelle), HERMES_DASHBOARD_BASIC_AUTH_PASSWORD (auto-généré), et éventuellement OPENAI_API_KEY et TELEGRAM_BOT_TOKEN. Ils apparaissent dans l'espace de noms en tant que Secrets Kubernetes (SecretSync pour la plupart ; un Secret explicite pour API_SERVER_KEY).

  • Console : Sécurité → Secret Manager.
  • CLI :
    gcloud secrets list --project "$PROJECT" --filter="name~hermes"
    gcloud secrets versions access latest --secret=<secret-name> --project "$PROJECT"
    kubectl get secrets -n "$NAMESPACE"

Les variables d'identification vides lors d'un déploiement de mise à jour conservent la version latest stockée. Voir App_GKE pour l'intégration de SecretSync.

D. Artifact Registry — l'image mise en miroir​

L'image officielle nousresearch/hermes-agent:<version> est mise en miroir dans Artifact Registry avant le déploiement (enable_image_mirroring = true) afin que les nœuds ne tirent jamais depuis Docker Hub. Il n'y a pas d'étape Cloud Build — il s'agit d'un module pré-construit. Les images mises en miroir sont tirées avec imagePullPolicy: Always.

  • Console : Artifact Registry → Dépôts.
  • CLI :
    gcloud artifacts repositories list --project "$PROJECT" --location "$REGION"
    gcloud artifacts docker images list \
    "$REGION-docker.pkg.dev/$PROJECT/<repo>" --filter="package~hermes"

E. Réseau et ingress​

La passerelle est exposée par défaut via un service LoadBalancer externe, avec une IP statique réservée afin que l'adresse survive aux redéploiements. Le serveur API applique sa propre authentification par jeton porteur, de sorte que le fait que le point de terminaison soit public est intentionnel ; un domaine personnalisé avec un certificat géré peut être superposé via l'API Gateway.

  • Console : Services réseau → Équilibrage de charge ; Réseau VPC → Adresses IP.
  • CLI :
    kubectl get svc -n "$NAMESPACE"
    gcloud compute addresses list --project "$PROJECT"

Voir App_GKE pour les domaines personnalisés, Cloud CDN et les IP statiques.

F. Cloud Logging et Monitoring​

Les sorties stdout/stderr des pods sont acheminées vers Cloud Logging ; les métriques GKE vers Cloud Monitoring. Le test de disponibilité est désactivé par défaut — le serveur API nécessite une authentification, donc un test de disponibilité non authentifié échouerait toujours.

  • Console : Logging → Explorateur de journaux ; Monitoring → Tableaux de bord / Alertes.
  • CLI :
    gcloud logging read 'resource.type="k8s_container" AND resource.labels.namespace_name="'"$NAMESPACE"'"' \
    --project "$PROJECT" --limit 50

3. Comportement de l'application Hermes​

  • Initialisation du répertoire de données au premier démarrage. Le point d'entrée de l'image est /init de s6-overlay, qui démarre en tant que root, chown le volume /opt/data (le nouveau répertoire NFS) à l'utilisateur non-root hermes, puis abandonne les privilèges et démarre la passerelle (container_args = ["gateway", "run"] — la commande par défaut de l'image est la CLI interactive, donc la passerelle doit être démarrée explicitement).
  • Pas de job d'initialisation de base de données. Hermes crée sa propre base de données de configuration SQLite sous /opt/data au premier démarrage ; il n'y a rien à amorcer et initialization_jobs est vide. database_type = "NONE" et enable_redis = false sont codés en dur dans l'appel de la Fondation.
  • L'accès à l'API nécessite le API_SERVER_KEY. Le point de terminaison compatible OpenAI sur le port 8642 s'authentifie avec un jeton porteur :
    KEY=$(gcloud secrets versions access latest --secret=<api-server-key-secret> --project "$PROJECT")
    EXTERNAL_IP=$(kubectl get svc -n "$NAMESPACE" \
    -o jsonpath='{.items[?(@.spec.type=="LoadBalancer")].status.loadBalancer.ingress[0].ip}')
    curl -s -H "Authorization: Bearer $KEY" "http://${EXTERNAL_IP}:8642/v1/models"
    (Le Service mappe son port au port du conteneur ; vérifiez kubectl get svc pour le port exposé.)
  • Tableau de bord via port-forward. Le tableau de bord web intégré (gestion des clés API, configuration du profil) s'exécute sur le port 9119 derrière une authentification basique et n'est pas exposé par le Service. Accédez-y localement :
    kubectl port-forward -n "$NAMESPACE" deploy/<service-name> 9119:9119
    # then open http://localhost:9119 — user `admin`, password from Secret Manager
  • Configuration du connecteur (Telegram). Définissez enable_telegram = true et fournissez telegram_bot_token (de @BotFather). Le connecteur Telegram d'Hermes interroge en mode long-polling en sortie — aucun webhook, routeur ou URL de rappel public n'est nécessaire. Une validation au moment du plan rejette enable_telegram = true avec un jeton vide. Les autres connecteurs (Discord, Slack, WhatsApp, Signal) sont configurés via la carte opérateur environment_variables.
  • Les mises à jour de version utilisent Recreate. Étant donné que l'application est basée sur NFS, la fondation remplace l'arrêt puis le démarrage du pod au lieu de le déployer — une brève interruption de disponibilité pendant les mises à jour est attendue et protège la base de données SQLite d'un chevauchement de deux rédacteurs.

4. Variables de configuration​

Les variables sont regroupées exactement comme elles apparaissent sur la plateforme de déploiement. Seuls les paramètres spécifiques ou notables pour Hermes sont listés ; toutes les autres entrées sont héritées de App_GKE avec son comportement et ses valeurs par défaut standards.

Groupe 1 — Projet, identité et identifiants​

VariableValeur par défautDescription
project_id(obligatoire)Projet Google Cloud cible.
regionus-central1Région pour la charge de travail et les ressources régionales.
anthropic_api_key""Clé principale du fournisseur de modèle, injectée en tant que ANTHROPIC_API_KEY. Obligatoire lors du déploiement initial (ou utilisez OpenAI) ; omettez lors des mises à jour pour conserver la version stockée.
api_server_key"" (auto)Jeton porteur pour le serveur API compatible OpenAI. Hexadécimal de 64 caractères auto-généré lorsqu'il est vide.
enable_openai / openai_api_keyfalse / ""Fournisseur secondaire optionnel, injecté en tant que OPENAI_API_KEY.
enable_dashboardtrueExécute le tableau de bord du port 9119 en cours de processus ; accessible via kubectl port-forward.
dashboard_username / dashboard_passwordadmin / "" (auto)Authentification basique du tableau de bord ; mot de passe auto-généré dans Secret Manager.

Groupe 3 — Identité de l'application​

VariableValeur par défautDescription
application_namehermesNom de base des ressources. Ne pas modifier après le premier déploiement.
application_versionlatestTag d'image nousresearch/hermes-agent ; épingler à un tag de version en production.

Groupe 4 — Exécution et mise à l'échelle​

VariableValeur par défautDescription
container_resources2000m / 2GiLimites de CPU et de mémoire pour le conteneur de la passerelle.
min_instance_count1Maintenir à 1 pour éviter les démarrages à froid pour les sessions d'agent.
max_instance_count1Validé à 1 — SQLite mono-rédacteur sur le NFS partagé.
container_port8642Port du serveur API compatible OpenAI de la passerelle.
timeout_seconds3600Les sessions d'agent peuvent être de longue durée.
container_image_sourceprebuiltDéploie l'image officielle sans étape de build.
enable_image_mirroringtrueMettre en miroir dans Artifact Registry pour éviter les limites de débit de Docker Hub.

Groupe 5 — Variables d'environnement et secrets​

VariableValeur par défautDescription
environment_variables{}Configuration supplémentaire ; les variables gérées par le module (API_SERVER_*, HERMES_DASHBOARD*) ont la priorité. Utilisez-les pour les identifiants de connecteur Discord/Slack/WhatsApp/Signal ou les points de terminaison de fournisseur (par exemple, OpenRouter).
secret_environment_variables{}Mappage de la variable d'environnement → nom de secret Secret Manager existant.

Groupe 6 — Backend et cluster GKE​

VariableValeur par défautDescription
service_typeLoadBalancerIP externe par défaut ; le serveur API applique l'authentification par jeton porteur.
session_affinityClientIPRoutage persistant (réplica unique, donc la plupart du temps sans objet).
termination_grace_period_seconds60Temps pour que les sessions d'agent actives se terminent à l'arrêt.

Groupe 10 — Observabilité et santé​

VariableValeur par défautDescription
startup_probeTCP, délai de 10 s, 36 tentativesÉcoute de port TCP — sûre quelle que soit l'authentification du serveur API ; marge pour le montage NFS et l'initialisation au premier démarrage.
liveness_probeTCP, délai de 30 sÉcoute de port TCP.
uptime_check_configdésactivéUn test de disponibilité non authentifié échouerait toujours contre le serveur API authentifié.

Groupe 13 — Système de fichiers (NFS)​

VariableValeur par défautDescription
enable_nfstrueObligatoire — validé. L'identité entière de l'agent réside sous /opt/data.
nfs_mount_path/opt/dataRépertoire de données fixe de l'image ; le partage NFS est monté directement par-dessus.

Groupe 14 — Cloud Storage et Artifact Registry​

VariableValeur par défautDescription
gcs_volumes[]Montages auxiliaires GCSFuse uniquement — ne jamais pointer vers /opt/data (SQLite est dangereux sur GCSFuse).
max_images_to_retain / delete_untagged_images / image_retention_days(défini)Politique de nettoyage d'Artifact Registry.

Groupe 15 — Connecteurs Hermes​

VariableValeur par défautDescription
enable_telegramfalseProvisionne le secret du jeton du bot Telegram et injecte TELEGRAM_BOT_TOKEN.
telegram_bot_token""Jeton du bot de @BotFather ; requis (validé) lorsque enable_telegram = true.

Groupe 19 — Domaine personnalisé et IP statique​

VariableValeur par défautDescription
enable_custom_domaintrueConfiguration de domaine personnalisé de l'API Gateway avec SSL géré (nécessite application_domains).
reserve_static_iptrueIP externe stable sur les redéploiements.

Miroirs de convention inertes : la base de données (groupe 16), Redis (miroirs du groupe 15), SQL personnalisé (groupe 18) et les variables enable_cloudsql_volume sont déclarées pour la parité de convention mais codées en dur sur off dans main.tf — Hermes n'a pas de base de données et pas de Redis.


5. Sorties​

Ces valeurs sont renvoyées lors d'un déploiement réussi et constituent le moyen le plus rapide de localiser et d'explorer les ressources en cours d'exécution.

SortieDescription
service_nameNom du service Kubernetes.
namespaceEspace de noms dans lequel la charge de travail s'exécute.
service_cluster_ipClusterIP intra-cluster.
stage_service_cluster_ipsCarte des ClusterIP pour les services spécifiques à chaque étape.
service_external_ipIP externe du LoadBalancer (lorsqu'une IP statique est réservée).
api_urlURL pour atteindre le serveur API de la passerelle.
storage_bucketsBuckets Cloud Storage créés (aucun par défaut).
network_name / network_exists / regionsRéseau VPC, présence, régions disponibles.
container_image / container_registryImage déployée et dépôt Artifact Registry.
monitoring_enabled / monitoring_notification_channelsÉtat et canaux de surveillance.
initialization_jobs / cron_jobsNoms des jobs de configuration et planifiés (vides par défaut).
statefulset_nameNom du StatefulSet (lorsqu'une charge de travail StatefulSet est sélectionnée).
deployment_id / tenant_id / resource_prefixIdentifiants de nommage.
project_id / project_numberIdentifiants de projet.
cicd_enabled / cicd_configurationÉtat et détails CI/CD.
github_repository_url / github_repository_owner / github_repository_nameDétails GitHub CI/CD.
artifact_registry_repository / cloudbuild_trigger_name / cloudbuild_trigger_idRegistre et déclencheur de build.
kubernetes_readyIndique si le point de terminaison du cluster était lisible et si les charges de travail Kubernetes ont été déployées (faux lors du premier apply d'un nouveau cluster inline — réexécuter apply).

6. Pièges de configuration et valeurs par défaut judicieuses​

Risque : Critique (perte de données / panne / sécurité) — Élevé (service dégradé) — Moyen (coût ou dégradation partielle) — Faible (mineur).

Validation au moment du plan. Le validation.tf de ce module et le moteur de la fondation App_GKE valident les valeurs et les combinaisons au moment du plan — max_instance_count > 1, enable_nfs = false, un connecteur Telegram sans son jeton, ou OpenAI activé sans clé, tout cela fait échouer le plan avec une erreur claire et nommée avant qu'aucune ressource ne soit créée.

ParamètreValeur judicieuseRisqueConséquence si erreur
max_instance_count1 (validé)CritiqueUn second réplica concurrent écrit dans la même base de données SQLite sur NFS — la violation du mono-rédacteur corrompt l'état entier de l'agent.
enable_nfstrue (validé)CritiqueSans le montage NFS, /opt/data est un disque de pod éphémère — chaque redémarrage / redéploiement efface silencieusement l'identité de l'agent (configuration, sessions, compétences, mémoires).
gcs_volumes à /opt/datajamaisCritiqueGCSFuse manque de verrouillage POSIX et de renommages atomiques ; SQLite sur GCSFuse se corrompt. Gardez l'état sur NFS.
quota_memory_requests / _limitsunités binaires (4Gi, 8192Mi)CritiqueLes entiers bruts sont des octets et bloquent toute planification de pod dans l'espace de noms.
anthropic_api_key (ou paire OpenAI)défini au premier déploiementÉlevéSans aucune clé de fournisseur, l'agent ne peut pas exécuter un seul tour.
VM NFS non RUNNINGattendre avant de déployerÉlevéLa découverte ne trouve aucun serveur → le module crée un NFS inline ou le montage échoue ; le pod reste en ContainerCreating.
startup_probe / liveness_probeTCP (par défaut)MoyenUne sonde HTTP contre le serveur API authentifié renvoie 401/403 indéfiniment — le pod ne devient jamais Ready et le déploiement se bloque.
min_instance_count1MoyenGKE n'a pas de mise à l'échelle à zéro, mais une mise à l'échelle manuelle laisse les connecteurs hors ligne.
application_versionépingler un tag de versionMoyenlatest se résout à nouveau par exécution de miroir ; le comportement peut changer sous vous lors du redéploiement.
enable_telegram sans jetonbloquéFaibleLa validation au moment du plan le rejette ; le connecteur ne peut pas démarrer sans le jeton du bot.

Pour le comportement de la fondation référencé tout au long — IAM et Workload Identity, ingress et certificats, CI/CD, Cloud Armor, IAP, Binary Authorization, VPC-SC, sauvegardes et mise en miroir d'images — voir App_GKE. La configuration d'application spécifique à Hermes partagée avec la variante Cloud Run est décrite dans Hermes_Common.

Need RAD to do something it does not do yet? Request it on the roadmap, or vote on what is already there.