Ota LLM-käyttöön Modalilla: pip installista tuotantopäätepisteeseen

Ota LLM-käyttöön Modalilla: pip installista tuotantopäätepisteeseen

Useimmat oppaat LLM-mallien itse isännöimisestä ohittavat vaikeimman osan: infrastruktuurin. Taistelet CUDA-ajurien kanssa, hallinnoit Docker-kuvia, määrität automaattista skaalausta ja joudut silti jotenkin maksamaan tyhjäkäynnissä olevista GPU:ista kello 3 aamulla. Modal poistaa kaiken tämän. Kirjoitat Pythonia, otat palvelun käyttöön ja saat URL-osoitteen.

Tämä opas käy läpi avoimen lähdekoodin LLM-mallin käyttöönoton Modalissa vLLM:n toimiessa päättelymoottorina. Lopussa sinulla on käytössä live-API-päätepiste, joka on yhteensopiva OpenAI:n kanssa, pyörii H100-GPU:illa ja skaalautuu nollaan, kun kukaan ei käytä sitä.

Mikä on Modal (ja miksi käyttää sitä LLM:iin)?

Modal on serverless-laskenta-alusta, joka on rakennettu erityisesti tekoälytyökuormille. Ajattele AWS Lambdaa, mutta GPU-tuella, sekuntiperusteisella laskutuksella ja Python-natiivilla kehittäjäkokemuksella. Ei YAML-tiedostoja, ei Dockerfilejä, ei Kubernetesia; määrittelet koko infrastruktuurisi Python-skriptissä ja otat sen käyttöön yhdellä komennolla.

Tässä syyt, miksi siitä on tullut suosituin valinta LLM-käyttöönotoissa:

• Nollaan skaalautuva laskutus, et maksa mitään, kun päätepisteesi ei käsittele pyyntöjä
• Sekuntiperusteinen GPU-hinnoittelu, H100:t hintaan ~3,95 $/h, A100 80GB hintaan ~2,50 $/h, laskutetaan sekunteina
• Alle sekunnin kestävät kylmäkäynnistykset, kontit käynnistyvät nopeasti, erityisesti muistivedosten avulla
• 30 $ kuukausittaiset ilmaiset luotot, riittää kokeiluihin ilman luottokorttimaksua
• Ei DevOpsia, ei Docker-rakennuksia, ei Terraformia, ei klusterinhallintaa

Jos olet ajanut LLM-malleja paikallisesti ja haluat antaa niille kunnollisen API:n ilman palvelinten hallinnointia, Modal on lyhyin reitti siihen.

Modal vs. RunPod vs. Lambda

Yhteenveto: Modal voittaa piikikkäissä työkuormissa ja kehityksessä. Jos GPU:n käyttöasteesi ylittää johdonmukaisesti 40 %, dedikoitu instanssi RunPodissa tai Lambdassa on edullisempi. Kaikkeen muuhun, prototyyppien tekemiseen, ajoittaisiin API-kutsuihin ja demoihin, Modalin nollaan skaalautuva malli säästää oikeaa rahaa.

Esitiedot

Ennen kuin aloitat, tarvitset kolme asiaa:

1. Python 3.10+ asennettuna paikallisesti
2. Modal-tili, rekisteröidy ilmaiseksi osoitteessa modal.com
3. Hugging Face -tili, mallien käyttöä varten (useimmat mallit ovat rajoitettuja)

Siinä kaikki. Ei GPU:ta paikallisella koneella, ei CUDA-työkalupakkia, ei Dockeria.

Vaihe 1: Asenna Modal ja todennuta

Avaa terminaali ja asenna Modalin Python-paketti:

pip install modal

Suorita sitten asennuskomento yhdistääksesi paikallisen ympäristösi Modal-tiliisi:

modal setup

Tämä avaa selaimen ikkunan todennusta varten. Kun vahvistat toiminnon, Modal tallentaa tunnuksen paikallisesti. Sinun ei tarvitse tehdä tätä enää uudelleen.

Vaihe 2: Määritä konttikuva

Modal-kontit määritellään Pythonilla. Määrität peruskuvan, asennat riippuvuudet ja asetat ympäristömuuttujat, kaikki koodina. Luo tiedosto nimeltä 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)

Huomioi muutama asia. Dockerfileä ei ole, tuo modal.Image-ketju korvaa sen kokonaan. Peruskuva sisältää NVIDIA CUDA 12.8:n Ubuntu 22.04:n kanssa, ja asennamme sen päälle vLLM:n ja Hugging Face Hub -asiakasohjelman.

Vaihe 3: Määritä mallin tallennus volyymeillä

LLM-mallien painot ovat suuria (7 miljardin parametrin malli on noin 14 GB fp16-muodossa). Et halua ladata niitä joka kerta, kun kontti käynnistyy. Modal Volumes tarjoaa pysyvän tallennustilan, joka liitetään suoraan kontteihisi:

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

Käytämme tässä Qwen3-4B-Thinking (FP8) -mallia, kvantisoidun 4 miljardin parametrin mallin, joka on nopea, kyvykäs ja mahtuu yhdelle GPU:lle. Voit vaihtaa tämän mihin tahansa Hugging Face -malliin: Llama 3.1 8B, Mistral 7B tai mihin tahansa, mitä vLLM tukee.

Miksi FP8? Se leikkaa muistin käytön suunnilleen puoleen verrattuna fp16:een, mikä tarkoittaa, että voit ajaa suurempia malleja samalla GPU:lla tai pienempiä malleja edullisemmilla GPU:illa. Jos olet kiinnostunut kvantisoinnin kompromisseista, oppaamme LLM-mallien paikalliseen ajamiseen käsittelee tarkkuusmuotoja yksityiskohtaisesti.

Vaihe 4: Luo vLLM-palvelinfunktio

Tässä Modalin taika tapahtuu. Koristat Python-funktion GPU-vaatimuksilla, skaalausasetuksilla ja web-palvelinmerkinnällä. Modal hoitaa kaiken muun:

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)

Puretaan tärkeimmät dekoratorit:

• gpu="H100:1", pyytää yhtä H100-GPU:ta. Vaihda arvoon "A100-80GB:1" edullisempaa päättelyä varten tai "H100:2" 70B+ malleja varten
• scaledown_window=15 * MINUTES, pitää kontin lämpimänä 15 minuuttia viimeisen pyynnön jälkeen ja skaalaa sitten nollaan
• @modal.concurrent(max_inputs=32), sallii jopa 32 samanaikaista pyyntöä konttia kohden (vLLM hoitaa batchauksen sisäisesti)
• @modal.web_server(port=8000), paljastaa vLLM HTTP -palvelimen suoraan Modalin web-päätepisteenä
• --enforce-eager, ohittaa CUDA-graafien kääntämisen nopeampien kylmäkäynnistysten vuoksi (kompromissi: hieman alhaisempi huippuläpäisykyky)

scaledown_window on tärkein kustannusvipusi. Aseta se 5 minuuttiin kehitystä varten ja 15–30 minuuttiin tuotanto-API:ita varten, joissa odotat säännöllistä liikennettä.

Vaihe 5: Ota käyttöön tuotannossa

Yksi komento. Siinä kaikki:

modal deploy app.py

Modal rakentaa konttikuvan, pushaa sen omaan rekisteriinsä ja palauttaa live-URL-osoitteen:

✓ 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

Ensimmäinen käyttöönotto vie muutaman minuutin, koska se lataa mallipainot volyymiin. Myöhemmät käyttöönotot (ja kylmäkäynnistykset) ovat paljon nopeampia, koska painot on välimuistissa.

Kehitystä varten käytä sen sijaan modal serve app.py; se lataa koodin uudelleen tiedostomuutosten yhteydessä ja antaa sinulle väliaikaisen URL-osoitteen.

Vaihe 6: Kutsu päätepistettäsi (OpenAI-yhteensopiva)

Käyttöönotettu vLLM-palvelimesi paljastaa OpenAI-yhteensopivan API:n osoitteessa /v1/chat/completions. Voit käyttää standardia OpenAI Python SDK:ta kutsuaksesi sitä, kunhan osoitat base-URL:n Modal-päätepisteeseesi:

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)

Tämä toimii myös curl:lla:

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

Mikä tahansa työkalu, joka tukee OpenAI-yhteensopivaa API:a, toimii: LangChain, LlamaIndex tai oma sovelluksesi. Jos reitität pyyntöjä useiden LLM-päätepisteiden välillä, LLM-gateway-työkalu voi auttaa sinua hallitsemaan vikasietoisuutta ja kuormantasauksia.

Kustannusten optimointivinkkejä

Modalin sekuntiperusteinen laskutus on jo tehokkaampaa kuin tuntihinnoittelu, mutta voit puristaa siitä vielä enemmän:

1. Käytä FP8-kvantisointia

FP8-mallit käyttävät suunnilleen puolet vähemmän VRAM-muistia kuin niiden fp16-vastineet. Qwen3-8B FP8-muodossa mahtuu yhdelle H100:lle, kun taas fp16-versio tarvitsee suurimman osan kyseisen GPU:n 80 GB:n muistista. Vähemmän VRAMia tarkoittaa, että voit käyttää edullisempia GPU:ita (A100 40GB, L40S) pienemmille malleille.

2. Säädä alasajoaikaa

scaledown_window-parametri ohjaa, kuinka kauan kontti pysyy lämpimänä viimeisen pyynnön jälkeen:

3. Valitse oikea GPU

Älä oletusarvoisesti valitse H100:aa. Pienemmät mallit eivät tarvitse sitä:

4. Ota kehotevälimuisti käyttöön

Jos työkuormasi sisältävät toistuvia järjestelmäkehoteita tai jaettuja etuliitteitä, vLLM:n automaattinen etuliitevälimuisti voi vähentää merkittävästi viivettä ja laskentatehon tarvetta. Voit ottaa sen käyttöön lisäämällä --enable-prefix-caching vLLM:n serve-komentoon. Jos haluat tutkia syvemmin, miten välimuistointi toimii eri palveluntarjoajilla, katso LLM-kehotevälimuistioppaamme.

5. Käytä --enforce-eager kylmäkäynnistysten optimointiin

Oletusarvoisesti vLLM kääntää CUDA-graafit käynnistyksen yhteydessä, mikä vie 1–3 ylimääräistä minuuttia. --enforce-eager-lippu ohittaa tämän kääntämisen. Kauppaat noin 10–15 % huippuläpäisykyvystä huomattavasti nopeampiin kylmäkäynnistyksiin. Piikikkäissä työkuormissa, joissa viive on tärkeämpää kuin raaka läpäisykyky, se on lähes aina oikea valinta.

Menemällä pidemmälle: Hienosäädetyt mallit

Kun olet tottunut ottamaan perusmalleja käyttöön, luonnollinen seuraava askel on oman hienosäädetyn version käyttöönotto. Työnkulku on identtinen; osoitat vain MODEL_NAME:n Hugging Face -repoosi tai Modal-volyymiin, joka sisältää hienosäädetty painot.

Modal tukee myös hienosäätöajojen suorittamista suoraan sen GPU:illa. Voit kouluttaa LoRA-sovitteen Modalissa, tallentaa sen volyymiin ja ottaa yhdistetyn mallin käyttöön poistumatta alustalta. LLM-hienosäätöoppaamme käsittelee koulutuspuolta syvällisesti.

Koko app.py

Tässä on koko käyttöönottoskripti yhtenä kopioi-liitä-valmiina lohkona:

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)

Ota käyttöön komennolla modal deploy app.py, vaihda MODEL_NAME mihin tahansa Hugging Face -malliin, ja olet live-tilassa.

Usein kysytyt kysymykset

Paljonko LLM:n ajaminen Modalilla maksaa?

Se riippuu GPU:sta ja siitä, kuinka kauan päätepisteesi pysyy lämpimänä. Qwen3-4B H100:lla maksaa noin 3,95 $/h aktiivisesta käytöstä. Nollaan skaalautumisella ja 15 minuutin alasajoajalla kevyesti käytetty päätepiste voi maksaa 5–15 $/kk. 30 $ kuukausittainen ilmainen luotto kattaa paljon kokeiluja.

Skaalautuuko Modal nollaan?

Kyllä, se on yksi sen tärkeimmistä myyntivalteista. Kun pyyntöjä ei saavu scaledown_window-ajan aikana, kontti sammuu ja lopetat maksamisen. Seuraava pyyntö laukaisee kylmäkäynnistyksen (tyypillisesti 2–10 sekuntia riippuen mallin koosta ja siitä, käytätkö --enforce-eager-lippua).

Voinko ottaa Llama 3.1:n tai Mistralin käyttöön Modalissa?

Ehdottomasti. Vaihda MODEL_NAME-vakio mihin tahansa vLLM:n tukemaan malliin: meta-llama/Llama-3.1-8B-Instruct, mistralai/Mistral-7B-Instruct-v0.3 tai satoihin muihin Hugging Facessa. 70B+ malleja varten vaihda N_GPU:n arvoksi 2 ja käytä gpu="H100:2".

Miten kylmäkäynnistykset vertautuvat RunPodiin?

Modalin kylmäkäynnistykset ovat tyypillisesti 2–4 sekuntia itse kontille plus mallin latausaika. Kun mallipainot on välimuistissa Volyymissä ja --enforce-eager on käytössä, 7–8B mallin kokonaisaika on 10–30 sekuntia. RunPodin serverless-kylmäkäynnistykset vaihtelevat alle 200 ms:sta (välimuistissa) 6–12 sekuntiin suuremmille konteille, vaikka niiden always-on-malli välttää kylmäkäynnistykset kokonaan.

Onko Modalin vLLM-päätepiste todella OpenAI-yhteensopiva?

Kyllä. vLLM toteuttaa samat /v1/chat/completions, /v1/completions ja /v1/models -päätepisteet, joita OpenAI käyttää. Voit osoittaa virallisen openai Python SDK:n Modal-URL-osoitteeseesi, ja se toimii out-of-the-box. Streamaus, funktiokutsut ja JSON-tila toimivat kaikki.

Tarvitsenko GPU:n paikallisella koneellani?

Et. Paikallinen koneesi ajaa vain Modal CLI:ä. Kaikki GPU-työ tapahtuu Modalin pilvi-infrastruktuurissa. Voit ottaa palvelun käyttöön jopa Chromebookilta, jos haluat.

Miten lisään todennuksen päätepisteeseeni?

Modalin web-päätepisteet ovat julkisia oletusarvoisesti. Tuotantoa varten lisää yksinkertainen API-avaimen tarkistus sovelluskoodiisi tai käytä Modalin sisäänrakennettuja web-todennusominaisuuksia. Voit myös asentaa välityspalvelinkerros LLM-gatewayn avulla, joka hoitaa todennuksen, nopeudenrajoituksen ja reitityksen.

Mikä on ero modal serve:n ja modal deploy:n välillä?

modal serve luo väliaikaisen päätepisteen, joka lataa koodin uudelleen, kun muokkaat sitä; täydellinen kehitykseen. modal deploy luo pysyvän, tuotantovalmiin päätepisteen vakaalla URL-osoitteella. Käytä serve:ä iteroinnin aikana ja deploy:tä, kun olet valmis julkaisemaan.

Voinko käyttää SGLangia vLLM:n sijaan?

Kyllä. Modalin dokumentaatio sisältää SGLang-esimerkkejä vLLM:n rinnalla. SGLangilla on yleensä pienempi overhead dekoodauspainotteisissa työkuormissa ja pienemmissä malleissa. vLLM on yleensä parempi sekatyökuormissa, joissa on raskas esitäyttö (prefill). Molemmat tuottavat OpenAI-yhteensopivia päätepisteitä.

Miten tämä vertautuu käyttöönottoon Railwayssa tai Renderissä?

Alustat kuten Railway, Render ja Fly.io ovat erinomaisia web-sovelluksiin, mutta ne eivät tarjoa GPU-instansseja. Modal on rakennettu nimenomaan GPU-työkuormille sekuntiperusteisella laskutuksella ja automaattisella skaalauksella. Jos tarvitset LLM-palvelua, Modal (tai RunPod) on oikea työkalu; perinteiset PaaS-alustat eivät pysty siihen.

Lähteet

• Modal Documentation: High-Performance LLM Inference
• Modal: How to Deploy vLLM
• Modal Pricing
• vLLM OpenAI-Compatible Server Documentation
• Modal vLLM Inference Example (GitHub)