Deploy en LLM med Modal: Fra pip install til produktions-endpoint

Deploy en LLM med Modal: Fra pip install til produktions-endpoint

De fleste guides om selvhosting af LLM'er overser den sværeste del: infrastrukturen. Du kæmper med CUDA-drivere, administrerer Docker-images, konfigurerer autoscaling og ender alligevel med at betale for inaktive GPU'er kl. 3 om natten. Modal eliminerer alt det. Du skriver Python, du deployer, og du får en URL.

Denne guide viser dig, hvordan du deployer en open-source LLM på Modal med vLLM som inferensmotor. I slutningen vil du have et live, OpenAI-kompatibelt API-endpoint kørende på H100 GPU'er, der skalerer ned til nul, når ingen bruger det.

Hvad er Modal (og hvorfor bruge det til LLM'er)?

Modal er en serverløs compute-platform bygget specifikt til AI-workloads. Tænk på AWS Lambda, men med GPU-support, fakturering per sekund og en Python-native udvikleroplevelse. Der er ingen YAML, ingen Dockerfiles, ingen Kubernetes; du definerer hele din infrastruktur i et Python-script og deployer med en enkelt kommando.

Her er hvorfor det er blevet go-to-løsningen til LLM-deployment:

• Scale-to-zero fakturering, du betaler ingenting, når dit endpoint ikke håndterer forespørgsler
• Pris pr. sekund for GPU'er, H100'er til ~$3,95/time, A100 80GB til ~$2,50/time, faktureret per sekund
• Kolde starts under et sekund, containere starter hurtigt op, især med hukommelsessnapshots
• $30/måned i gratis credits, nok til at eksperimentere uden kreditkortomkostninger
• Ingen DevOps, ingen Docker-builds, ingen Terraform, ingen cluster-administration

Hvis du har været kører LLM'er lokalt og vil give dem et ordentligt API uden at administrere servere, er Modal den korteste vej dertil.

Modal vs. RunPod vs. Lambda

Bundlinjen: Modal vinder ved bursty workloads og udvikling. Hvis din GPU-udnyttelse konsekvent overstiger 40%, er en dedikeret instans på RunPod eller Lambda billigere. Til alt andet, prototyping, intermitterende API'er, demos, sparer Modals scale-to-zero model rigtige penge.

Forudsætninger

Før du starter, skal du bruge tre ting:

1. Python 3.10+ installeret lokalt
2. En Modal-konto, tilmeld dig gratis på modal.com
3. En Hugging Face-konto, til modeladgang (de fleste modeller er begrænsede)

Det er det. Ingen GPU på din lokale maskine, intet CUDA toolkit, ingen Docker.

Trin 1: Installer Modal og godkend

Åbn en terminal og installer Modal Python-pakken:

pip install modal

Kør derefter setup-kommandoen for at linke dit lokale miljø til din Modal-konto:

modal setup

Dette åbner et browservindue til godkendelse. Når du bekræfter, gemmer Modal et token lokalt. Du behøver ikke gøre dette igen.

Trin 2: Definer container-imageet

Modal-containere defineres i Python. Du specificerer base-imageet, installerer afhængigheder og indstiller miljøvariabler, alt sammen som kode. Opret en fil kaldet app.py:

import modal

# Define the container image with CUDA, Python, and vLLM
vllm_image = (
    modal.Image.from_registry(
        "nvidia/cuda:12.8.0-devel-ubuntu22.04", add_python="3.12"
    )
    .entrypoint([])
    .pip_install(
        "vllm==0.13.0",
        "huggingface-hub==0.36.0",
    )
)

app = modal.App("llm-endpoint", image=vllm_image)

Et par ting at bemærke. Der er ingen Dockerfile; den modal.Image-kæde erstatter den fuldstændigt. Base-imageet inkluderer NVIDIA CUDA 12.8 med Ubuntu 22.04, og vi installerer vLLM og Hugging Face Hub-klienten ovenpå.

Trin 3: Konfigurer modellagring med Volumes

LLM-vægte er store (en 7B parameter-model er ~14 GB i fp16). Du ønsker ikke at downloade dem hver gang en container starter. Modal Volumes giver dig vedvarende lagring, der monteres direkte i dine containere:

# Persistent volumes for caching model weights
hf_cache = modal.Volume.from_name("huggingface-cache", create_if_missing=True)
vllm_cache = modal.Volume.from_name("vllm-cache", create_if_missing=True)

MODEL_NAME = "Qwen/Qwen3-4B-Thinking-2507-FP8"
MODEL_REVISION = "953532f942706930ec4bb870569932ef63038fdf"

Vi bruger Qwen3-4B-Thinking (FP8) her, en kvantiseret 4-milliarder parameter-model, der er hurtig, dygtig og passer på en enkelt GPU. Du kan bytte denne ud med enhver Hugging Face-model: Llama 3.1 8B, Mistral 7B eller hvad som helst, som vLLM understøtter.

Hvorfor FP8? Det halverer næsten hukommelsesforbruget sammenlignet med fp16, hvilket betyder, at du kan køre større modeller på samme GPU eller mindre modeller på billigere GPU'er. Hvis du er nysgerrig på trade-offs ved kvantisering, dækker vores guide til at køre LLM'er lokalt præcisionsformaterne i detaljer.

Trin 4: Opret vLLM-serverfunktionen

Her sker Modals magi. Du dekorerer en Python-funktion med GPU-krav, scaling-konfiguration og en webserver-annotation. Modal håndterer alt andet:

N_GPU = 1
MINUTES = 60
VLLM_PORT = 8000

@app.function(
    gpu=f"H100:{N_GPU}",
    scaledown_window=15 * MINUTES,
    timeout=10 * MINUTES,
    volumes={
        "/root/.cache/huggingface": hf_cache,
        "/root/.cache/vllm": vllm_cache,
    },
)
@modal.concurrent(max_inputs=32)
@modal.web_server(port=VLLM_PORT, startup_timeout=10 * MINUTES)
def serve():
    import subprocess

    cmd = [
        "vllm", "serve",
        MODEL_NAME,
        "--revision", MODEL_REVISION,
        "--served-model-name", MODEL_NAME,
        "--host", "0.0.0.0",
        "--port", str(VLLM_PORT),
        "--tensor-parallel-size", str(N_GPU),
        "--enforce-eager",  # Faster cold starts
    ]

    subprocess.Popen(" ".join(cmd), shell=True)

Lad os bryde de vigtigste dekoratorer ned:

• gpu="H100:1", anmoder om en enkelt H100 GPU. Skift til "A100-80GB:1" for billigere inferens eller "H100:2" til 70B+ modeller
• scaledown_window=15 * MINUTES, holder containeren varm i 15 minutter efter den sidste forespørgsel og skalerer derefter ned til nul
• @modal.concurrent(max_inputs=32), tillader op til 32 samtidige forespørgsler per container (vLLM håndterer batching internt)
• @modal.web_server(port=8000), eksponerer vLLM HTTP-serveren direkte som et Modal web-endpoint
• --enforce-eager, springer CUDA-graph-kompilering over for hurtigere kolde starts (trade-off: lidt lavere peak throughput)

scaledown_window er din primære omkostningshebel. Sæt den til 5 minutter til udvikling, 15-30 minutter til produktions-API'er, hvor du forventer regelmæssig trafik.

Trin 5: Deploy til produktion

Én kommando. Det er alt:

modal deploy app.py

Modal bygger container-imageet, pusher det til deres registry og returnerer en live URL:

✓ Created objects.
├── 🔨 Created mount /app.py
├── 🔨 Created volume huggingface-cache
├── 🔨 Created volume vllm-cache
└── 🔨 Created web function serve => https://your-workspace--llm-endpoint-serve.modal.run

Den første deploy tager et par minutter, fordi den downloader modelvægte til volumenet. Efterfølgende deploys (og kolde starts) er meget hurtigere, da vægtene er cachelagret.

Til udvikling skal du bruge modal serve app.py i stedet; det genindlæser hot ved filændringer og giver dig en midlertidig URL.

Trin 6: Kald dit endpoint (OpenAI-kompatibelt)

Din deployede vLLM-server eksponerer et OpenAI-kompatibelt API på /v1/chat/completions. Du kan bruge det officielle OpenAI Python SDK til at kalde det, bare peg base-URL'en mod dit Modal-endpoint:

from openai import OpenAI

client = OpenAI(
    api_key="not-needed",  # vLLM doesn't require auth by default
    base_url="https://your-workspace--llm-endpoint-serve.modal.run/v1",
)

response = client.chat.completions.create(
    model="Qwen/Qwen3-4B-Thinking-2507-FP8",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Explain what vLLM is in two sentences."},
    ],
    temperature=0.7,
    max_tokens=256,
)

print(response.choices[0].message.content)

Dette fungerer også med curl:

curl -X POST https://your-workspace--llm-endpoint-serve.modal.run/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "Qwen/Qwen3-4B-Thinking-2507-FP8",
    "messages": [{"role": "user", "content": "Hello!"}],
    "max_tokens": 128
  }'

Ethvert værktøj, der understøtter et OpenAI-kompatibelt API, vil fungere, LangChain, LlamaIndex, din egen app. Hvis du router forespørgsler på tværs af flere LLM-endpoints, kan et LLM gateway-værktøj hjælpe dig med at administrere failover og load balancing.

Tips til optimering af omkostninger

Modals fakturering per sekund er allerede mere effektiv end timeprissætning, men du kan presse mere ud af det:

1. Brug FP8-kvantisering

FP8-modeller bruger cirka halvdelen af VRAM'en sammenlignet med deres fp16-modstykker. En Qwen3-8B i FP8 passer på en enkelt H100, mens fp16-versionen kræver det meste af den GPUs 80 GB. Mindre VRAM betyder, at du kan bruge billigere GPU'er (A100 40GB, L40S) til mindre modeller.

2. Juster scaledown-vinduet

Parameteren scaledown_window styrer, hvor længe en container forbliver varm efter den sidste forespørgsel:

3. Vælg den rigtige GPU

Gå ikke standard til H100. Mindre modeller har ikke brug for det:

4. Aktiver prompt-caching

Hvis dine workloads involverer gentagne system-prompts eller delte præfikser, kan vLLM's automatiske præfiks-caching reducere latency og beregning betydeligt. Du kan aktivere det ved at tilføje --enable-prefix-caching til vLLM serve-kommandoen. For en dybere udforskning af, hvordan caching fungerer på tværs af forskellige udbydere, tjek vores LLM prompt caching-guide.

5. Brug --enforce-eager til optimering af kold start

Som standard kompilerer vLLM CUDA-grafer ved opstart, hvilket tager 1-3 ekstra minutter. Flaget --enforce-eager springer denne kompilering over. Du bytter ~10-15% peak throughput for dramatisk hurtigere kolde starts. Til bursty workloads, hvor latency betyder mere end rå throughput, er det næsten altid det rigtige valg.

Videre: Fine-tuned modeller

Når du er komfortabel med at deploye basismodeller, er det naturlige næste skridt at deploye din egen fine-tuned version. Workflowet er identisk; du peger blot MODEL_NAME på dit Hugging Face-repo eller et Modal-volume, der indeholder dine fine-tuned vægte.

Modal understøtter også kørsel af fine-tuning jobs direkte på deres GPU'er. Du kan træne en LoRA-adapter på Modal, gemme den på et volume og deploye den mergede model, alt sammen uden at forlade platformen. Vores LLM fine-tuning guide dækker træningssiden i dybden.

Den komplette app.py

Her er det fulde deployment-script i én blok, klar til copy-paste:

import modal

# --- Image Definition ---
vllm_image = (
    modal.Image.from_registry(
        "nvidia/cuda:12.8.0-devel-ubuntu22.04", add_python="3.12"
    )
    .entrypoint([])
    .pip_install("vllm==0.13.0", "huggingface-hub==0.36.0")
)

# --- Volumes for Model Caching ---
hf_cache = modal.Volume.from_name("huggingface-cache", create_if_missing=True)
vllm_cache = modal.Volume.from_name("vllm-cache", create_if_missing=True)

# --- Model Config ---
MODEL_NAME = "Qwen/Qwen3-4B-Thinking-2507-FP8"
MODEL_REVISION = "953532f942706930ec4bb870569932ef63038fdf"

app = modal.App("llm-endpoint", image=vllm_image)

N_GPU = 1
MINUTES = 60
VLLM_PORT = 8000

@app.function(
    gpu=f"H100:{N_GPU}",
    scaledown_window=15 * MINUTES,
    timeout=10 * MINUTES,
    volumes={
        "/root/.cache/huggingface": hf_cache,
        "/root/.cache/vllm": vllm_cache,
    },
)
@modal.concurrent(max_inputs=32)
@modal.web_server(port=VLLM_PORT, startup_timeout=10 * MINUTES)
def serve():
    import subprocess

    cmd = [
        "vllm", "serve",
        MODEL_NAME,
        "--revision", MODEL_REVISION,
        "--served-model-name", MODEL_NAME,
        "--host", "0.0.0.0",
        "--port", str(VLLM_PORT),
        "--tensor-parallel-size", str(N_GPU),
        "--enforce-eager",
    ]

    subprocess.Popen(" ".join(cmd), shell=True)

Deploy med modal deploy app.py, swap MODEL_NAME ud med enhver Hugging Face-model, og du er live.

Ofte stillede spørgsmål

Hvor meget koster det at køre en LLM på Modal?

Det afhænger af GPU'en og hvor længe dit endpoint forbliver varmt. En Qwen3-4B på en H100 koster ~$3,95/time i aktiv brug. Med scale-to-zero og et 15-minutters scaledown-vindue kan et let brugt endpoint koste $5-15/måned. De $30 i gratis månedlige credits dækker en masse eksperimentering.

Skalerer Modal ned til nul?

Ja, det er et af dets primære salgsargumenter. Når der ikke kommer nogen forespørgsler i løbet af din scaledown_window, lukker containeren ned, og du stopper med at betale. Den næste forespørgsel udløser en kold start (typisk 2-10 sekunder afhængigt af modelstørrelse og om du bruger --enforce-eager).

Kan jeg deploye Llama 3.1 eller Mistral på Modal?

Absolut. Swap MODEL_NAME konstanten ud med enhver model, som vLLM understøtter: meta-llama/Llama-3.1-8B-Instruct, mistralai/Mistral-7B-Instruct-v0.3 eller hundreder af andre på Hugging Face. Til 70B+ modeller skal du ændre N_GPU til 2 og bruge gpu="H100:2".

Hvordan sammenlignes kolde starts med RunPod?

Modals kolde starts er typisk 2-4 sekunder for selve containeren plus tid til modelindlæsning. Med modelvægte cachelagret i et Volume og --enforce-eager aktiveret, ser du 10-30 sekunder i alt for en 7-8B model. RunPods serverløse kolde starts varierer fra under 200 ms (cachelagret) til 6-12 sekunder for større containere, selvom deres always-on model undgår kolde starts helt.

Er Modals vLLM-endpoint virkelig OpenAI-kompatibelt?

Ja. vLLM implementerer de samme /v1/chat/completions, /v1/completions og /v1/models endpoints, som OpenAI bruger. Du kan pege det officielle openai Python SDK mod din Modal-URL, og det fungerer out of the box. Streaming, function calling og JSON mode fungerer alle.

Har jeg brug for en GPU på min lokale maskine?

Nej. Din lokale maskine kører kun Modal CLI. Alt GPU-arbejde sker på Modals cloud-infrastruktur. Du kunne faktisk deploye fra en Chromebook, hvis du ville.

Hvordan tilføjer jeg godkendelse til mit endpoint?

Modal web-endpoints er offentlige som standard. Til produktion skal du tilføje et simpelt API-key-tjek i din applikationskode eller bruge Modals indbyggede web-godkendelsesfunktioner. Du kan også opsætte et proxy-lag ved hjælp af en LLM gateway, der håndterer auth, rate limiting og routing.

Hvad er forskellen mellem modal serve og modal deploy?

modal serve opretter et midlertidigt endpoint, der genindlæser hot, når du redigerer din kode, perfekt til udvikling. modal deploy opretter et vedvarende, produktionsklart endpoint med en stabil URL. Brug serve, mens du itererer, og deploy, når du er klar til at levere.

Kan jeg bruge SGLang i stedet for vLLM?

Ja. Modals dokumentation inkluderer SGLang-eksempler sammen med vLLM. SGLang har tendens til at have lavere overhead for decode-tunge workloads og mindre modeller. vLLM er generelt bedre til blandede workloads med tung prefill. Begge producerer OpenAI-kompatible endpoints.

Hvordan sammenlignes dette med at deploye på Railway eller Render?

Platforme som Railway, Render og Fly.io er gode til webapps, men de tilbyder ikke GPU-instanser. Modal er formålsbygget til GPU-workloads med fakturering per sekund og autoscaling. Hvis du har brug for at serve en LLM, er Modal (eller RunPod) det rigtige værktøj; traditionelle PaaS-platforme kan ikke gøre det.

Kilder

• Modal Dokumentation: High-Performance LLM Inference
• Modal: Sådan deployer du vLLM
• Modal Priser
• vLLM OpenAI-Kompatibel Server Dokumentation
• Modal vLLM Inferens Eksempel (GitHub)