Driftsätt en LLM på serverlöst GPU: 5 plattformar, riktiga priser, ärliga kalla starter

Driftsätt en LLM på serverlöst GPU: 5 plattformar, riktiga priser, ärliga kalla starter

RunPod tar $2,72/tim för en A100 80GB. Din endpoint får tolv begäran före lunch. GPU:et står stilla de andra 23 timmarna och debiterar hela tiden. Driftsätt en LLM på serverlöst GPU så betalar du bara medan en begäran körs. Fem plattformar gör det här. De debiterar i fem olika enheter. Ingen normaliserar dem.

Ett overksamt GPU kostar exakt lika mycket som ett upptaget.

Det viktigaste

• Serverlöst GPU debiterar bara medan en begäran körs och skalar till noll däremellan.
• En GPU per instans på Cloud Run; 70B-modeller kräver flera GPU:er, så serverlöst kan oftast inte hosta dem.
• Modellvikter ligger i imagen, på en nätverksvolym eller laddas ner igen vid varje kall start.
• En kall start är tre saker: container-start, viktinläsning, motorinit. Bara den första är snabb.
• Under ungefär 47 000 begäran per dag slår skalning till noll en hyrd GPU dygnet runt.

Vad betyder "serverlöst GPU" egentligen för en LLM?

En serverlös GPU-plattform kör din inferens-container på delad GPU-hårdvara, startar den när en begäran kommer och skalar till noll när trafiken stannar. Du betalar per sekund (eller per minut eller per timme, beroende på leverantör) bara medan containern lever. Ingen idle-faktura. Ingen reserverad instans.

Debiteringsenheten skiljer sig åt mellan leverantörer, vilket är varför nästa avsnitt normaliserar allt till $/GPU-timme.

Två begränsningar överraskar folk. För det första tillåter Google Cloud Run en GPU per instans, som mest. Det sätter VRAM-taket vid ett enda kort. För det andra betyder "serverlöst" inte beständigt tillstånd. Det finns ingen långlivad process som håller dina vikter i RAM mellan begäran. När containern dör dör allt i minnet med den. Just det faktumet driver lagringsbeslutet i modellvikts-avsnittet nedan.

Serverlöst betyder inte ingen server. Det betyder ingen server mellan dina begäran, och det är exakt dit dina modellvikter försvinner.

Vilken serverlös GPU-plattform ska du välja? (2026 års priser, sida vid sida)

Vi säljer ingen av dessa plattformar och tar inga affiliate-intäkter från någon. Av de sju artiklar som konkurrerar om den här sökfrågan och dess närliggande varianter är fyra publicerade av ett företag som säljer serverlösa GPU:er. Det är inte den här tabellen.

Alla taxor är avlästa från leverantörernas egna prissidor den 30 juli 2026. Taxor ändras; dubbelkolla innan du bestämmer dig.

Normaliseringsmatten, visad en gång så att du kan granska den: Modal A100 80GB på $0,000694/s gånger 3600 sekunder blir $2,4984/tim. Beam: $0,000625 gånger 3600 blir $2,25/tim. Baseten: $0,06667/min gånger 60 blir $4,00/tim. Den där 1,8x-spridningen mellan Beam och Baseten för samma A100 är verklig, och den gömmer sig mitt framför ögonen på alla eftersom ingen publicerar samma enhet.

Tre förbehåll. Beams prissida säger uttryckligen att de inte debiterar för server-spin-up eller container-image-laddning. Basetens pris-FAQ besvarar "Do I pay for idle time on Baseten?" med "No, you do not pay for idle time" och lägger sedan till att debiterbar tid är "the time your model is actively deploying, scaling up or down, or making predictions", så mätaren täcker mer än prediktionstiden, och det är den delen som är värd att budgetera för. RunPod publicerar timtaxor och ingen kall-start-siffra på sin prissida.

Om Modal är ditt val har vi skrivit en egen fullständig Modal-genomgång.

Får din modell ens plats? VRAM, en-GPU-gränser och kvoter

Kan du köra en 70B-modell på ett serverlöst GPU? Oftast inte. I FP16 behöver 70B ~140 GB VRAM. Cloud Run har ett tak på en GPU per instans (max 96 GB på RTX PRO 6000). Matten går inte ihop utan kvantisering (FP8/GGUF) eller en fler-GPU-plattform.

Cloud Runs standardkvot är 3 L4-GPU:er per region och projekt (RTX PRO 6000 beviljas separat, som 3 000 milliGPU), över sex L4-regioner: asia-southeast1, asia-south1, europe-west1, europe-west4, us-central1, us-east4. Det är Cloud Run-hälften av svaret om dataresidens för alla som frågar om serverlöst GPU i Europa; Modal och RunPod dokumenterar sina egna EU-regioner, och FAQ:en har resten.

Ismaili Simbas Cloud Run-genomgång på dev.to (april 2025) rapporterar att kvotbegäran "kan ta ett tag (upp till 5 arbetsdagar) att bli godkänd" och att "de L4-GPU:er som finns på Cloud Run har en gräns på 16 GB RAM." Planera för den fördröjningen.

För VRAM-dimensionering modell för modell, se vår guide om VRAM-krav.

Var ligger dina modellvikter (och vad kostar det)?

En Reddit-tråd från november 2024 som fortfarande låg på plats 5 på Google för exakt den här sökfrågan när vi kollade den 30 juli 2026 frågar, ordagrant:

"Jag har inte lyckats hitta något pris för att lagra en 80 GB-modell… Vad finns det för alternativ om jag inte vill ladda ner modellen vid varje API-anrop (pod som provisioneras vid anrop och sedan stängs)? … Varför listar dessa plattformar inte kostnaden för modellagring?"

Tre svar med låga poäng, inget av dem ett svar. När vi körde sökningen den 30 juli 2026 innehöll topp tio fortfarande den två år gamla tråden som frågar vad modellagring kostar. Ingen i tråden svarade. Båda plattformarna publicerar priset. På Modal är det $0,09 per GiB per månad med den första TiB gratis, så den där 80 GB-checkpointen debiteras $0,00. På RunPod är det $0,07 per GB per månad för nätverkslagring under 1 TB, vilket sätter samma checkpoint på ungefär $5,60 i månaden.

Den tredje raden är fällan. En 2024-genomgång av ServerlessLLM från TU München (arXiv 2411.15664) rapporterar att LLaMA-2-70B (130 GB) behöver 26+ sekunder att hämta vid 5 GB/s, plus ~84 sekunder att ladda på 8 GPU:er, mot ~100 ms tokengenerering. De siffrorna citeras i den genomgången, de mäts inte av den.

RunPods prissida har en lagringssektion: container-disk $0,10/GB/mån, volym-disk $0,10/GB/mån körande och $0,20/GB/mån vilande, nätverkslagring $0,07/GB/mån under 1 TB och $0,05/GB/mån över det, högpresterande nätverkslagring $0,14/GB/mån. Siffran finns. Den sitter bara inte bredvid de serverlösa per-GPU-taxorna som läsaren jämför när frågan dyker upp, och inte heller i endpoint-konfigurationsflödet. Ett findability-problem, inte ett hemlighetsmakeri, och tillräckligt för att hålla frågan vid liv två år senare.

# Point the Hugging Face cache at a mounted network volume
# so weights persist across cold starts (RunPod / Modal pattern)
export HF_HOME=/workspace/hf-cache
export TRANSFORMERS_CACHE=/workspace/hf-cache
export HF_HUB_ENABLE_HF_TRANSFER=1

# Alternative: bake weights into the image at build time
FROM vllm/vllm-openai:latest
COPY ./model-weights /models/qwen3-27b-fp8
ENV MODEL_NAME=/models/qwen3-27b-fp8
# Downside: 30+ GB image, full rebuild to change models

Om du inte har valt modell än dimensionerar vår 2026-sammanställning av öppna modeller varje alternativ för driftsättning.

Driftsätt den: vLLM på RunPod Serverless, hela vägen

Sex steg från noll till en anropbar endpoint. Verifiera varje steg mot RunPods vLLM-procedur (uppdaterad 22 juni 2026), som inte publicerar några priser.

1. Välj din modell. Välj en modell med öppna vikter i rätt storlek för ditt GPU (se VRAM-tabellen ovan). Om den är gated på Hugging Face, generera en access-token först.

2. Skapa den serverlösa endpointen. I RunPods konsol, välj Serverless, plocka vLLM-worker-mallen och välj GPU-nivå.

3. Sätt miljövariablerna som spelar roll.

MODEL_NAME=Qwen/Qwen3.6-27B-FP8
MAX_MODEL_LEN=32768
GPU_MEMORY_UTILIZATION=0.90
DTYPE=auto

Fel MODEL_NAME betyder 404 vid start. MAX_MODEL_LEN satt för högt för ditt VRAM betyder OOM före första token. GPU_MEMORY_UTILIZATION över 0,95 lämnar inget utrymme för KV-cache-toppar.

1. Sätt min/max workers och idle-timeout. Min workers på 0 ger dig skalning till noll (och kalla starter). Min workers på 1 tar bort kalla starter men debiterar kontinuerligt. Avsnittet om kalla starter nedan går igenom den avvägningen.

2. Koppla in nätverksvolymen du bestämde dig för i modellvikts-avsnittet, eller acceptera image-inbakning. Hoppar du över det här laddar varje kall start ner checkpointen igen.

3. Avfyra den första begäran. Läs endpoint-ID:t i konsolen och bekräfta att det kommer tillbaka tokens.

curl -X POST "https://api.runpod.ai/v2/${ENDPOINT_ID}/runsync" \
  -H "Authorization: Bearer ${RUNPOD_API_KEY}" \
  -H "Content-Type: application/json" \
  -d '{
    "input": {
      "messages": [{"role": "user", "content": "Explain cold starts in one sentence."}],
      "max_tokens": 60
    }
  }'

Om du väger själva servermotorn jämförde vi vLLM och SGLang på genomströmning och latens.

Hur anropar du endpointen från din app?

Alla plattformar i kortlistan pratar ett OpenAI-kompatibelt API. En Python-snutt fungerar överallt. Att byta leverantör är en base_url-ändring, inte en omskrivning. Det gör om "vilken leverantör" från ett lock-in-beslut till ett konfigurationsbeslut.

import os

from openai import OpenAI

ENDPOINT_ID = os.environ["RUNPOD_ENDPOINT_ID"]

client = OpenAI(
    base_url=f"https://api.runpod.ai/v2/{ENDPOINT_ID}/openai/v1",
    api_key=os.environ["RUNPOD_API_KEY"],
)

response = client.chat.completions.create(
    model="Qwen/Qwen3.6-27B-FP8",
    messages=[{"role": "user", "content": "What is scale to zero?"}],
    max_tokens=120,
)
print(response.choices[0].message.content)

# Same code, different provider. One line changes.
ENDPOINT_ID = os.environ["RUNPOD_ENDPOINT_ID"]

PROVIDERS = {
    "runpod": f"https://api.runpod.ai/v2/{ENDPOINT_ID}/openai/v1",
    "modal": "https://your-app--your-func.modal.run/v1",
    "beam": "https://your-beam-endpoint/v1",
}

client = OpenAI(base_url=PROVIDERS["modal"], api_key="your-key")

Om alla leverantörer pratar OpenAI:s dialekt slutar "vilken serverlös GPU-leverantör" vara ett arkitekturbeslut och blir en rad konfiguration.

När du har flera endpoints täcker vår jämförelse av LLM-gateways routing och failover. För en lättare setup lägger en LiteLLM-proxy till retries och loggning.

Vilken kall start får du egentligen?

För en 7B-modell på serverlöst GPU, räkna med 10 till 30 sekunder vid en riktig kall start (container-start plus viktinläsning plus motorinit), enligt utövarrapporter. Leverantörsdokumentation anger 1 till 5 sekunder för bara container-starten. Gapet mellan de siffrorna är din checkpoint som korsar ett nätverk.

RunPods produktsida hävdar FlashBoot kalla starter under 200 ms (ett leverantörspåstående, inte en mätning). En utövare på r/LLMDevs rapporterar: "kalla starter är enligt min erfarenhet inte särskilt bra … jag skulle säga ~10–30 s", och tillägger "men det mesta av min erfarenhet handlar om diffusionsmodeller." Båda stämmer. De mäter olika saker.

Siffran för kall start är tre siffror staplade:

1. Container-start. Modals dokumentation: "Containers startar på ungefär en sekund." Cloud Run: instanser med förinstallerade drivrutiner "startar på cirka 5 sekunder."

2. Viktinläsning. Delen ingen marknadsför. En 2024-genomgång av ServerlessLLM från TU München (arXiv 2411.15664) sätter LLaMA-2-70B till 26+ sekunder att hämta plus ~84 sekunder att ladda på 8 GPU:er.

3. Motorinit. vLLM-graffångst och uppvärmning. Logesh Umapathi mätte Qwen3.6-27B-FP8 på en A100-80GB: från 460 s baslinje till 219 s med eager mode, till ~70 s med vLLM sleep mode plus Modal GPU-snapshots. Det är 6,5x, publicerat 17 maj 2026.

Vår tolkning av publicerade data: leverantörssiffror mäter containern. Utövaresiffror mäter hela begäran. Mellan de två stoppuren sitter 80 GB vikter som korsar ett nätverk. Kolumnen Typ är poängen.

Vad du gör: vLLM sleep mode, GPU-snapshots och att trimma nedskalningsfönstret. Modals standard-idle är 60 sekunder (konfigurerbart 2 s–20 min). En varm worker tar bort kalla starter men debiterar som alltid-på.

# Modal scaledown config (illustrative)
# A 60s window means you pay for 60 idle seconds per burst.
# A warm worker (min_containers=1) costs ~$2.50/hr on A100 80GB, 24/7.
@app.function(
    gpu="A100",
    scaledown_window=60,  # seconds idle before shutdown
    # min_containers=1,   # uncomment to kill cold starts; costs $60/day
)

Är serverlöst GPU billigare än ett alltid-på-GPU?

Serverlöst GPU är billigare när ditt GPU står stilla större delen av dygnet. Vid 3 000 begäran/dag med i snitt 2 sekunder vardera på en A100 80GB kostar serverlöst ungefär $4,17/dag mot $65,28/dag för ett hyrt GPU som körs dygnet runt. Brytpunkten är en fråga om nyttjandegrad, inte om volym.

Antaganden (våra, redovisade så att du kan räkna om): A100 80GB till Modals $2,50/tim, 2 sekunder genomsnittlig GPU-tid per begäran, hyrd GPU till RunPods $2,72/tim dygnet runt, hostat token-API till $0,40/1M tokens (en publicerad mellanprisnivå) och ~1 000 tokens per begäran.

Brytpunkten landar runt 47 000 begäran/dag. Under det vinner serverlöst. Ett hostat token-API slår båda vid låg volym med en standardmodell. Break-even handlar inte om hur många begäran du får. Det handlar om hur många timmar ditt GPU tillbringar med att göra ingenting.

BentoML:s analys från augusti 2024 ramar in avvägningen bra, även om prisexemplen är från GPT-3.5-turbo-eran och två år gamla.

För vad ett hostat token-API kostar vid din volym, se vår prisjämförelse för LLM-API:er. För att sänka kostnaden per begäran på inferenssidan sparar prompt-cachning typiskt 30–60 % på upprepad kontext.

# Break-even calculator: adjust these and re-run
REQUESTS_PER_DAY = 3000
SECONDS_PER_REQUEST = 2
SERVERLESS_RATE_HR = 2.50   # Modal A100 80GB
RENTED_RATE_HR = 2.72       # RunPod A100 80GB, 24/7

serverless_daily = REQUESTS_PER_DAY * SECONDS_PER_REQUEST / 3600 * SERVERLESS_RATE_HR
rented_daily = RENTED_RATE_HR * 24

print(f"Serverless: ${serverless_daily:.2f}/day")
print(f"Rented 24/7: ${rented_daily:.2f}/day")
print(f"Crossover: {int(RENTED_RATE_HR * 24 / (SECONDS_PER_REQUEST / 3600 * SERVERLESS_RATE_HR))} req/day")

När serverlöst GPU är fel val

• Stadigt hög trafik. Över ~47 000 begäran/dag till dessa priser vänder nyttjandegraden och ett hyrt GPU blir billigare per begäran.
• Hårda SLO:er under sekunden på kall väg. Inga snapshot-trick gör den första begäran omedelbar. Behåll en varm worker eller hyr burken.
• 70B+ modeller som behöver flera GPU:er. En GPU per instans på Cloud Run avslutar den diskussionen.
• Strikt dataresidens. Sex L4-regioner är hela menyn på Cloud Run.
• Begärans-ekonomi som förlorar mot en worker-plats du redan betalar för. Har du ledigt GPU-utrymme kostar extra inferens ingenting.

Om ditt GPU är upptaget sexton timmar om dygnet är serverlöst det dyra alternativet, och den som säger något annat säljer serverlöst.

För vägen med lokalt först, se vår guide om lokala LLM-verktyg.

Vanliga frågor

Vad är ett serverlöst GPU?

En serverlös GPU-plattform kör din modellcontainer på delad hårdvara, skalar till noll mellan begäran och debiterar bara aktiv beräkning. Du får en inferens-endpoint utan att hantera en beständig GPU-instans. Priset är en kall-start-fördröjning vid uppstart.

Vad kostar det att köra en LLM på ett serverlöst GPU?

En A100 80GB går på $2,25/tim på Beam, $2,50/tim på Modal, $2,72/tim på RunPod (verifierat 30 juli 2026). Din faktura beror på nyttjandegraden: 3 000 begäran/dag à 2 s kostar ~$4/dag på Modal. Lagring tillkommer med $0,09/GiB/månad, med 1 TiB gratis.

Betalar jag för att lagra modellviktorna?

Ja, men det är billigt. Modal tar $0,09/GiB/månad med 1 TiB/månad gratis, så en 80 GB-checkpoint kostar ingenting. RunPods prissida listar nätverkslagring för $0,07/GB/månad under 1 TB, ungefär $5,60/månad för samma 80 GB.

Laddas min modell ner igen vid varje begäran?

Bara om inget är cachat. Vikter på en beständig volym eller inbakade i imagen överlever kalla starter. Peka Hugging Face-cachen mot flyktig lagring så laddas en 130 GB-modell ner vid varje uppstart. Det är fällan att undvika.

Hur lång är den kalla starten för en 7B-modell?

Räkna med 10–30 sekunder vid en riktig kall start, enligt utövarrapporter (r/LLMDevs, dec 2024). Containern startar på 1–5 s (Modal, Cloud Run-dokumentationen). Resten är viktinläsning och motorinit. Med snapshots och sleep mode mätte Umapathi ~70 s för en 27B-modell, ner från 460 s.

Kan jag köra en 70B-modell på serverlöst GPU?

Oftast inte. En 70B-modell i FP16 behöver ~140 GB VRAM. Cloud Run tillåter en GPU per instans (max 96 GB). Du behöver FP8-kvantisering för att få plats på ett enda 80 GB-kort, eller en fler-GPU-plattform. De flesta serverlösa ytor har ett-GPU-tak.

Är serverlöst GPU billigare än att hyra ett GPU dygnet runt?

Under ~47 000 begäran/dag (vid 2 s/begäran på en A100 80GB), ja. Serverlöst debiterar bara aktiva sekunder; ett hyrt GPU debiterar 24 timmar oavsett. Över det vinner det hyrda GPU:et. Ett hostat token-API slår båda vid låga volymer. Se break-even-tabellen ovan.

Kan jag driftsätta en LLM på serverlöst GPU gratis?

Modal ger $30/månad i gratis krediter (Starter). Beam ger $30/månad. GCP:s $300-kredit för nya konton täcker Cloud Run GPU-användning. Nog för att prototypa, inte för att köra produktionstrafik. Ingen plattform erbjuder en permanent gratisnivå för GPU-inferens.

Vilka serverlösa GPU-leverantörer finns i Europa?

Cloud Run kör L4-GPU:er i europe-west1 (Belgien) och europe-west4 (Nederländerna). Modal dokumenterar EU-regionval (eu-west, eu-north, eu-south) prissatta till 1,5–1,75x bastaxorna. RunPod namnger europeiska datacenter, bland annat EU-NL-1 och EU-FR-1. Sätt regionen explicit; ingen av dem har EU som standard.

Behöver jag Docker för att driftsätta en LLM på serverlöst GPU?

Inte alltid. RunPod erbjuder färdiga vLLM-worker-mallar som hoppar över Docker. Modal bygger containrar från en Python-image-definition i kod. För egna beroenden skriver du en Dockerfile. För vanlig vLLM-serving fungerar den färdiga vägen på minuter.

Slutsats

Fem plattformar, fem debiteringsenheter, en normaliserad tabell. Beslutet är enklare än leverantörssidorna får det att se ut:

• Välj GPU efter VRAM, inte efter märke.
• Lägg vikterna på en volym, inte i imagen, om du inte aldrig byter modell.
• Räkna med 10–30 sekunder kalla starter och planera efter det.
• Under ~47 000 begäran/dag vinner skalning till noll på kostnad.
• Servermotorn bakom endpointen går att byta ut; base_url är en rad.

Du har en anropbar endpoint. Nästa fråga: vad ska stå framför den när du behöver routing och failover? Vår jämförelse av LLM-gateways svarar på det. Eller bolla din setup med oss.