Izvietot MCP serveri ražošanas vidē
Šajā lapā
Atjauninājums 2026. gada 2. novembrī — Le Chat tagad ir Vibe. Kopš 2026. gada 28. maija Le Chat ir pārdēvēts par Vibe (joprojām adresē chat.mistral.ai): vienots aģents darbam un kodam, saglabājot jūsu sarunas, iestatījumus un abonementus. Vecais Le Chat interfeiss joprojām ir pieejams režīmā Chat; režīmā Work aģenti tagad ir prasmes (izsaucamas ar
@), atmiņas veido zināšanu bāzi, bet padziļināta izpēte ir prasme Deep Research. Plāni tagad saucas Mistral Free, Pro, Team un Enterprise. Šajā nodarbībā lietots nosaukums Vibe; dažas šeit aprakstītās izvēlnes var būt mainījušas nosaukumus vai atrašanās vietu.
Atjauninājums 2026. gada 2. novembrī — MCP Python SDK v2. Šis kurss tagad seko
mcpSDK 2. versijai (2.3.0 pēc 2026. gada 2. oktobra datiem):MCPServeraizstājFastMCP, transporta iestatījumi pārcelti uzrun()vaistreamable_http_app(), un lietotnei, kas eksponēta zem reāla resursdatora nosaukuma, tas ir jādeklarē (transport_security). Tā ir arī versija, ko pieprasa Mistral SDK: papildinājumsmistralai[agents]prasamcp>=2.2.0,<3.0. Avoti: Kas jauns v2 · Migrācijas ceļvedis · Izvietošana un mērogošana.
No prototipa līdz ražošanas serverim
Tavs serveris darbojas lokāli, un ngrok to dara pieejamu pasaulei tikai demonstrācijas nolūkos. Problēma sākas, kad tam jālieto kādam citam: tu aizver termināli, URL pazūd, un visi savienojumi, ko tavi kolēģi konfigurējuši, pārstāj darboties. Pāreja uz ražošanas vidi būtībā nozīmē stabila adrešu iegūšanu, pieejamību 24/7 un apkalpošanu pār HTTPS. Četras iespējas tevi tur aizvedīs, sākot no ātrākās līdz visvairāk kontrolētajai. Tava izvēle galvenokārt ir atkarīga no datu sensitivitātes un no tā, cik lielu kontroli vēlies pār infrastruktūru.
1. variants: Hugging Face Spaces
Hugging Face Spaces nodrošina bezmaksas virtuālās mašīnas bez GPU, kas ir vairāk nekā pietiekami MCP serverim, kas tikai nodod API izsaukumus. Tas ir ātrākais ceļš uz reālu izvietošanu: trīs faili un git push.
mon-mcp-space/
├── app.py # FastAPI + MCP serveris
├── requirements.txt # Atkarības
└── README.md # Spaces metadati
Fails app.py seko tieši tai struktūrai, ko esi redzējis līdz šim, izņemot to, ka sensitīvās vērtības tiek lasītas no vides — HF Secrets tās tur injicē:
# app.py
"""MCP serveris, kas izvietots 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("My Production Server")
@mcp.tool()
def hello(name: str) -> str:
"""Sveiciena funkcija personai.
Args:
name: Personas vārds
Returns:
Sveiciena ziņojums
"""
return f"Hello {name} from Hugging Face Spaces!"
@asynccontextmanager
async def lifespan(app: FastAPI):
async with mcp.session_manager.run():
yield
# Spaces resursdatora nosaukums formātā <lietotājs>-<telpa>.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))
# Sensitīviem mainīgajiem izmanto HF Secrets
API_KEY = os.environ.get("MY_API_KEY", "")
Platformas īpatnība slēpjas failā README, kura YAML galvene virza Spaces būvi. Laukam app_port ir jāsakrīt ar portu, ko tavs serveris faktiski klausās; pretējā gadījumā izvietošana būs veiksmīga, bet paliks nepieejama:
---
title: My MCP Server
emoji: 🔧
colorFrom: blue
colorTo: green
sdk: docker
app_port: 7860
---
# Izveido Space vietnē huggingface.co
# Augšupielādē kodu
git push
# Space tiek automātiski izvietots
Tavs galapunkts tad kļūst par https://your-username-mon-mcp-space.hf.space/mcp-endpoint/mcp, kas tiek apkalpots pār HTTPS. Atlicis veikt vienu konfigurācijas soli: deklarē šo resursdatora nosaukumu, your-username-mon-mcp-space.hf.space, mainīgajā MCP_PUBLIC_HOST Space iestatījumos. Bez tā SDK noraidīs katru pieprasījumu ar kļūdu 421 Invalid Host header.
2. variants: Docker
Tiklīdz serveris saskaras ar iekšējiem datiem, izmitināšana savā infrastruktūrā kļūst par noteikumu, un Docker ir standarta formāts. Dockerfile prasa tikai dažas instrukcijas, turklāt atkarību instalēšana tiek veikta pirms koda kopēšanas, lai izmantotu slāņu kešatmiņu atkārtotās būvēs:
FROM python:3.12-slim
WORKDIR /app
# Instalē atkarības
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
# Kopē kodu
COPY . .
# Atver portu
EXPOSE 8000
# Startē serveri
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 # tikai ja tavi rīki to izmanto: SDK v2 to vairs neinstalē
Palaižot, opcija --restart unless-stopped ir tas, kas atšķir ražošanas izvietošanu no vienkārša testa: bez tās pirmā avārija izslēgs serveri, līdz kāds to pamanīs.
# Būvē attēlu
docker build -t mon-mcp-server .
# Palaiž konteineru
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 padara šo konfigurāciju atkārtojamu un pievieno veselības pārbaudi, ko orķestrators izmanto, lai noteiktu iesalušu serveri — dzīvs process, kas vairs neatbild, ir scenārijs, ko vienkārša automātiska restartēšana nenosedz:
# 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
3. un 4. variants: Pārvaldīti izvietojumi
Prefect Horizon (agrāk FastMCP Cloud), platforma no komandas, kas stāv aiz neatkarīgā FastMCP ietvara, noņem infrastruktūras soli: tu piesakies vietnē horizon.prefect.io ar savu GitHub kontu, izvēlies repozitoriju un servera failu, un platforma būvē un publicē URL ar iebūvētu autentifikāciju. Tā ir paredzēta serveriem, kas rakstīti ar šo ietvaru (pip install fastmcp, from fastmcp import FastMCP), kas atšķiras no oficiālā SDK, ko izmantojam šajā kursā; personīgiem projektiem ir pieejams bezmaksas tarifs.
Cloudflare Workers ir vērsts uz citu lietojuma profilu: bezservera ar izpildi pēc iespējas tuvāk lietotājam, tādējādi samazinot latentumu. Īpaša veidne palīdz uzsākt projektu:
# Izmanto Cloudflare MCP veidni
npm create cloudflare@latest -- remote-mcp-server-authless --template=cloudflare/ai/demos/remote-mcp-authless
Abas opcijas atbrīvo tevi no sertifikātu un restartu pārvaldības, taču par cenu atkarības no platformas un izpildes ierobežojumiem — bezservera Worker, piemēram, nesader labi ar stāvokli uzturošu serveri.
Izvietošanas drošība
HTTPS ir obligāts: Vibe noraida teksta galapunktus, un tokens, kas ceļo pār HTTP, ir apdraudēts tokens. Ir trīs ceļi turp atkarībā no tava izmitinātāja. Apgrieztais starpniekserveris (reverse proxy), piemēram, Nginx vai Caddy, novietots servera priekšā ar Let’s Encrypt sertifikātu, sedz dedicated servera gadījumu. Mākoņplatformas — Hugging Face, Cloudflare un lielākā daļa PaaS sniedzēju — nodrošina HTTPS automātiski. Tunelis, piemēram, Cloudflare Tunnel, eksponē serveri, kas paliek tavā iekšējā tīklā, neatverot portus.
Neviens noslēpums nedrīkst parādīties kodā. Ņem vērā atšķirību starp abām tālāk redzamajām sintaksēm: os.environ["MCP_API_TOKEN"] izraisa startēšanas kļūmi, ja mainīgais trūkst, kas ir tieši vēlamā uzvedība obligātam noslēpumam, savukārt os.environ.get() pieļauj trūkumu neobligātām vērtībām.
import os
# Konfigurācija, izmantojot vides mainīgos
API_TOKEN = os.environ["MCP_API_TOKEN"] # Obligāts
DATABASE_URL = os.environ.get("DATABASE_URL") # Neobligāts
DEBUG = os.environ.get("DEBUG", "false") == "true"
Publisks serveris bez ātruma ierobežošanas galu galā tiks pārslogots, vai nu apzināti, vai nē. Vairumā gadījumu pietiek ar IP balstītu ierobežotāju:
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 pieprasījumi minūtē uz vienu IP
...
Notiekošā novērošana
Ražošanas vidē tev vairs nav termināļa acu priekšā, un rīku, kas neizdodas vienā no desmit reizēm, var diagnosticēt tikai ar izsekošanas ierakstiem. Minimums ir instrumentēt katras izsaukuma ievadi, izvadi un ilgumu:
import logging
import time
logger = logging.getLogger("mcp-server")
@mcp.tool()
async def my_tool(param: str) -> str:
"""Mans rīks ar žurnālēšanu."""
start = time.time()
logger.info(f"Tool called with param={param}")
try:
result = await process(param)
duration = time.time() - start
logger.info(f"Tool finished in {duration:.2f}s")
return result
except Exception as e:
logger.error(f"Error in tool: {e}")
raise
Ilguma mērīšana nav greznība: rīks, kas atbild divpadsmit sekundes, izraisa klienta puses noilgumus un rada iespaidu par bojātu serveri, lai gan tas patiesībā strādā. Pirms servera paziņošanas pārskati šos sešus konfigurācijas punktus.
- HTTPS aktīvs un derīgs sertifikāts
- Vides mainīgie visiem noslēpumiem
- Strukturēta žurnālēšana iespējota
- Veselības pārbaudes galapunkts (
/vai/health) - Automātiska restartēšana pēc avārijas
- Ātruma ierobežošana konfigurēta
Atlikuši divi pārbaudes soļi, ko cilvēki visbiežāk izlaiž, bet kas atklāj patiesās problēmas: tests ar MCP Inspector, kas palaists no ārpuses, un tests no Mistral Vibe. Serveris, kas perfekti atbild no tavas mašīnas, var tikt bloķēts ar ugunsmūri vai CORS konfigurāciju, tiklīdz to izsauc no citas vietas.
Galvenās atziņas
- Hugging Face Spaces: ātrākais, bezmaksas, ideāls sākumam
- Docker: pilnīga kontrole, piemērots dedicated serveriem un mākonim
- Prefect Horizon (bijušais FastMCP Cloud): izvietošana no GitHub, serveriem, kas rakstīti ar FastMCP ietvaru
- Cloudflare Workers: bezservera, zems latentums, mērogojams
- Drošība ar HTTPS, vides mainīgajiem un ātruma ierobežošanu
- Pievieno monitoringu un žurnālus ražošanas atkļūdošanai