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 projet | Projet géré par RAD | |
|---|---|---|
| Frais de module (unique) | 110 crédits | 99 crédits (10 % de moins) |
| Builds | Inclus 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 build | Identique |
| Coût d'exécution Google Cloud | 142,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
| Ressource | US$/mois (prix catalogue Google, us-central1) |
|---|---|
| Pod GKE Autopilot, 2 vCPU / 2 Gio | 72,16 $ |
| Cloud SQL pour PostgreSQL, 1 vCPU / 3,75 Go, zonal, 10 Go SSD | 51,02 $ |
| Serveur de fichiers NFS/cache (petite VM) | 13,43 $ |
| Cloud NAT et réseau | 5,00 $ |
| Cloud Storage (modules complémentaires, sauvegardes) | 1,00 $ |
| Frais de gestion de cluster GKE | partagés entre toutes les applications GKE du projet ; 0 $ si c'est votre seul cluster, sinon ~73 $ |
| Total | 142,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 Cloud | Notes |
|---|---|---|
| Calcul | GKE Autopilot | Pod de passerelle, 2 vCPU / 2 Gio par défaut, min=1 / max=1 réplicas |
| État de l'agent | NFS auto-géré (Services_GCP) | Monté à /opt/data — configuration SQLite, sessions, compétences, mémoires. Pas de Cloud SQL |
| Secrets | Secret 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 conteneur | Artifact Registry (miroir) | Image pré-construite officielle mise en miroir ; pas de build personnalisé, pas d'étape Cloud Build |
| Réseau | VPC + Cloud Load Balancing | Service 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_countest 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égieRecreate, 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_KEYauto-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_KEYest 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, ouenable_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/datasur 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
/initde s6-overlay, qui démarre en tant que root,chownle volume/opt/data(le nouveau répertoire NFS) à l'utilisateur non-roothermes, 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/dataau premier démarrage ; il n'y a rien à amorcer etinitialization_jobsest vide.database_type = "NONE"etenable_redis = falsesont 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 :(Le Service mappe son port au port du conteneur ; vérifiezKEY=$(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"kubectl get svcpour 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 = trueet fournisseztelegram_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 rejetteenable_telegram = trueavec un jeton vide. Les autres connecteurs (Discord, Slack, WhatsApp, Signal) sont configurés via la carte opérateurenvironment_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
| Variable | Valeur par défaut | Description |
|---|---|---|
project_id | (obligatoire) | Projet Google Cloud cible. |
region | us-central1 | Ré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_key | false / "" | Fournisseur secondaire optionnel, injecté en tant que OPENAI_API_KEY. |
enable_dashboard | true | Exécute le tableau de bord du port 9119 en cours de processus ; accessible via kubectl port-forward. |
dashboard_username / dashboard_password | admin / "" (auto) | Authentification basique du tableau de bord ; mot de passe auto-généré dans Secret Manager. |
Groupe 3 — Identité de l'application
| Variable | Valeur par défaut | Description |
|---|---|---|
application_name | hermes | Nom de base des ressources. Ne pas modifier après le premier déploiement. |
application_version | latest | Tag d'image nousresearch/hermes-agent ; épingler à un tag de version en production. |
Groupe 4 — Exécution et mise à l'échelle
| Variable | Valeur par défaut | Description |
|---|---|---|
container_resources | 2000m / 2Gi | Limites de CPU et de mémoire pour le conteneur de la passerelle. |
min_instance_count | 1 | Maintenir à 1 pour éviter les démarrages à froid pour les sessions d'agent. |
max_instance_count | 1 | Validé à 1 — SQLite mono-rédacteur sur le NFS partagé. |
container_port | 8642 | Port du serveur API compatible OpenAI de la passerelle. |
timeout_seconds | 3600 | Les sessions d'agent peuvent être de longue durée. |
container_image_source | prebuilt | Déploie l'image officielle sans étape de build. |
enable_image_mirroring | true | Mettre en miroir dans Artifact Registry pour éviter les limites de débit de Docker Hub. |
Groupe 5 — Variables d'environnement et secrets
| Variable | Valeur par défaut | Description |
|---|---|---|
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
| Variable | Valeur par défaut | Description |
|---|---|---|
service_type | LoadBalancer | IP externe par défaut ; le serveur API applique l'authentification par jeton porteur. |
session_affinity | ClientIP | Routage persistant (réplica unique, donc la plupart du temps sans objet). |
termination_grace_period_seconds | 60 | Temps pour que les sessions d'agent actives se terminent à l'arrêt. |
Groupe 10 — Observabilité et santé
| Variable | Valeur par défaut | Description |
|---|---|---|
startup_probe | TCP, 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_probe | TCP, délai de 30 s | Écoute de port TCP. |
uptime_check_config | désactivé | Un test de disponibilité non authentifié échouerait toujours contre le serveur API authentifié. |
Groupe 13 — Système de fichiers (NFS)
| Variable | Valeur par défaut | Description |
|---|---|---|
enable_nfs | true | Obligatoire — validé. L'identité entière de l'agent réside sous /opt/data. |
nfs_mount_path | /opt/data | Répertoire de données fixe de l'image ; le partage NFS est monté directement par-dessus. |
Groupe 14 — Cloud Storage et Artifact Registry
| Variable | Valeur par défaut | Description |
|---|---|---|
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
| Variable | Valeur par défaut | Description |
|---|---|---|
enable_telegram | false | Provisionne 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
| Variable | Valeur par défaut | Description |
|---|---|---|
enable_custom_domain | true | Configuration de domaine personnalisé de l'API Gateway avec SSL géré (nécessite application_domains). |
reserve_static_ip | true | IP 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.
| Sortie | Description |
|---|---|
service_name | Nom du service Kubernetes. |
namespace | Espace de noms dans lequel la charge de travail s'exécute. |
service_cluster_ip | ClusterIP intra-cluster. |
stage_service_cluster_ips | Carte des ClusterIP pour les services spécifiques à chaque étape. |
service_external_ip | IP externe du LoadBalancer (lorsqu'une IP statique est réservée). |
api_url | URL pour atteindre le serveur API de la passerelle. |
storage_buckets | Buckets Cloud Storage créés (aucun par défaut). |
network_name / network_exists / regions | Réseau VPC, présence, régions disponibles. |
container_image / container_registry | Image déployée et dépôt Artifact Registry. |
monitoring_enabled / monitoring_notification_channels | État et canaux de surveillance. |
initialization_jobs / cron_jobs | Noms des jobs de configuration et planifiés (vides par défaut). |
statefulset_name | Nom du StatefulSet (lorsqu'une charge de travail StatefulSet est sélectionnée). |
deployment_id / tenant_id / resource_prefix | Identifiants de nommage. |
project_id / project_number | Identifiants de projet. |
cicd_enabled / cicd_configuration | État et détails CI/CD. |
github_repository_url / github_repository_owner / github_repository_name | Détails GitHub CI/CD. |
artifact_registry_repository / cloudbuild_trigger_name / cloudbuild_trigger_id | Registre et déclencheur de build. |
kubernetes_ready | Indique 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.tfde 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ètre | Valeur judicieuse | Risque | Conséquence si erreur |
|---|---|---|---|
max_instance_count | 1 (validé) | Critique | Un 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_nfs | true (validé) | Critique | Sans 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/data | jamais | Critique | GCSFuse manque de verrouillage POSIX et de renommages atomiques ; SQLite sur GCSFuse se corrompt. Gardez l'état sur NFS. |
quota_memory_requests / _limits | unités binaires (4Gi, 8192Mi) | Critique | Les 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 RUNNING | attendre 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_probe | TCP (par défaut) | Moyen | Une 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_count | 1 | Moyen | GKE 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 version | Moyen | latest se résout à nouveau par exécution de miroir ; le comportement peut changer sous vous lors du redéploiement. |
enable_telegram sans jeton | bloqué | Faible | La 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.
Guides associés
- Lab pratique : Agent Hermes sur GKE Autopilot — déployez-le étape par étape, avec les écrans de la console et les commandes à chaque étape.
- Agent Hermes sur Google Cloud Run — la même application sur Cloud Run, lorsque vous avez besoin de l'autre cible de déploiement.
- Hermes Common — Configuration d'application partagée — la configuration partagée par les deux cibles de déploiement.
Need RAD to do something it does not do yet? Request it on the roadmap, or vote on what is already there.