Smetti di inviare i tuoi dati: come costruire un'infrastruttura LLM privata e scalabile

Dal concetto al codice: costruire la pipeline privata

Per mantenere questo concreto, passiamo direttamente a un dispiegamento Qwen3.5-9B pronto per la produzione. Mentre i modelli 70B+ dominano i titoli di spicco, la gamma 7B - 14B è spesso il vero punto ideale di produzione: abbastanza piccolo da offrire una forte latenza su hardware come l'NVIDIA L40S, ma abbastanza capace per carichi di lavoro come chat, comprensione documentale, ragionamento visivo ed estrazione OCR.

Questo esempio mostra come appare uno stack di produzione pratico: un ambiente riproducibile, cache persistente, elasticità scalabile a zero, avviamenti a freddo più rapidi tramite snapshot di memoria e protezione endpoint più rigorosa tramite autenticazione proxy.

import socket
import subprocess

import modal

MODEL_NAME = "Qwen/Qwen3.5-27B-FP8"
FAST_BOOT = True
VLLM_PORT = 8000
GPU_TYPE = "L40S"
GPU_COUNT = 1

vllm_image = (
    # Docker image with CUDA drivers and Python 3.12.
    modal.Image.from_registry("nvidia/cuda:12.8.0-devel-ubuntu22.04", add_python="3.12")
    .entrypoint([])
    .uv_pip_install(
        # vLLM version that supports Qwen3.5-27B.
        "vllm>=0.17.0",
        # Hugging Face Hub is used to pull model weights.
        "huggingface-hub",
        # High-performance attention backend.
        "flashinfer-python",
    )
    .env(
        {
            # Speeds up model downloads from Hugging Face.
            "HF_XET_HIGH_PERFORMANCE": "1",
            # vLLM server dev mode lets you expose sleep/wake endpoints.
            "VLLM_SERVER_DEV_MODE": "1",
        }
    )
)

# Persist Hugging Face and vLLM caches across cold starts.
hf_cache_vol = modal.Volume.from_name("huggingface-cache", create_if_missing=True)
vllm_cache_vol = modal.Volume.from_name("vllm-cache", create_if_missing=True)

app = modal.App("Qwen3.5-27B")

with vllm_image.imports():
    import requests


# Wait until the local vLLM process is accepting connections.
def wait_ready(proc: subprocess.Popen):
    while True:
        try:
            socket.create_connection(("localhost", VLLM_PORT), timeout=1).close()
            return
        except OSError:
            if proc.poll() is not None:
                raise RuntimeError(f"vLLM exited with {proc.returncode}")


# Tell vLLM to enter sleep mode before snapshotting.
def vllm_sleep(level=1):
    requests.post(f"http://localhost:{VLLM_PORT}/sleep?level={level}").raise_for_status()


# Wake the vLLM server after the container is restored.
def vllm_wake_up():
    requests.post(f"http://localhost:{VLLM_PORT}/wake_up").raise_for_status()


@app.cls(
    image=vllm_image,
    gpu=f"{GPU_TYPE}:{GPU_COUNT}",
    volumes={
        "/root/.cache/huggingface": hf_cache_vol,
        "/root/.cache/vllm": vllm_cache_vol,
    },
    # How long should we wait for the container to finish?
    timeout=300,
    # How long should an idle container stay warm?
    scaledown_window=600,
    # How many replicas should we run?
    max_containers=1,
    # Crucial for a scale-to-zero architecture.
    min_containers=0,
    # Save initialized container state.
    enable_memory_snapshot=True,
    # Include GPU memory in the snapshot.
    experimental_options={"enable_gpu_snapshot": True},
)
# Tune concurrency carefully for your workload.
@modal.concurrent(max_inputs=4)
class QwenServer:
    @modal.enter(snap=True)
    def start(self):
        cmd = [
            "vllm",
            "serve",
            "--uvicorn-log-level=info",
            MODEL_NAME,
            "--host",
            "0.0.0.0",
            "--port",
            str(VLLM_PORT),
            # Adjust based on context window requirements.
            "--max-model-len",
            "65536",
            # Limits GPU memory utilization to 90% to avoid fragmentation.
            "--gpu-memory-utilization",
            "0.9",
            # enables sleep mode, which is crucial for snapshotting.
            "--enable-sleep-mode",
            # Reuses KV cache across requests that share a common prefix.
            "--enable-prefix-caching",
        ]
        # enforce-eager disables both Torch compilation and CUDA graph capture.
        # The default behavior is no-enforce-eager.
        cmd += ["--enforce-eager" if FAST_BOOT else "--no-enforce-eager"]
        self.vllm_proc = subprocess.Popen(cmd)
        wait_ready(self.vllm_proc)

        # In production, send a few warmup requests here.
        # That preserves a more ready-to-serve runtime state before sleeping.
        vllm_sleep()

    @modal.enter(snap=False)
    def restore(self):
        # Wake the sleeping server after restore.
        vllm_wake_up()
        wait_ready(self.vllm_proc)

    @modal.web_server(
        port=VLLM_PORT,
        # Allow time for model load and server boot.
        startup_timeout=600,
        # Require Modal proxy auth tokens on the endpoint.
        requires_proxy_auth=True,
    )
    def serve(self):
        pass

Tra i controlli di produzione in questo esempio, due sono particolarmente importanti:

• Gli snapshot di memoria riducono i tempi di avvio. I volumi aiutano mantenendo i pesi dei modelli vicini all'runtime, ma il server deve comunque caricare quei pesi, inizializzare vLLM e ricostruire lo stato di runtime. Gli snapshot vanno oltre ripristinando un contenitore già inizializzato, il che può rendere gli avviamenti a freddo molto più rapidi, specialmente se abbinati alla modalità sleep vLLM e a una fase di riscaldamento.
• requires_proxy_auth=Vero rafforza il controllo degli accessi. Per impostazione predefinita, un endpoint web può essere raggiungibile dall'internet pubblico. L'autenticazione proxy posiziona un gate davanti a quell'endpoint, consentendo solo ai client che presentano un ID e un segreto valido del token Modal nelle intestazioni Modal-Key e Modal-Secret . Le richieste non autorizzate vengono respinte prima ancora di arrivare all'app, il che significa che il container viene avviato solo per traffico valido invece di consumare risorse per chiamate indesiderate.

Queste scelte aiutano a trasformare una distribuzione operativa in una pronta per la produzione. I volumi riducono i download ripetuti, gli snapshot rendono gli avvii a freddo serverless molto più pratici e l'autenticazione tramite proxy aiuta a garantire che l'endpoint non sia aperto al pubblico.