Un agent IA monte son infrastructure par MCP

Une exécution réelle : réseau privé, deux Nano, pare-feu limité à une adresse et répartiteur de charge, montés puis démontés par un agent via le serveur MCP de FFxF. Les appels, les temps, la surprise du pare-feu et les refus qui l'ont retenu.

Une conversation d'agent IA reliée par une prise MCP à un réseau privé où un répartiteur dessert deux machines, sous un pare-feu

Dans une démo précédente, un agent IA louait une machine, s'en servait et la rendait. Une vraie application demande davantage : plusieurs serveurs, un réseau entre eux, un pare-feu, un point d'entrée unique. Cet article reprend le même serveur MCP, https://ffxf.net/mcp, et lui fait monter une petite architecture complète, puis la démonter.

Exécution réelle du 3 novembre 2026, à Montréal : 85 appels d'outils, 5 minutes 16 secondes de la première requête à la dernière, 0,046 CAD au total. Chaque réponse citée plus bas est abrégée, jamais réécrite.

1. La demande et ce qu'elle devient

Voici la phrase donnée à l'agent (Claude Code), avec une clé d'API dans FFXF_API_KEY :

prompt
Monte deux serveurs web Debian derrière un répartiteur de charge, dans un réseau
privé à eux. Des Nano à l'heure. Le HTTP et le SSH directs seulement depuis
23.159.52.5. Montre le prix avant de commander. Quand j'aurai vérifié, détruis tout.

L'agent en tire une séquence d'outils. L'ordre n'est pas libre : le répartiteur et les machines ont besoin du réseau privé, les cibles du répartiteur doivent être dans ce réseau, le pare-feu ne s'attache qu'à une machine qui existe.

Pour mesurer chaque appel, l'agent a écrit un court script Python qui parle au serveur MCP en JSON-RPC, plutôt que de passer par son client intégré. Les outils et les réponses sont les mêmes.

2. Parler au serveur sans client MCP

Le serveur est sans état : pas de session à ouvrir, chaque requête HTTP se suffit. tools/list renvoie les 71 outils de la version 1.12.0 avec leur schéma, tools/call en exécute un.

bash
curl -s https://ffxf.net/mcp \
  -H "Authorization: Bearer $FFXF_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call",
       "params":{"name":"get_account","arguments":{}}}'

La réponse de l'API arrive en texte JSON dans result.content[0].text. Ici, le solde, la consommation horaire et le budget mensuel :

json
{ "credit": { "balance": "…" },
  "hourly": { "burn_rate": "0.036", "active_machines": 2 },
  "budget": { "monthly": "…", "cap_percent": 120 },
  "quota":  { "limit": 20, "used": 3, "remaining": 17 } }

3. La construction, appel par appel

Le réseau privé d'abord. Au premier essai, la création a été refusée : un autre test occupait le troisième et dernier réseau privé permis au compte. Le refus dit pourquoi et où demander plus.

json
create_vpc { "name": "blog-09-agent-mcp-vpc", "cidr": "10.90.0.0/24", "region": "montreal" }

{ "error": { "status": 409, "code": "action_conflict",
  "message": "You have reached your limit of 3 private networks.",
  "details": { "quota": 3, "increase_url": "https://console.ffxf.net/servers/vpcs" } } }

Une fois la place libérée, le même appel répond en 4,6 secondes avec un réseau active, passerelle en 10.90.0.1. Puis, pour chaque machine, l'estimation avant la commande, comme le serveur le demande à l'agent dans ses consignes :

json
estimate_vm { "plan": "nano", "region": "montreal", "image": "debian-13",
              "hostname": "blog-09-agent-mcp-web-1", "billing": "hourly",
              "ssh_keys": ["34"], "vpc": 41 }

{ "would_succeed": true, "hourly_rate": "0.018", "required_credit": "0.44",
  "checks": [ "quota: pass", "stock: pass", "billing_mode: pass",
              "credit: pass", "budget: pass" ] }

create_vm { …même commande…, "password_delivery": "none" }

{ "vm": { "id": 312, "status": "provisioning" },
  "action": { "id": 398, "type": "create", "status": "queued" } }

Le pare-feu et le répartiteur se créent pendant que les machines démarrent. Le pare-feu n'ouvre que deux ports entrants, et seulement pour une adresse :

json
create_firewall { "name": "blog-09-agent-mcp-fw", "rules": [
  { "protocol": "tcp", "ports": "22", "sources": ["23.159.52.5/32"] },
  { "protocol": "tcp", "ports": "80", "sources": ["23.159.52.5/32"] } ] }
→ { "id": 17, "members": [] }

create_load_balancer { "name": "blog-09-agent-mcp-lb", "vpc": 41 }
→ { "id": 9, "status": "pending",
    "billing": { "mode": "hourly", "rate": "0.010", "currency": "CAD" } }

Ensuite, l'attente. get_action toutes les trois secondes : la première machine est prête 19 secondes après sa commande, la seconde 35 secondes. L'agent lit leurs adresses avec get_vm, attache le pare-feu ("status": "applied"), crée un pool HTTP avec contrôle de santé sur /, y met les deux machines sur le port 80 et ouvre le port 80 du répartiteur.

json
upsert_pool     { "lb": 9, "name": "web", "protocol": "http",
                  "health_type": "http", "health_path": "/" }        → { "id": 13 }
set_targets     { "lb": 9, "pool": 13, "targets": [ { "vm": 312, "port": 80 },
                                                   { "vm": 313, "port": 80 } ] }
upsert_listener { "lb": 9, "port": 80, "protocol": "http", "default_pool": 13 }

Tout est décrit 45 secondes après la première requête. Le répartiteur, lui, passe à active 2 minutes 47 secondes après sa commande : c'est l'étape la plus longue, et 25 des appels de la construction ne servent qu'à l'attendre.

4. Ce qui ne passe pas par MCP

Le serveur MCP pilote l'infrastructure, pas l'intérieur des machines. Pour installer un serveur web, l'agent passe par SSH, avec la clé déjà enregistrée sur le compte. Sur Debian 13, l'utilisateur est debian, pas root. Les deux machines en parallèle, en 7 secondes :

python
for ip in 203.0.113.82 203.0.113.83; do
  ssh debian@$ip 'sudo apt-get -qq update && sudo apt-get -qq install -y nginx \
    && hostname | sudo tee /var/www/html/index.html' &
done; wait

La carte du réseau privé, eth2, avait déjà son adresse (10.90.0.2 et 10.90.0.3) : rien à configurer à la main.

5. Vérifier, et une surprise

Six requêtes sur l'adresse du répartiteur alternent entre les deux machines, et get_load_balancer les voit en bonne santé :

python
for i in 1 2 3 4 5 6; do curl -s http://203.0.113.84/; done
blog-09-agent-mcp-web-2
blog-09-agent-mcp-web-1
blog-09-agent-mcp-web-2
blog-09-agent-mcp-web-1
…

get_load_balancer { "lb": 9 }
→ "targets": [ { "address": "10.90.0.2", "health": "up", "response_ms": 1 },
               { "address": "10.90.0.3", "health": "up", "response_ms": 1 } ]

Le pare-feu tient sur les machines elles-mêmes. Depuis 23.159.52.5, le port 80 répond ; depuis l'adresse IPv6 de la même machine, autre source, la requête expire.

bash
curl -4 http://203.0.113.82/              # 200
curl -6 "http://[2001:db8:100::4d]/"   # aucune réponse après 5 s
nc -6 -z -w 5 2001:db8:100::4d 22      # refusé aussi

Mais le répartiteur, lui, répondait à tout le monde, en IPv4 comme en IPv6. C'est normal : il joint les machines par le réseau privé, que le pare-feu ne filtre jamais. Restreindre l'entrée publique se règle donc sur le port d'entrée du répartiteur, avec sources. Sept secondes après cet appel, l'IPv6 n'obtenait plus de réponse.

json
upsert_listener { "lb": 9, "listener": 11, "sources": ["23.159.52.5/32"] }
→ { "id": 11, "port": 80, "sources": ["23.159.52.5/32"] }

Un agent qui comprend « seulement depuis cette IP » doit donc toucher deux objets, pas un. La documentation des pare-feux et des répartiteurs le dit ; la démo l'a confirmé.

6. Tout détruire, dans le bon ordre

Avant le démontage réel, trois appels dans le mauvais ordre ou avec une mauvaise confirmation, pour voir ce qui retient l'agent. Les trois sont refusés :

json
delete_vpc { "vpc": 41 }
→ 409 action_conflict  "A load balancer is attached to this network: delete it first."

delete_firewall { "firewall": 17 }
→ 409 action_conflict  "Detach this firewall from its machines first."  { "members": 2 }

destroy_vm { "vm": 312, "confirm_hostname": "blog-09-agent-mcp-web" }
→ 400 validation_failed "Confirm the deletion by repeating the machine hostname."
      { "expected": "blog-09-agent-mcp-web-1" }

Puis le démontage : delete_load_balancer, destroy_vm pour chaque machine avec son nom exact, get_action jusqu'à completed (18 et 25 secondes), puis le pare-feu, détaché d'office avec ses machines, et le réseau privé, vide. Pour finir, list_load_balancers, list_firewalls, list_vpcs et get_vm confirment qu'il ne reste rien : les deux machines sont à deleted, facturation terminated. 33 secondes en tout.

7. Les chiffres

Un appel prend 0,38 seconde en médiane ; le plus long, la création du réseau privé, 4,6 secondes. Le relevé GET /v1/usage compte une heure entamée par ressource : 0,018 CAD par Nano et 0,010 CAD pour le répartiteur, soit 0,046 CAD. Laissée en marche un mois, la même architecture coûterait environ 33,58 CAD en facturation à l'heure (deux Nano à 13,14 CAD, le répartiteur à 7,30 CAD).

8. Ce qui encadre l'agent

  • Portées de la clé. Celle de la démo n'a pas databases.*. Un outil de base gérée répond 403 insufficient_scope, avec la portée requise et la liste de celles que la clé possède.
  • Budget et crédit. estimate_vm vérifie quota, stock, crédit et budget avant toute commande. Le budget mensuel se règle dans la console ; au-delà de 120 %, les machines s'arrêtent.
  • Quotas. Trois réseaux privés et trois répartiteurs par compte par défaut : un agent qui s'emballe bute sur un refus clair.
  • Destruction. Le serveur demande à l'agent de consulter l'utilisateur avant d'effacer quoi que ce soit, et l'API exige le nom d'hôte exact. Ici, la demande initiale disait « quand j'aurai vérifié » : l'agent a attendu la vérification avant de démonter.
  • Ordre des suppressions. Un réseau privé utilisé ou un pare-feu attaché ne se suppriment pas : rien ne reste orphelin à moitié.

Pour brancher votre propre agent, la page Agents IA donne la phrase d'installation, Connecter un agent IA la commande de chaque client, et Outils MCP la liste des outils avec leurs portées.

Une puce de processeur d'où sort un flux de jetons, sans carte graphique

Ollama sans GPU : jetons par seconde du Nano au Scale

De qwen3:0.6b à qwen3:14b, huit modèles mesurés sur chacune de nos formules, même question et mêmes réglages. Ce qui tient en mémoire, la vitesse réelle, pourquoi 8 vCPU ne vont pas deux fois plus vite que 4, et quel modèle pour quelle formule.

Lire l'article 6 min de lecture

Trois agents IA de formes différentes lancent chacun une tâche sur sa propre machine, qui aboutit à une pull request

Codex Cloud, avec n'importe quel agent IA

Une machine neuve par tâche, un environnement prêt, des secrets rangés, une PR à relire : les briques de Codex Cloud, assemblées avec l'agent et le modèle de votre choix, par MCP ou par un script de cinquante lignes.

Lire l'article 9 min de lecture

Support & discussions

Questions techniques, retours d'incidents ou discussions d'infrastructure, l'équipe est présente sur Discord, Telegram, X, Instagram, Reddit et IRC.