Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Deployér en MCP-server til produktion

Lektion 12 af 14 Opdateret 2. november 2026 Udvikler
På denne side
  1. Fra prototype til produktionsserver
  2. Mulighed 1: Hugging Face Spaces
  3. Mulighed 2: Docker
  4. Mulighed 3 og 4: Administrerede implementeringer
  5. Sikring af implementeringen
  6. Se hvad der sker
  7. Vigtige pointer

Opdatering 2. november 2026 — Le Chat er nu Vibe. Fra den 28. maj 2026 er Le Chat blevet omdøbt til Vibe (stadig på chat.mistral.ai): en enkelt agent til arbejde og kode, der viderefører dine samtaler, indstillinger og abonnementer. Den ældre Le Chat-oplevelse forbliver tilgængelig i Chat-tilstand; i Work-tilstand er agenter nu færdigheder (kaldes med @), hukommelser udgør vidensbasen, og dyb research er færdigheden Deep Research. Abonnementer hedder nu Mistral Free, Pro, Team og Enterprise. Denne lektion bruger navnet Vibe; nogle menuer beskrevet her kan have ændret navn eller placering.

Opdatering 2. november 2026 — MCP Python SDK v2. Dette kursus følger nu version 2 af mcp-SDK’et (2.3.0 pr. 2. oktober 2026): MCPServer erstatter FastMCP, transportindstillinger flyttes til run() eller streamable_http_app(), og en app, der eksponeres under et rigtigt værtsnavn, skal deklarere dette værtsnavn (transport_security). Dette er også den version, der kræves af Mistral SDK: mistralai[agents]-ekstraniveauet kræver mcp>=2.2.0,<3.0. Kilder: Hvad er nyt i v2 · Migrationsguide · Deploy & skalér.

Fra prototype til produktionsserver

Din server kører lokalt, og ngrok eksponerer den for verden kun til en demo. Problemet opstår, når andre skal bruge den: du lukker din terminal, URL’en dør, og hver connector, dine kolleger har konfigureret, bryder sammen. At gå i produktion betyder i bund og grund at få en stabil adresse, tilgængelig 24/7, serveret over HTTPS. Fire muligheder bringer dig dertil, fra den hurtigste til den mest kontrollerede. Dit valg afhænger primært af, hvor følsomme dine data er, og hvor meget kontrol du vil have over infrastrukturen.

Mulighed 1: Hugging Face Spaces

Hugging Face Spaces leverer gratis virtuelle maskiner uden GPU’er, hvilket er mere end rigeligt til en MCP-server, der videresender API-kald. Dette er den hurtigste vej til en rigtig implementering: tre filer og et git push.

mon-mcp-space/
├── app.py              # FastAPI + MCP-server
├── requirements.txt    # Afhængigheder
└── README.md           # Space-metadata

Filen app.py følger nøjagtig den struktur, du har set hidtil, bortset fra at følsomme værdier læses fra miljøet – HF Secrets injicerer dem der:

# app.py
"""MCP-server deployeret på 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("Min Produktionsserver")

@mcp.tool()
def hello(name: str) -> str:
    """Hils på en person.

    Args:
        name: Personens fornavn

    Returns:
        Hilsenbesked
    """
    return f"Hej {name} fra Hugging Face Spaces!"

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

# Space-værtsnavn, i formatet <bruger>-<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))

# Brug HF Secrets til følsomme variabler
API_KEY = os.environ.get("MY_API_KEY", "")

Platformens særegenhed ligger i README-filen, hvis YAML-header styrer Space-byggeriet. Feltet app_port skal matche den port, din server faktisk lytter på; ellers lykkes implementeringen, men forbliver utilgængelig:

---
title: Min MCP-server
emoji: 🔧
colorFrom: blue
colorTo: green
sdk: docker
app_port: 7860
---
# Opret et Space på huggingface.co
# Push koden
git push
# Space'et deployeres automatisk

Dit endpoint bliver derefter https://your-username-mon-mcp-space.hf.space/mcp-endpoint/mcp, serveret over HTTPS. Ét konfigurationstrin mangler: erklær dette værtsnavn, dit-brugernavn-mon-mcp-space.hf.space, i variablen MCP_PUBLIC_HOST i Space-indstillingerne. Uden dette vil SDK’et afvise enhver anmodning med en fejlmeddelelse om 421 Invalid Host header.

Mulighed 2: Docker

Så snart serveren rører interne data, bliver hosting på din egen infrastruktur reglen, og Docker er standardformatet. Dockerfilen kræver kun få instruktioner, hvor installation af afhængigheder placeres før kopiering af koden for at udnytte lag-caching under genopbygninger:

FROM python:3.12-slim

WORKDIR /app

# Installer afhængigheder
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Kopier kode
COPY . .

# Eksponer port
EXPOSE 8000

# Start server
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   # kun hvis dine værktøjer bruger det: SDK v2 installerer det ikke længere

Ved opstart er indstillingen --restart unless-stopped det, der adskiller en produktionsimplementering fra en simpel test: uden den vil det første nedtag bringe din server offline, indtil nogen bemærker det.

# Byg imaget
docker build -t mon-mcp-server .

# Kør containeren
docker run -d \
  --name mcp-server \
  -p 8000:8000 \
  -e MY_API_KEY="hemmelighed" \
  -e DATABASE_URL="postgresql://..." \
  --restart unless-stopped \
  mon-mcp-server

Docker Compose gør denne konfiguration reproducerbar og tilføjer et health check, som orchestratoren bruger til at opdage en frossen server – en levende proces, der ikke længere svarer, er et scenarie, som simple automatiske genstarter ikke dækker:

# 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

Mulighed 3 og 4: Administrerede implementeringer

Prefect Horizon (tidligere FastMCP Cloud), platformen fra holdet bag det uafhængige FastMCP-framework, fjerner infrastrukturen: du logger ind på horizon.prefect.io med din GitHub-konto, vælger repository og serverfil, og platformen bygger og publicerer en URL med indbygget godkendelse. Den målretter servere skrevet med dette framework (pip install fastmcp, from fastmcp import FastMCP), hvilket er adskilt fra det officielle SDK, der bruges i dette kursus; der findes et gratis niveau til personlige projekter.

Cloudflare Workers målretter en anden brugsprofil: serverless, med eksekvering tættest på brugeren og dermed reduceret ventetid. En dedikeret skabelon sparkes projektet i gang med:

# Brug Cloudflares MCP-skabelon
npm create cloudflare@latest -- remote-mcp-server-authless --template=cloudflare/ai/demos/remote-mcp-authless

Begge muligheder sparer dig for at administrere certifikater og genstarter, til gengæld for platformafhængighed og eksekveringsbegrænsninger – en serverless Worker passer f.eks. ikke godt sammen med en stateful server.

Sikring af implementeringen

HTTPS er ikke-forhandlingsbart: Vibe nægter klartekst-endpoints, og et token, der rejser over HTTP, er et kompromitteret token. Tre veje fører dertil afhængigt af din hosting. En reverse proxy som Nginx eller Caddy placeret foran din server med et Let’s Encrypt-certifikat dækker tilfældet med en dedikeret server. Cloud-native platforme – Hugging Face, Cloudflare og de fleste PaaS-udbydere – leverer HTTPS automatisk. En tunnel, såsom Cloudflare Tunnel, eksponerer en server, der forbliver på dit interne netværk, uden at åbne porte.

Ingen hemmelighed bør optræde i koden. Bemærk forskellen mellem de to syntakser nedenfor: os.environ["MCP_API_TOKEN"] får opstarten til at fejle, hvis variablen mangler, hvilket er præcis den ønskede adfærd for en obligatorisk hemmelighed, mens os.environ.get() tolererer fravær for valgfrie værdier.

import os

# Konfiguration via miljøvariabler
API_TOKEN = os.environ["MCP_API_TOKEN"]       # Obligatorisk
DATABASE_URL = os.environ.get("DATABASE_URL")  # Valgfri
DEBUG = os.environ.get("DEBUG", "false") == "true"

En offentlig server uden rate limiting bliver før eller siden overbelastet, frivilligt eller ej. En IP-baseret begrænser er tilstrækkelig i de fleste tilfælde:

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 anmodninger pr. minut pr. IP
    ...

Se hvad der sker

I produktion har du ikke længere din terminal foran dig, og et værktøj, der fejler én gang ud af ti, kan kun diagnosticeres med spor. Som minimum skal du instrumentere input, output og varighed for hvert kald:

import logging
import time

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

@mcp.tool()
async def my_tool(param: str) -> str:
    """Mit værktøj med logging."""
    start = time.time()
    logger.info(f"Værktøj kaldt med param={param}")

    try:
        result = await process(param)
        duration = time.time() - start
        logger.info(f"Værktøj afsluttet på {duration:.2f}s")
        return result
    except Exception as e:
        logger.error(f"Fejl i værktøj: {e}")
        raise

At måle varighed er ikke en luksus: et værktøj, der tager tolv sekunder om at svare, udløser klient-side timeouts og giver indtryk af en defekt server, når den faktisk fungerer. Før du annoncerer din server, skal du gennemgå følgende seks konfigurationspunkter.

  • HTTPS aktivt og gyldigt certifikat
  • Miljøvariabler for alle hemmeligheder
  • Struktureret logging aktiveret
  • Health check-endpoint (/ eller /health)
  • Automatisk genstart ved nedbrud
  • Rate limiting konfigureret

To tjek mangler, dem folk oftest springer over, men som afslører de virkelige problemer: en test med MCP Inspector lanceret udefra, derefter en test fra Mistral Vibe. En server, der svarer perfekt fra din maskine, kan blive blokeret af en firewall eller CORS-konfiguration, så snart den kaldes fra et andet sted.

Vigtige pointer

  • Hugging Face Spaces: hurtigst, gratis, ideel til at komme i gang
  • Docker: fuld kontrol, velegnet til dedikerede servere og cloud
  • Prefect Horizon (ex-FastMCP Cloud): implementering fra GitHub, til servere skrevet med FastMCP-frameworket
  • Cloudflare Workers: serverless, lav ventetid, skalerbar
  • Sikr med HTTPS, miljøvariabler og rate limiting
  • Tilføj overvågning og logs til fejlfinding i produktion