Comment créer et déployer un serveur MCP distant sur Google Cloud Run en 10 minutes chrono !
Jack Wotherspoon
Developer Advocate
Plus un modèle IA a connaissance des contextes, plus ses réponses sont pertinentes et moins il a tendance à halluciner. Mais cette intégration du contexte – issu des outils métier et des sources de données – dans les LLMs s’avère souvent laborieuse et freine la création et la démocratisation des agents IA. Pour relever ce défi, Anthropic a introduit le Model Context Protocol (MCP), qui standardise la manière dont les applications fournissent du contexte aux LLM.
Imaginez que vous souhaitiez créer un serveur MCP pour votre API afin de le rendre vos données accessibles à d’autres développeurs, pour qu’ils puissent l’utiliser comme contexte dans leurs propres applications d’IA. Se posera alors forcément la question « où le déployer ? ». Notre réponse à cette question sonne comme une évidence : « sur Google Cloud Run bien sûr ! »
Le guide ci-dessous, directement inspiré de la documentation officielle de Cloud Run, vous montre étape par étape comment créer et héberger facilement votre propre serveur MCP à distance. De quoi révolutionner la manière dont vous injectez du contexte dans vos applications IA !
Transports MCP
Le protocole MCP repose sur une architecture client-serveur. À l’origine limité à une exécution locale via stdio, le protocole MCP a, depuis, considérablement évolué et prend désormais en charge des transports d’accès distant : streamable-http et sse. Certes, les « Server-Sent Events » (SSE) sont aujourd’hui obsolètes et remplacés par Streamable HTTP dans la dernière spécification MCP, mais ils restent pris en charge pour assurer la compatibilité avec les versions précédentes.
Avec Streamable HTTP, le serveur MCP fonctionne comme un processus indépendant capable de gérer plusieurs connexions client. Ce transport utilise les requêtes HTTP POST et GET.
Le serveur DOIT exposer un unique chemin d’endpoint HTTP (appelé endpoint MCP) supportant les méthodes POST et GET. Par exemple, au travers d’une URL telle que : https://example.com/mcp.
Pour explorer les différents types de transport, consultez la documentation officielle de MCP.
Pourquoi passer au serveur MCP distant ?
Exécuter un serveur MCP à distance sur Google Cloud Run offre plusieurs avantages :
Scalabilité : Cloud Run est conçu pour s’adapter rapidement au volume des requêtes entrantes. Le service absorbe sans sourciller les montées en charge, dimensionnant votre serveur MCP à la volée, que ce soit pour quelques requêtes ou de massifs pics soudains de trafic.
Serveur centralisé : Vous pouvez partager l’accès à un serveur MCP centralisé avec d’autres membres de votre équipe via les privilèges IAM. Chacun peut s’y connecter depuis sa propre machine, en toute sécurité, sans avoir à gérer son propre serveur. Toute modification apportée au serveur MCP profite instantanément à tous les utilisateurs.
Sécurité renforcée : Cloud Run facilite la mise en place d’un accès authentifié, garantissant que seules les connexions autorisées peuvent accéder à votre serveur MCP et évitant ainsi tout accès non autorisé.
IMPORTANT : sans authentification, votre serveur MCP devient accessible à n’importe qui sur le web. Une faille critique à éviter absolument.
Prérequis
* Python 3.10 ou supérieur
* Uv, l’outil nouvelle génération pour gérer vos dépendances Python et piloter votre projet. Consultez la doc officielle pour une installation rapide.
* Google Cloud SDK (gcloud)
Installation
Adaptation dynamique et incisive :
Commencez par créer un dossier de travail « mcp-on-cloudrun ». C’est dans ce répertoire que vous centraliserez l’ensemble du code source de votre serveur MCP ainsi que les fichiers nécessaires au déploiement sur Cloud Run.
Passons à l’action ! Utilisez uv pour initialiser votre projet. Ce puissant gestionnaire de projets va simplifier à la fois la création et la gestion des dépendances de votre serveur MCP.
Après avoir exécuté la commande ci-dessus, vous devriez voir apparaître le fichier pyproject.toml suivant :
Poursuivons la mise en place ! Ajoutez maintenant les fichiers essentiels à la racine de votre projet :
- server.py : le cœur du code de votre serveur MCP.
- test_server.py : pour valider facilement le fonctionnement du serveur à distance.
- Dockerfile : indispensable pour packager et déployer votre application sur Cloud Run.
La structure de nos fichiers devrait maintenant être complète et ressembler à ça :
Maintenant que notre structure de fichiers est en place, configurons nos identifiants Google Cloud et sélectionnons notre projet :
Math MCP Server
Les LLM excellent dans les tâches non déterministes : comprendre l’intention, générer du texte créatif, résumer des idées complexes ou raisonner sur des concepts abstraits. En revanche, ils sont notoirement peu fiables pour les tâches déterministes : celles qui n’admettent qu’une seule réponse correcte.
Doter les LLM de fonctions déterministes (comme des opérations de calcul mathématique) est un bon exemple de la façon dont des outils externes peuvent apporter un contexte précieux via MCP pour améliorer leur utilisation et/ou leurs capacités.
Nous allons utiliser FastMCP pour créer un simple serveur MCP dédié aux opérations mathématiques, doté de deux « outils » : addition et soustraction. FastMCP propose une méthode rapide et pythonique pour construire des serveurs et clients MCP.
Ajoutez FastMCP comme dépendance dans votre fichier pyproject.toml :
Copiez et collez le code suivant dans le fichier server.py afin de mettre en place notre serveur MCP dédié aux opérations mathématiques :
Transport
Dans cet exemple, nous utilisons le transport streamable-http, recommandé pour les serveurs distants. Cependant, il est également possible d’utiliser sse (Server-Sent Events), qui reste pris en charge pour des raisons de compatibilité.
Si vous souhaitez utiliser sse, il suffit de modifier la dernière ligne du fichier server.py en définissant transport="sse".
Déploiement sur Cloud Run
Il est temps de passer au déploiement sur Cloud Run. Copiez et collez le code ci-dessous dans le fichier Dockerfile (actuellement vide) : ce fichier utilise uv pour exécuter notre server.py.
Deux options s’offrent à vous : déployer directement votre code source ou passer par une image conteneurisée.
Quel que soit votre choix, il est crucial d’ajouter le flag --no-allow-unauthenticated lors du déploiement : c’est votre rempart contre tout accès non autorisé. Sans cette précaution, votre serveur MCP serait exposé à la première sollicitation venue… avec tous les risques que cela implique.
Option 1 – Déployer le code source
Option 2 – Déployer une image conteneurisée
Commencez par créer un dépôt Artifact Registry pour stocker l’image du conteneur.
Enchaînons avec la création de votre image Docker et son transfert sécurisé dans Artifact Registry grâce à Cloud Build.
Cet outil Google Cloud automatise chaque étape : compilation de l’image, gestion des dépendances et push dans votre repository Artifact Registry, le tout dans un environnement conteneurisé, fiable et reproductible.
Il ne reste plus qu’à déployer votre image conteneurisée du serveur MCP sur Cloud Run.
Une fois l’une ou l’autre des options terminée, si votre service a été déployé avec succès, vous verrez s’afficher un message similaire à celui-ci :
Authentification des clients MCP
On ne badine pas avec la sécurité, même sur des tests. Puisque nous avons spécifié un peu plus haut l’option « --no-allow-unauthenticated » pour exiger une authentification, tout client MCP se connectant à notre serveur MCP distant devra s’authentifier.
La documentation officielle « Héberger des serveurs MCP sur Cloud Run » fournit des informations détaillées sur ce sujet, selon l’environnement dans lequel vous exécutez votre client MCP.
Dans cet exemple, nous utiliserons le proxy Cloud Run pour établir un tunnel authentifié vers notre serveur MCP distant, directement depuis notre machine locale.
Par défaut, l’URL des services Cloud Run exige que toutes les requêtes soient autorisées avec le rôle IAM « Cloud Run Invoker » (roles/run.invoker). Ce binding de politique IAM garantit l’utilisation d’un mécanisme d’authentification robuste pour votre client MCP local.
Assurez-vous que vous, ainsi que tous les membres de l’équipe qui souhaitent accéder au serveur MCP distant, disposez bien du rôle IAM « roles/run.invoker » associé à votre compte Google Cloud principal (ou à leurs comptes Google Cloud).
Remarque : La commande suivante peut vous inviter à télécharger le proxy Cloud Run s’il n’est pas déjà installé. Suivez les instructions pour l’installer si besoin.
Si tout se passe bien, vous devriez voir apparaître le message suivant :
Tout le trafic envoyé vers http://127.0.0.1:8080 sera désormais authentifié et redirigé vers notre serveur MCP distant.
Tester le serveur MCP distant
Dernière ligne droite : la validation ! Connectez-vous à votre serveur MCP fraîchement déployé avec le client FastMCP, via l’URL locale sécurisée http://127.0.0.1:8080/mcp (attention, le suffixe /mcp est indispensable avec le transport Streamable HTTP).
Il ne vous reste plus qu’à ajouter ce script dans test_server.py pour tester en conditions réelles les fonctions d’addition et de soustraction de votre serveur MCP distant.
Remarque : Assurez-vous que le proxy Cloud Run est bien lancé avant d’exécuter le serveur de test.
Dans une nouvelle fenêtre Terminal, exécuter la commande :
Vous devriez voir s’afficher :
Félicitations ! Vous avez déployé avec succès un serveur MCP distant sur Cloud Run et l’avez testé à l’aide du client FastMCP.
Envie d’aller plus loin dans le déploiement d’applications IA sur Cloud Run ? Le blog « Easily Deploying AI Apps to Cloud Run » extrait du dernier Google I/O vous propose de maîtriser toutes les astuces et dernières avancées du déploiement d’IA sur Cloud Run. À explorer sans hésiter pour monter en puissance !
