Exécutez vLLM en local et accédez-y depuis n’importe quel endroit via Tokios.

Cette page vous guide dans toute la procédure : de l’installation initiale de vLLM sur votre machine dotée d’une carte graphique jusqu’à la mise en place d’un point de terminaison API authentifié et accessible à distance — en environ 5 minutes seulement. Votre modèle demeure sur votre propre matériel, et vos requêtes ne transitent jamais par un serveur d’inférence tiers.

Votre vLLM fonctionne déjà ? Allez directement à Étape 3 : Installation du connecteur Tokios. Si vous préférez une version condensée, consultez Accès à vLLM à distance.

Prérequis

Avant de commencer, assurez-vous de disposer de :

1 Une carte graphique NVIDIA compatible CUDA (RTX 3090, 4090, A100 ou DGX Spark).
CUDA 12.1+ installé (exécutez nvidia-smi pour vérifier).
Python 3.9–3.12 avec le paquet pip disponible.
Un compte Tokios account (l’inscription est gratuite).

Pour les configurations multi‑GPU, consultez Le parallélisme tensoriel ci‑dessous.

Étape 1 : Installez et lancez vLLM

Installez vLLM via pip :

pip install vllm

Démarrez le serveur compatible OpenAI. Assurez-vous qu’il reste lié à 127.0.0.1 — ne le liez pas à une plage plus large :

vllm serve mistralai/Mistral-7B-Instruct-v0.2 \
  --host 127.0.0.1 \
  --port 8000

Lors de la première exécution, vLLM télécharge les poids du modèle, les charge en mémoire GPU et démarre un serveur HTTP compatible OpenAI sur http://127.0.0.1:8000.

Vérifiez que le serveur fonctionne bien

Dans un autre terminal :

curl http://127.0.0.1:8000/v1/models

Vous devriez voir votre modèle apparaître dans la liste.

Configurations de lancement courantes

Choisissez les paramètres adaptés à votre matériel :

vllm serve mistralai/Mistral-7B-Instruct-v0.2 \
  --host 127.0.0.1 \
  --port 8000 \
  --gpu-memory-utilization 0.90 \
  --max-model-len 8192

vllm serve Qwen/Qwen2.5-72B-Instruct-AWQ \
  --host 127.0.0.1 \
  --port 8000 \
  --quantization awq \
  --gpu-memory-utilization 0.90 \
  --max-model-len 4096

vllm serve nvidia/Qwen3.5-35B-A3B-NVFP4 \
  --host 127.0.0.1 \
  --port 8000 \
  --gpu-memory-utilization 0.85 \
  --max-model-len 8192

vllm serve meta-llama/Llama-3-8B-Instruct \
  --host 127.0.0.1 \
  --port 8000 \
  --kv-cache-dtype fp8 \
  --max-model-len 16384

--max-model-len détermine la quantité de mémoire GPU que vLLM alloue au cache KV. Commencez avec une valeur modérée (4096 ou 8192) puis augmentez-la après avoir vérifié que le modèle se charge sans dépassement de mémoire. Consultez Le cache KV et le contexte pour en savoir plus sur le calcul de la consommation mémoire.

Utilisation de plusieurs GPU : parallélisme tensoriel

Pour les modèles ne tenant pas sur un seul GPU 1, utilisez le parallélisme tensoriel sur plusieurs GPU d’une même machine :

# 2 GPUs, tensor parallel
vllm serve meta-llama/Llama-3-70B-Instruct \
  --host 127.0.0.1 \
  --port 8000 \
  --tensor-parallel-size 2 \
  --gpu-memory-utilization 0.90

Pour un déploiement multi-GPU sur un seul nœud, le parallélisme tensoriel est à privilégier sur le parallélisme en pipeline, car il assure une meilleure utilisation de la bande passante durant la phase de décodage.

Windows (WSL2)

vLLM ne fonctionne pas nativement sous Windows. Il convient d’utiliser Docker dans WSL2 en activant le transfert direct du GPU.

# docker-compose.yml
services:
  vllm:
    image: vllm/vllm-openai:latest
    runtime: nvidia
    ports:
      - "127.0.0.1:8000:8000"
    volumes:
      - ~/.cache/huggingface:/root/.cache/huggingface
    environment:
      - NVIDIA_VISIBLE_DEVICES=all
    command: >
      --model mistralai/Mistral-7B-Instruct-v0.2
      --host 0.0.0.0
      --port 8000
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

docker compose up

Étape 2 : Effectuer un test en local

Avant de configurer l’accès à distance, il faut vérifier que vLLM renvoie bien une réponse correcte.

curl http://127.0.0.1:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.2",
    "messages": [{"role": "user", "content": "Write hello world in Python"}],
    "max_tokens": 100
  }'

Vous devriez obtenir une réponse de complétion de chat valide.

Étape 3 : Installer le connecteur Tokios

Ce connecteur établit une connexion sortante depuis votre machine vers https://api.tokios.com. Aucun port entrant n’est ouvert, il n’est pas nécessaire de configurer de redirection de port ni de créer de enregistrement DNS. Connectez-vous à tokios.com/console, ouvrez l’onglet Setup puis cliquez sur Start pairing. Tokios affichera un code d’appairage unique, tel que TKS-XXXX-XXXX, valable pendant environ 15 minutes. Saisissez la commande d’installation sur la machine où vLLM est exécuté.

Windows

irm https://tokios.com/downloads/install/windows | iex; tokios-install -Code 'TKS-XXXX-XXXX'

macOS

curl -fsSL https://tokios.com/downloads/install/macos | sh -s -- --code TKS-XXXX-XXXX

Linux

curl -fsSL https://tokios.com/downloads/install/linux | sh -s -- --code TKS-XXXX-XXXX

Avez-vous déjà installé tokios-connector ? Vous pouvez alors transmettre directement le code requis.

tokios-connector TKS-XXXX-XXXX

De retour dans la console, cliquez sur Approve dans l’onglet Setup ou Connectors. Le jeton du connecteur (ct-tok-…) est transmis via le tunnel après approbation ; vous ne le verrez jamais à l’écran ni ne devrez le coller dans un fichier.

Étape 4 : Dirigez le connecteur vers vLLM

Le serveur de vLLM compatible OpenAI utilise exactement le format attendu par Tokios. Pour un seul modèle, l’assistant de configuration de la console sélectionne automatiquement http://127.0.0.1:8000/v1. Pour plusieurs modèles ou une configuration personnalisée, créez un fichier tokios-connector.json :

{
  "Upstream": {
    "BaseUrl": "http://127.0.0.1:8000/v1"
  }
}

Consultez Configuration du connecteur pour connaître le format complet d’un fichier multi-modèles.

Étape 5 : Enregistrez un déploiement

Dans l’onglet Models, enregistrez votre modèle vLLM et choisissez un nom public, par exemple mistral-tunnel. Ce nom public est celui que les clients indiquent dans le champ model. Il est indépendant de l’ID de modèle local de vLLM, ce qui permet de modifier le modèle amont sans perturber les paramètres clients.

Utilisez des adaptateurs LoRA ? Lancez vLLM avec --enable-lora --lora-modules adapter1=/path/to/adapter, puis enregistrez chaque adaptateur comme un déploiement Tokios distinct. Voir Routage des modèles.

Étape 6 : Créez une clé API

Dans l’onglet Keys, cliquez sur Create key.

Vous pouvez également limiter son utilisation à certains déploiements grâce à des motifs de noms de modèles (liste séparée par des virgules ; utilisez * pour tout autoriser).
Copiez immédiatement la clé sk-tok-… : elle ne s’affiche qu’une seule fois.

Vous pouvez créer plusieurs clés API — une pour chaque membre d’équipe, agent ou environnement — et les révoquer individuellement.

Étape 7 : Effectuez la connexion depuis n’importe quel client.

Votre ID de modèle amont vLLM est désormais accessible à l’adresse https://api.tokios.com. Voici comment l’appeler :

curl https://api.tokios.com/v1/chat/completions \
  -H "Authorization: Bearer sk-tok-YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral-tunnel",
    "stream": true,
    "messages": [{"role": "user", "content": "Write hello world in Rust"}]
  }'

from openai import OpenAI

client = OpenAI(
    base_url="https://api.tokios.com/v1",
    api_key="sk-tok-YOUR_KEY",
)

response = client.chat.completions.create(
    model="mistral-tunnel",
    messages=[{"role": "user", "content": "Write hello world in Rust"}],
    stream=True,
)

for chunk in response:
    print(chunk.choices[0].delta.content or "", end="")

export ANTHROPIC_BASE_URL=https://api.tokios.com
export ANTHROPIC_API_KEY=sk-tok-YOUR_KEY
claude --model mistral-tunnel

export OPENAI_API_KEY=sk-tok-YOUR_KEY
aider --openai-api-base https://api.tokios.com/v1 \
      --model openai/mistral-tunnel

{
  "baseURL": "https://api.tokios.com/v1",
  "apiKey": "sk-tok-YOUR_KEY",
  "model": "mistral-tunnel"
}

Le champ model doit toujours contenir le nom de votre déploiement enregistré (mistral-tunnel), et non l’ID de modèle local fourni par vLLM.

Modèle de sécurité : tunnel sortant uniquement.

Voici ce qui distingue ce système des tunnels SSH, du redirectionnement de ports ou de Tailscale :

Your GPU machine                  api.tokios.com               Remote client
──────────────                    ──────────────               ─────────────
vLLM ─┐                                                        sk-tok-… key
  (localhost:8000)                                               │
       ├─ connector ──► outbound TLS tunnel ──► gateway ──────► HTTPS
       │  (no inbound     (initiates             (auth +       request
       │   port open)      connection)            routing)
       └─ nothing listens
          on any port

Propriété	Votre configuration
Ouverture des ports entrants	0
Nécessité d’une adresse IP publique	Non
Fonctionne même derrière un CGNAT.	Oui
Méthode d’authentification	`sk-tok-…` jeton Bearer par requête
Définition de portée des clés	Par déploiement et par utilisateur
Chiffrement	Utilisation du protocole TLS de bout en bout
Diffusion en continu via SSE	Fonctionnement natif sans mise en tampon

Votre processus vLLM ne subit aucune modification. Il reste sur 127.0.0.1:8000, inaccessible depuis l’extérieur. Le connecteur est le seul élément capable d’y accéder, et il ne lance que des connexions sortantes.

Vous pouvez conserver le paramètre --api-key de vLLM afin d’assurer une défense en profondeur sur la connexion en boucle locale entre le connecteur et vLLM. Les requêtes clients transmises via Tokios sont authentifiées à l’aide de votre clé API sk-tok-… ; seul le connecteur est autorisé à accéder à 127.0.0.1:8000.

Questions fréquentes

Le streaming fonctionne-t-il ?

Oui. Configurez "stream": true et Tokios renvoie des événements envoyés par le serveur standard (SSE) au format OpenAI ou Anthropic, selon l’interface API que vous avez utilisée.

Puis-je servir plusieurs modèles ?

Oui. Ajoutez d’autres déploiements dans l’onglet Models, ou utilisez un fichier de configuration tokios-connector.json pour définir plusieurs ID de modèles amont et routes. Consultez Configuration du connecteur.

Puis-je autoriser l’accès à mes collègues ?

Oui. Créez une clé API distincte sk-tok-… pour chaque collègue dans l’onglet Keys. Limitez chaque clé aux déploiements requis. La révocation d’une clé annule immédiatement l’accès.

Que se passe-t-il si vLLM redémarre ?

Le connecteur se reconnecte automatiquement à vLLM dès son redémarrage. Aucune intervention manuelle n’est nécessaire : il suffit de relancer vLLM pour que l’endpoint se rétablisse.

Cela fonctionne-t-il sous Windows ?

Oui. Exécutez vLLM dans WSL2 via Docker (voir la configuration WSL2 ci-dessus), puis installez le connecteur Tokios sur l’hôte Windows ou dans WSL2 — les deux options sont valables.

Votre vLLM, accessible de n’importe où

vLLM continue de fonctionner tel quel : sur localhost, sur votre GPU, sans aucun port entrant requis. Le connecteur ne fait que des appels sortants. Toutes les autres fonctions — authentification, routage, streaming, gestion des clés — se résument à un seul endpoint que vous pouvez appeler depuis n’importe quel appareil, collègue ou agent disposant d’une clé.

Démarrage rapide

Associez un connecteur et enregistrez votre premier modèle dans un processus complet.

Clés API

Créez, définissez les autorisations et renouvelez les sk-tok-… clés API pour vos collègues et agents.

Clients compatibles

39 clients confirmés comme fonctionnels — agents de codage, applications de chat, SDK.

Comparaison des solutions d’accès à distance

Comparaison de Tokios avec Tailscale, Cloudflare Tunnel et les tunnels SSH.

Matériel et compatibilité

Servir et connecter votre runtime

Connecter un client ou une app

Comparer

Exécutez vLLM en local et accédez-y depuis n’importe quel endroit via Tokios.

Prérequis

Étape 1 : Installez et lancez vLLM

Vérifiez que le serveur fonctionne bien

Configurations de lancement courantes

Utilisation de plusieurs GPU : parallélisme tensoriel

Windows (WSL2)

Étape 2 : Effectuer un test en local

Étape 3 : Installer le connecteur Tokios

Étape 4 : Dirigez le connecteur vers vLLM

Étape 5 : Enregistrez un déploiement

Étape 6 : Créez une clé API

Étape 7 : Effectuez la connexion depuis n’importe quel client.

Modèle de sécurité : tunnel sortant uniquement.

Questions fréquentes

Votre vLLM, accessible de n’importe où

Démarrage rapide

Clés API

Clients compatibles

Comparaison des solutions d’accès à distance

​Prérequis

​Étape 1 : Installez et lancez vLLM

​Vérifiez que le serveur fonctionne bien

​Configurations de lancement courantes

​Utilisation de plusieurs GPU : parallélisme tensoriel

​Windows (WSL2)

​Étape 2 : Effectuer un test en local

​Étape 3 : Installer le connecteur Tokios

​Étape 4 : Dirigez le connecteur vers vLLM

​Étape 5 : Enregistrez un déploiement

​Étape 6 : Créez une clé API

​Étape 7 : Effectuez la connexion depuis n’importe quel client.

​Modèle de sécurité : tunnel sortant uniquement.

​Questions fréquentes

​Votre vLLM, accessible de n’importe où

Démarrage rapide

Clés API

Clients compatibles

Comparaison des solutions d’accès à distance

Prérequis

Étape 1 : Installez et lancez vLLM

Vérifiez que le serveur fonctionne bien

Configurations de lancement courantes

Utilisation de plusieurs GPU : parallélisme tensoriel

Windows (WSL2)

Étape 2 : Effectuer un test en local

Étape 3 : Installer le connecteur Tokios

Étape 4 : Dirigez le connecteur vers vLLM

Étape 5 : Enregistrez un déploiement

Étape 6 : Créez une clé API

Étape 7 : Effectuez la connexion depuis n’importe quel client.

Modèle de sécurité : tunnel sortant uniquement.

Questions fréquentes

Votre vLLM, accessible de n’importe où