Een LLM deployen op serverless GPU: 5 platforms, echte prijzen, eerlijke cold starts

Een LLM deployen op serverless GPU: 5 platforms, echte prijzen, eerlijke cold starts

RunPod rekent $2,72/uur voor een A100 80GB. Je endpoint krijgt twaalf requests voor de lunch. Die GPU staat de andere 23 uur stil en factureert de hele tijd door. Deploy een LLM op een serverless GPU en je betaalt alleen terwijl een request draait. Vijf platforms doen dit. Ze factureren in vijf verschillende eenheden. Niemand normaliseert ze.

Een stilstaande GPU kost precies evenveel als een drukke.

Belangrijkste punten

• Serverless GPU factureert alleen terwijl een request draait en schaalt tussendoor naar nul.
• Eén GPU per instance op Cloud Run; 70B-modellen hebben meerdere GPU's nodig, dus serverless kan ze meestal niet hosten.
• Modelgewichten zitten in de image, op een netwerkvolume, of worden bij elke cold start opnieuw gedownload.
• Een cold start bestaat uit drie dingen: container-boot, gewichten laden, engine-init. Alleen de eerste is snel.
• Onder ruwweg 47.000 requests per dag wint scale-to-zero van een gehuurde 24/7 GPU.

Wat betekent 'serverless GPU' eigenlijk voor een LLM?

Een serverless GPU-platform draait je inference-container op gedeelde GPU-hardware, start hem op wanneer een request binnenkomt en schaalt naar nul wanneer het verkeer stopt. Je betaalt per seconde (of per minuut, of per uur, afhankelijk van de vendor) alleen terwijl de container live is. Geen stilstandsfactuur. Geen gereserveerde instance.

De factuureenheid verschilt per vendor, daarom normaliseert de volgende sectie alles naar $/GPU-uur.

Twee beperkingen verrassen mensen. Ten eerste: Google Cloud Run staat één GPU per instance toe, maximaal. Dat begrenst je VRAM-plafond op één kaart. Ten tweede betekent "serverless" niet dat er persistente state is. Er is geen langlevend proces dat je gewichten tussen requests in RAM houdt. Wanneer de container sterft, sterft alles in het geheugen mee. Dat ene feit stuurt de opslagbeslissing in de modelgewichten-sectie hieronder.

Serverless betekent niet geen server. Het betekent geen server tussen je requests, en precies daar verdwijnen je modelgewichten naartoe.

Welk serverless GPU-platform kies je? (prijzen 2026, naast elkaar)

We verkopen geen van deze platforms en ontvangen van geen enkele affiliate-inkomsten. Van de zeven artikelen die concurreren op deze zoekopdracht en zijn varianten, zijn er vier gepubliceerd door een bedrijf dat serverless GPU's verkoopt. Deze tabel niet.

Alle tarieven gelezen van de eigen prijs pagina's van de vendors op 30-07-2026. Tarieven veranderen; controleer opnieuw voordat je vastlegt.

De normalisatie-rekensom, één keer getoond zodat je hem kunt controleren: Modal A100 80GB à $0,000694/s vermenigvuldigd met 3600 seconden is $2,4984/uur. Beam: $0,000625 keer 3600 is $2,25/uur. Baseten: $0,06667/min keer 60 is $4,00/uur. Die spreiding van 1,8x tussen Beam en Baseten voor dezelfde A100 is echt, en hij verschuilt zich in plain sight omdat niemand dezelfde eenheid publiceert.

Drie kanttekeningen. De prijs pagina van Beam vermeldt expliciet dat ze het opstarten van servers of het laden van container-images niet factureren. De prijs-FAQ van Baseten beantwoordt "Do I pay for idle time on Baseten?" met "No, you do not pay for idle time", en voegt toe dat factureerbare tijd "the time your model is actively deploying, scaling up or down, or making predictions" is, dus de meter dekt meer dan predictietijd, en dat is het deel om te begroten. RunPod publiceert uurtarieven en geen cold-start-cijfer op zijn prijs pagina.

Als Modal je keuze is, hebben we de volledige Modal-walkthrough apart geschreven.

Past je model wel? VRAM, één-GPU-limieten en quota

Kun je een 70B-model op een serverless GPU draaien? Meestal niet. Bij FP16 heeft 70B ~140 GB VRAM nodig. Cloud Run begrenst op één GPU per instance (max 96 GB op RTX PRO 6000). De som klopt niet zonder kwantisatie (FP8/GGUF) of een multi-GPU-platform.

De standaard quota van Cloud Run is 3 L4-GPU's per regio per project (RTX PRO 6000 wordt apart toegekend, als 3.000 milliGPU), verdeeld over zes L4-regio's: asia-southeast1, asia-south1, europe-west1, europe-west4, us-central1, us-east4. Dat is de Cloud Run-helft van het antwoord op dataresidency voor iedereen die vraagt naar serverless GPU in Europa; Modal en RunPod documenteren hun eigen EU-regio's, en de FAQ heeft de rest.

Ismaili Simba's Cloud Run-walkthrough op dev.to (april 2025) meldt dat het quota-verzoek "can take some time (up to 5 working days) to be approved", en dat "the L4 GPUs available on Cloud Run have a limit of 16GB RAM." Plan die vertraging in.

Voor VRAM-sizing per model, zie onze VRAM-vereisten-gids.

Waar staan je modelgewichten (en wat kost dat)?

Een Reddit-thread van november 2024 die, toen we op 30-07-2026 controleerden, nog steeds op #5 stond op Google voor precies deze zoekopdracht, vraagt letterlijk:

"I have been unable to find rate for storing the 80 gb model… What's an alternative if I don't want to download the model at every api calls (pod provisioned at call then closed)? … Why do these platforms not list model storage cost?"

Drie antwoorden met lage scores, geen ervan een antwoord. Toen we deze zoekopdracht op 30-07-2026 draaiden, bevatten de top tien resultaten nog steeds die twee jaar oude thread die vraagt wat modelopslag kost. Niemand in de thread beantwoordde het. Beide platforms publiceren het tarief. Bij Modal is het $0,09 per GiB per maand met de eerste TiB gratis, dus die 80 GB-checkpoint factureert $0,00. Bij RunPod is het $0,07 per GB per maand voor netwerkopslag onder 1 TB, wat dezelfde checkpoint op ruwweg $5,60 per maand zet.

De derde rij is de faalmodus. Een 2024 TU München-review van ServerlessLLM (arXiv 2411.15664) meldt dat LLaMA-2-70B (130 GB) 26+ seconden nodig heeft om te halen bij 5 GB/s, plus ~84 seconden om op 8 GPU's te laden, tegen ~100 ms tokengeneratie. Die cijfers zijn geciteerd in die review, niet gemeten.

De prijs pagina van RunPod heeft een Storage-sectie: container disk $0,10/GB/mnd, volume disk $0,10/GB/mnd draaiend en $0,20/GB/mnd stilstand, netwerkopslag $0,07/GB/mnd onder 1 TB en $0,05/GB/mnd erboven, high-performance netwerkopslag $0,14/GB/mnd. Het cijfer bestaat. Het staat alleen niet naast de per-GPU serverless-tarieven die een lezer vergelijkt wanneer de vraag opkomt, en ook niet in de endpoint-configuratieflow. Een vindbaarheidsprobleem, geen geheimhoudingsprobleem, en genoeg om de vraag twee jaar later levend te houden.

# 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

Als je nog geen model hebt gekozen, onze 2026 open-weights-roundup sized elke optie voor deployment.

Deployen: vLLM op RunPod Serverless, end-to-end

Zes stappen van nul naar een aanroepbaar endpoint. Verifieer elke stap tegen RunPod's vLLM-procedure (bijgewerkt 22 jun 2026), die geen prijzen publiceert.

1. Kies je model. Kies een open-weights model dat past bij je GPU (zie de VRAM-tabel hierboven). Als het gated is op Hugging Face, genereer dan eerst een access token.

2. Maak het serverless endpoint aan. Selecteer Serverless in de console van RunPod, kies de vLLM-worker-template en kies je GPU-tier.

3. Stel de environment-variabelen in die ertoe doen.

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

MODEL_NAME fout betekent een 404 bij boot. MAX_MODEL_LEN te hoog ingesteld voor je VRAM betekent OOM vóór de eerste token. GPU_MEMORY_UTILIZATION boven 0,95 laat geen hoofdruimte voor KV-cache-pieken.

1. Stel min/max workers en idle-timeout in. Min workers op 0 geeft je scale-to-zero (en cold starts). Min workers op 1 doodt cold starts maar factureert continu. De cold-start-sectie hieronder werkt die afweging uit.

2. Koppel het netwerkvolume waar je in de modelgewichten-sectie voor hebt gekozen, of accepteer het image-bake-pad. Als je dit overslaat, downloadt elke cold start de checkpoint opnieuw.

3. Vuur het eerste request af. Lees de endpoint-ID uit de console en bevestig dat tokens terugkomen.

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
    }
  }'

Als je de serving-engine zelf afweegt, vergeleken we vLLM en SGLang op throughput en latency.

Hoe roep je het endpoint aan vanuit je app?

Elk platform in de shortlist spreekt een OpenAI-compatibele API. Eén Python-snippet werkt overal. Van provider wisselen is een base_url-wijziging, geen rewrite. Dat herkadert "welke provider" van een lock-in-beslissing naar een configuratiebeslissing.

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")

Als elke provider het dialect van OpenAI spreekt, houdt "welke serverless GPU-provider" op een architectuurbeslissing te zijn en wordt het één regel configuratie.

Zodra je meerdere endpoints hebt, dekt onze LLM-gateway-vergelijking routing en failover. Voor een lichtere setup voegt een LiteLLM-proxy retries en logging toe.

Welke cold start zie je daadwerkelijk?

Voor een 7B-model op een serverless GPU, verwacht 10 tot 30 seconden bij een echte cold start (container-boot plus gewichten laden plus engine-init), op basis van rapporten van practitioners. Vendor-docs noemen 1 tot 5 seconden voor alleen de container-boot. Het gat tussen die cijfers is je checkpoint die een netwerk oversteekt.

De productpagina van RunPod claimt FlashBoot-cold starts onder 200ms (een vendor-claim, geen meting). Een practitioner in r/LLMDevs meldt: "cold starts in my experience aren't great … I would say ~ 10 - 30 s", en voegt toe "most of my experience revolves around diffusion models though." Beide zijn waar. Ze meten verschillende dingen.

Het cold-start-cijfer zijn drie cijfers gestapeld:

1. Container-boot. Modal's docs: "Containers boot in about one second." Cloud Run: instances met drivers vooraf geïnstalleerd "start in approximately 5 seconds."

2. Gewichten laden. Het deel dat niemand adverteert. Een 2024 TU München-review van ServerlessLLM (arXiv 2411.15664) zet LLaMA-2-70B op 26+ seconden om te halen plus ~84 seconden om op 8 GPU's te laden.

3. Engine-init. vLLM graph capture en warm-up. Logesh Umapathi mat Qwen3.6-27B-FP8 op een A100-80GB gaande van 460s baseline naar 219s met eager mode tot ~70s met vLLM sleep mode plus Modal GPU-snapshots. Dat is 6,5x, gepubliceerd 17 mei 2026.

Onze interpretatie van gepubliceerde data: vendor-cijfers timen de container. Practitioner-cijfers timen het hele request. Tussen die twee stopwatches zit 80 GB aan gewichten die een netwerk oversteken. De kolom Type is het punt.

Wat te doen: vLLM sleep mode, GPU-snapshots en het scaledown-venster tunen. De standaard idle van Modal is 60 seconden (configureerbaar 2s-20min). Een warme worker doodt cold starts maar factureert als always-on.

# 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
)

Is serverless GPU goedkoper dan een always-on GPU?

Serverless GPU is goedkoper wanneer je GPU het grootste deel van de dag stilstaat. Bij 3.000 requests/dag van gemiddeld 2 seconden elk op een A100 80GB kost serverless ruwweg $4,17/dag versus $65,28/dag voor een gehuurde GPU die 24/7 draait. Het omslagpunt is een duty-cycle-vraag, geen volumevraag.

Aannames (van ons, vermeld zodat je ze kunt herhalen): A100 80GB à $2,50/uur van Modal, 2 seconden gemiddelde GPU-tijd per request, gehuurde GPU à $2,72/uur van RunPod rond de klok, gehoste token-API à $0,40/1M tokens (een middenklasse gepubliceerd tarief) en ~1.000 tokens per request.

Het omslagpunt ligt rond 47.000 requests/dag. Daaronder wint serverless. Een gehoste token-API verslaat beide bij laag volume met een commodity-model. Break-even gaat niet over hoeveel requests je krijgt. Het gaat over hoeveel uur je GPU niets doet.

De analyse van BentoML van augustus 2024 kadert deze afweging goed, hoewel zijn prijsvoorbeelden uit het GPT-3.5-turbo-tijdperk stammen en twee jaar verouderd zijn.

Voor wat een gehoste token-API kost bij jouw volume, zie onze LLM-API-prijsvergelijking. Om de kosten per request aan de inference-kant te drukken, bespaart prompt-caching doorgaans 30-60% op herhaalde context.

# 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")

Wanneer serverless GPU de verkeerde keuze is

• Aanhoudend hoog verkeer. Voorbij ~47.000 requests/dag bij deze tarieven keert de duty cycle om en is een gehuurde GPU goedkoper per request.
• Harde sub-seconde SLO's op een koud pad. Geen snapshot-truc maakt een eerste request instant. Houd een warme worker aan of huur de machine.
• 70B+ modellen die meerdere GPU's nodig hebben. Eén GPU per instance op Cloud Run beëindigt dat gesprek.
• Strikte dataresidency. Zes L4-regio's is het hele menu op Cloud Run.
• Per-request-economie die verliest van een worker-slot waar je toch al voor betaalt. Als je GPU-hoofdruimte over hebt, kost inference toevoegen niets extra.

Als je GPU zestien uur per dag druk is, is serverless de dure optie en wie je anders vertelt, verkoopt serverless.

Voor het local-first-pad, zie onze lokale LLM-tooling-gids.

Veelgestelde vragen

Wat is een serverless GPU?

Een serverless GPU-platform draait je modelcontainer op gedeelde hardware, schaalt tussen requests naar nul en factureert alleen voor actieve compute. Je krijgt een inference-endpoint zonder een persistente GPU-instance te beheren. De afweging is een cold-start-vertraging bij het opstarten.

Wat kost het om een LLM op een serverless GPU te draaien?

Een A100 80GB draait à $2,25/uur op Beam, $2,50/uur op Modal, $2,72/uur op RunPod (geverifieerd 30-07-2026). Je factuur hangt af van de duty cycle: 3.000 requests/dag à 2s elk kost ~$4/dag op Modal. Opslag voegt $0,09/GiB/maand toe, met 1 TiB gratis.

Betaal ik voor het opslaan van de modelgewichten?

Ja, maar het is goedkoop. Modal rekent $0,09/GiB/maand met 1 TiB/maand gratis, dus een 80 GB-checkpoint kost niets. De prijs pagina van RunPod vermeldt netwerkopslag à $0,07/GB/maand onder 1 TB, ongeveer $5,60/maand voor dezelfde 80 GB.

Downloadt mijn model opnieuw bij elk request?

Alleen als er niets gecachet is. Gewichten op een persistent volume of in de image gebakken overleven cold starts. Richt de Hugging Face-cache op ephemeral storage en een 130 GB-model downloadt opnieuw bij elke opstart. Dat is de faalmodus om te vermijden.

Hoe lang is de cold start voor een 7B-model?

Verwacht 10-30 seconden bij een echte cold start, volgens rapporten van practitioners (r/LLMDevs, dec 2024). De container boot in 1-5s (Modal, Cloud Run docs). De rest is gewichten laden en engine-init. Met snapshots en sleep mode mat Umapathi ~70s voor een 27B-model, omlaag van 460s.

Kan ik een 70B-model op een serverless GPU draaien?

Meestal niet. Een 70B-model à FP16 heeft ~140 GB VRAM nodig. Cloud Run staat één GPU per instance toe (max 96 GB). Je hebt FP8-kwantisatie nodig om op één 80 GB-kaart te passen, of een multi-GPU-platform. De meeste serverless-oppervlakken begrenzen op één GPU.

Is serverless GPU goedkoper dan een GPU 24/7 huren?

Onder ~47.000 requests/dag (à 2s/request op een A100 80GB), ja. Serverless factureert alleen actieve seconden; een gehuurde GPU factureert 24 uur ongeacht. Daarboven wint de gehuurde GPU. Een gehoste token-API verslaat beide bij laag volume. Zie de break-even-tabel hierboven.

Kan ik een LLM gratis op een serverless GPU deployen?

Modal geeft $30/maand gratis credits (Starter). Beam geeft $30/maand. Het $300 tegoed van GCP voor nieuwe accounts dekt Cloud Run GPU-gebruik. Genoeg om te prototypen, niet om productieverkeer te draaien. Geen enkel platform biedt een permanente gratis tier voor GPU-inference.

Welke serverless GPU-providers zijn beschikbaar in Europa?

Cloud Run serveert L4-GPU's in europe-west1 (België) en europe-west4 (Nederland). Modal documenteert EU-regioselectie (eu-west, eu-north, eu-south) geprijsd à 1,5-1,75x de basistarieven. RunPod noemt Europese datacenters waaronder EU-NL-1 en EU-FR-1. Pin de regio expliciet; geen van hen default naar de EU.

Heb ik Docker nodig om een LLM op een serverless GPU te deployen?

Niet altijd. RunPod biedt vooraf gebouwde vLLM-worker-templates die Docker overslaan. Modal bouwt containers vanuit een Python-image-definitie in code. Voor custom dependencies schrijf je een Dockerfile. Voor standaard vLLM-serving werkt het vooraf gebouwde pad in minuten.

Conclusie

Vijf platforms, vijf factuureenheden, één genormaliseerde tabel. De beslissing is eenvoudiger dan de vendor-pagina's het laten lijken:

• Kies je GPU op VRAM, niet op merk.
• Zet je gewichten op een volume, niet in de image, tenzij je nooit modellen wisselt.
• Verwacht cold starts van 10-30 seconden en plan eromheen.
• Onder ~47.000 requests/dag wint scale-to-zero op kosten.
• De serving-engine achter het endpoint is verwisselbaar; de base_url is één regel.

Je hebt een aanroepbaar endpoint. Volgende: wat staat ervoor wanneer je routing en failover nodig hebt? Onze LLM-gateway-vergelijking beantwoordt dat. Of bespreek je setup met ons.