Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Déployer un serveur MCP en production

Ceacht 12 as 14 Nuashonraithe 2 Samhain 2026 Forbróir
Ar an leathanach seo
  1. Du prototype au serveur de production
  2. Option 1 : Hugging Face Spaces
  3. Option 2 : Docker
  4. Options 3 et 4 : Déploiements managés
  5. Sécuriser le déploiement
  6. Voir ce qui se passe
  7. Príomhphointí

Mise à jour du 2 novembre 2026 — Le Chat devient Vibe. Depuis le 28 mai 2026, Le Chat a été rebaptisé Vibe (toujours sur chat.mistral.ai) : un agent unique pour le travail et le code, qui conserve tes conversations, tes paramètres et tes abonnements. L’expérience historique de Le Chat reste accessible en mode Chat ; en mode Work, les agents sont désormais des compétences (appelées avec @), les mémoires constituent la base de connaissances, et la recherche approfondie est la compétence Deep Research. Les formules s’appellent désormais Mistral Free, Pro, Team et Enterprise. Cette leçon utilise le nom Vibe ; certains menus décrits ici peuvent avoir changé de nom ou d’emplacement.

Mise à jour du 2 novembre 2026 — MCP Python SDK v2. Ce cours suit désormais la version 2 du SDK mcp (2.3.0 au 2 octobre 2026) : MCPServer remplace FastMCP, les paramètres de transport migrent vers run() ou streamable_http_app(), et une application exposée sous un vrai nom d’hôte doit déclarer ce nom d’hôte (transport_security). C’est aussi la version requise par le SDK Mistral : l’extra mistralai[agents] exige mcp>=2.2.0,<3.0. Sources : Quoi de neuf dans la v2 · Guide de migration · Déploiement et mise à l’échelle.

Du prototype au serveur de production

Ton serveur tourne en local et ngrok l’expose au monde entier juste pour une démo. Le problème commence quand quelqu’un d’autre doit l’utiliser : tu fermes ton terminal, l’URL meurt, et tous les connecteurs configurés par tes collègues se brisent. Passer en production signifie essentiellement obtenir une adresse stable, disponible 24h/24 et 7j/7, servie via HTTPS. Quatre options t’y mènent, de la plus rapide à la plus maîtrisée. Ton choix dépend principalement de la sensibilité de tes données et du niveau de contrôle que tu souhaites sur l’infrastructure.

Option 1 : Hugging Face Spaces

Hugging Face Spaces fournit des machines virtuelles gratuites sans GPU, largement suffisantes pour un serveur MCP qui relaie des appels API. C’est le chemin le plus rapide vers un déploiement réel : trois fichiers et un git push.

mon-mcp-space/
├── app.py              # FastAPI + serveur MCP
├── requirements.txt    # Dépendances
└── README.md           # Métadonnées du Space

Le fichier app.py suit exactement la structure que tu as vue jusqu’ici, sauf que les valeurs sensibles sont lues depuis l’environnement — les Secrets HF les y injectent :

# app.py
"""Serveur MCP déployé sur Hugging Face Spaces."""

import os
from contextlib import asynccontextmanager

from fastapi import FastAPI
from mcp.server.mcpserver import MCPServer
from mcp.server.transport_security import TransportSecuritySettings

mcp = MCPServer("Mon Serveur de Production")

@mcp.tool()
def hello(name: str) -> str:
    """Saluer une personne.

    Args:
        name: Le prénom de la personne

    Returns:
        Message de salutation
    """
    return f"Bonjour {name} depuis Hugging Face Spaces !"

@asynccontextmanager
async def lifespan(app: FastAPI):
    async with mcp.session_manager.run():
        yield

# Nom d'hôte du Space, sous la forme <user>-<space>.hf.space
SPACE_HOST = os.environ.get("MCP_PUBLIC_HOST", "localhost")
security = TransportSecuritySettings(allowed_hosts=[SPACE_HOST, f"{SPACE_HOST}:*"])

api = FastAPI(lifespan=lifespan)
api.mount("/mcp-endpoint", mcp.streamable_http_app(transport_security=security))

# Pour les variables sensibles, utilise les Secrets HF
API_KEY = os.environ.get("MY_API_KEY", "")

La particularité de la plateforme réside dans le README, dont l’en-tête YAML pilote la construction du Space. Le champ app_port doit correspondre au port sur lequel ton serveur écoute réellement ; sinon, le déploiement réussit mais reste inaccessible :

---
title: Mon Serveur MCP
emoji: 🔧
colorFrom: blue
colorTo: green
sdk: docker
app_port: 7860
---
# Créer un Space sur huggingface.co
# Pousser le code
git push
# Le Space se déploie automatiquement

Ton point de terminaison devient alors https://your-username-mon-mcp-space.hf.space/mcp-endpoint/mcp, servi en HTTPS. Une étape de configuration reste à faire : déclarer ce nom d’hôte, ton-nom-utilisateur-mon-mcp-space.hf.space, dans la variable MCP_PUBLIC_HOST des paramètres du Space. Sans cela, le SDK rejette chaque requête avec une erreur 421 Invalid Host header.

Option 2 : Docker

Dès que le serveur touche à des données internes, l’hébergement sur ta propre infrastructure devient la règle, et Docker est le format standard. Le Dockerfile ne prend que quelques instructions, l’installation des dépendances étant placée avant la copie du code pour tirer parti de la mise en cache des couches lors des reconstructions :

FROM python:3.12-slim

WORKDIR /app

# Installer les dépendances
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copier le code
COPY . .

# Exposer le port
EXPOSE 8000

# Démarrer le serveur
CMD ["uvicorn", "server:api", "--host", "0.0.0.0", "--port", "8000"]
fastapi>=0.115.0
uvicorn>=0.30.0
mcp>=2.2,<3
httpx>=0.27.0   # uniquement si tes outils l'utilisent : le SDK v2 ne l'installe plus

Au lancement, l’option --restart unless-stopped est ce qui distingue un déploiement de production d’un simple test : sans elle, le premier plantage met ton serveur hors ligne jusqu’à ce que quelqu’un s’en aperçoive.

# Construire l'image
docker build -t mon-mcp-server .

# Lancer le conteneur
docker run -d \
  --name mcp-server \
  -p 8000:8000 \
 -e MY_API_KEY="secret" \
  -e DATABASE_URL="postgresql://..." \
  --restart unless-stopped \
  mon-mcp-server

Docker Compose rend cette configuration reproductible et ajoute une vérification d’état de santé (health check), que l’orchestrateur utilise pour détecter un serveur gelé — un processus vivant qui ne répond plus est un scénario que les redémarrages automatiques simples ne couvrent pas :

# docker-compose.yml
version: "3.8"
services:
  mcp-server:
    build: .
    ports:
      - "8000:8000"
    environment:
      - MY_API_KEY=${MY_API_KEY}
      - DATABASE_URL=${DATABASE_URL}
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/"]
      interval: 30s
      retries: 3

Options 3 et 4 : Déploiements managés

Prefect Horizon (anciennement FastMCP Cloud), la plateforme de l’équipe derrière le framework indépendant FastMCP, supprime l’étape d’infrastructure : tu te connectes sur horizon.prefect.io avec ton compte GitHub, choisis le dépôt et le fichier serveur, et la plateforme construit et publie une URL avec une authentification intégrée. Elle cible les serveurs écrits avec ce framework (pip install fastmcp, from fastmcp import FastMCP), qui est distinct du SDK officiel utilisé dans ce cours ; une offre gratuite existe pour les projets personnels.

Cloudflare Workers vise un profil d’usage différent : serverless, avec une exécution au plus près de l’utilisateur et donc une latence réduite. Un modèle dédié lance le projet :

# Utiliser le modèle MCP de Cloudflare
npm create cloudflare@latest -- remote-mcp-server-authless --template=cloudflare/ai/demos/remote-mcp-authless

Ces deux options t’épargnent la gestion des certificats et des redémarrages, au prix d’une dépendance à la plateforme et de contraintes d’exécution — un Worker serverless, par exemple, ne s’accorde pas bien avec un serveur avec état.

Sécuriser le déploiement

HTTPS est non négociable : Vibe refuse les points de terminaison en clair, et un jeton voyageant en HTTP est un jeton compromis. Trois voies y mènent selon ton hébergement. Un proxy inverse comme Nginx ou Caddy placé devant ton serveur, avec un certificat Let’s Encrypt, couvre le cas du serveur dédié. Les plateformes cloud-natives — Hugging Face, Cloudflare et la plupart des fournisseurs PaaS — fournissent HTTPS automatiquement. Un tunnel, tel que Cloudflare Tunnel, expose un serveur restant sur ton réseau interne sans ouvrir de ports.

Aucun secret ne doit apparaître dans le code. Note la distinction entre les deux syntaxes ci-dessous : os.environ["MCP_API_TOKEN"] fait échouer le démarrage si la variable manque, ce qui est exactement le comportement souhaité pour un secret obligatoire, tandis que os.environ.get() tolère l’absence pour les valeurs optionnelles.

import os

# Configuration via variables d'environnement
API_TOKEN = os.environ["MCP_API_TOKEN"]       # Obligatoire
DATABASE_URL = os.environ.get("DATABASE_URL")  # Optionnel
DEBUG = os.environ.get("DEBUG", "false") == "true"

Un serveur public sans limitation de débit finit par être saturé, volontairement ou non. Un limiteur basé sur l’IP suffit dans la plupart des cas :

from fastapi import FastAPI, Request
from slowapi import Limiter, _rate_limit_exceeded_handler

limiter = Limiter(key_func=lambda request: request.client.host)
api = FastAPI()
api.state.limiter = limiter

@api.middleware("http")
async def rate_limit(request: Request, call_next):
    # 100 requêtes par minute par IP
    ...

Voir ce qui se passe

En production, tu n’as plus ton terminal devant toi, et un outil qui échoue une fois sur dix ne peut être diagnostiqué qu’avec des traces. Au minimum, instrumente l’entrée, la sortie et la durée de chaque appel :

import logging
import time

logger = logging.getLogger("mcp-server")

@mcp.tool()
async def my_tool(param: str) -> str:
    """Mon outil avec journalisation."""
    start = time.time()
    logger.info(f"Outil appelé avec param={param}")

    try:
        result = await process(param)
        duration = time.time() - start
        logger.info(f"Outil terminé en {duration:.2f}s")
        return result
    except Exception as e:
        logger.error(f"Erreur dans l'outil : {e}")
        raise

Mesurer la durée n’est pas un luxe : un outil qui met douze secondes à répondre déclenche des délais d’attente côté client et donne l’impression d’un serveur cassé alors qu’il fonctionne réellement. Avant d’annoncer ton serveur, passe en revue les six points de configuration suivants.

  • HTTPS actif et certificat valide
  • Variables d’environnement pour tous les secrets
  • Journalisation structurée activée
  • Point de terminaison de vérification d’état (/ ou /health)
  • Redémarrage automatique en cas de plantage
  • Limitation de débit configurée

Deux vérifications restent, celles que les gens oublient le plus souvent mais qui révèlent les vrais problèmes : un test avec MCP Inspector lancé depuis l’extérieur, puis un test depuis Mistral Vibe. Un serveur qui répond parfaitement depuis ta machine peut être bloqué par un pare-feu ou une configuration CORS dès qu’il est appelé depuis ailleurs.

Príomhphointí

  • Hugging Face Spaces : le plus rapide, gratuit, idéal pour débuter
  • Docker : contrôle total, adapté aux serveurs dédiés et au cloud
  • Prefect Horizon (ex-FastMCP Cloud) : déploiement depuis GitHub, pour les serveurs écrits avec le framework FastMCP
  • Cloudflare Workers : serverless, faible latence, évolutif
  • Sécurise avec HTTPS, les variables d’environnement et la limitation de débit
  • Ajoute de la surveillance et des journaux pour le débogage en production