SSD Nodes Learn Hosting plans →
Guides Matt ConnorPar Matt Connor

Exécuter GLM sur un VPS avec Ollama : quel modèle ?

GLM 5.2 est cloud only dans Ollama : découvrez le modèle GLM adapté à un VPS et la RAM requise pour chaque quantisation sur votre serveur.

Pouvez-vous exécuter GLM 5.2 sur un VPS ?

Oui, mais pas avec un tag officiel d’Ollama. Au 25 octobre 2026, GLM 5.2 dans la bibliothèque Ollama porte exactement un tag, glm-5.2:cloud. Un tag :cloud s’exécute sur les serveurs d’Ollama. Votre serveur envoie le prompt et reçoit les tokens ; les poids ne sont donc jamais écrits sur votre disque. Z.ai publie les poids et documente le déploiement local avec SGLang et vLLM. Le dépôt de poids de Z.ai indique environ 753 milliards de paramètres pour le modèle. Avec quatre bits par paramètre et 753 milliards de paramètres, les poids occupent environ 377 Go. Ce calcul ne tient pas compte du contexte, des activations ni du système d’exploitation. Les offres VPS publiées dépassent cette capacité mémoire : Paragon propose son E-48 avec 512 Go de RAM pour 580 € par mois.

Le modèle GLM qui tient sur un serveur loué est glm-4.7-flash. Ses poids téléchargeables sont publiés dans 4 tags. Il s’agit d’un modèle mixture-of-experts : seule une petite partie du réseau s’exécute pour chaque token. Z.ai le décrit comme un modèle 30B-A3B : 30 milliards de paramètres au total, dont environ 3 milliards sont actifs pour chaque token. Ce guide répond donc à la question que vous pouvez réellement mettre en œuvre. Épinglez un tag, dimensionnez le serveur, mesurez votre propre vitesse et gardez l’endpoint privé.

Vérifiez le tag avant de copier une commande, y compris celles de ce guide. La bibliothèque Ollama peut changer sans préavis. Ouvrez la liste des tags de glm-4.7-flash et confirmez que le tag existe toujours. Si une version plus récente de GLM avec des poids locaux est disponible, utilisez-la de préférence et notez le tag que vous avez réellement testé.

Si vous voulez malgré tout utiliser GLM 5.2, ollama run glm-5.2:cloud fonctionne après ollama signin et se comporte, côté client, comme n’importe quel autre modèle Ollama. Comprenez ce que cela implique : le prompt quitte votre serveur. Si vous hébergez vous-même le modèle parce que les données doivent rester sur votre machine, un tag :cloud ne répond pas à cette exigence.

Quels tags GLM existent et lequel figer

Deux entrées GLM officielles sont importantes ici. glm-5.2 est uniquement disponible dans le cloud de la bibliothèque Ollama. glm-4.7-flash est la version locale. Voici ses tags publiés, avec la taille de téléchargement indiquée par Ollama pour chacun. Si vous avez déjà utilisé glm-5.1, notez qu’Ollama l’a retiré le 25 septembre 2026 et que sa page de bibliothèque ne répertorie désormais aucun modèle. Z.ai publie toujours les poids de GLM-5.1 et documente le déploiement local. Le retrait par Ollama ne rend donc pas le modèle indisponible ailleurs.

Graphiqueglm-4.7-flash tags in Ollama's library, checked 2026-10-25
Les données de ce graphique
[
  {
    "label": "q4_K_M",
    "download_gb": 19
  },
  {
    "label": "latest",
    "download_gb": 19
  },
  {
    "label": "q8_0",
    "download_gb": 32
  },
  {
    "label": "bf16",
    "download_gb": 60
  }
]

Ces valeurs sont celles publiées sur la page de la bibliothèque, et non des mesures. latest et q4_K_M sont tous deux indiqués à 19 Go. latest correspond donc actuellement au build Q4. Cela peut changer lors de toute nouvelle publication. C’est pourquoi vous ne devez jamais écrire un simple ollama pull glm-4.7-flash dans un script ou un Dockerfile. Indiquez la quantification. Le tag le plus volumineux, bf16, correspond à un téléchargement de 60 Go contenant les poids bfloat16 non quantifiés.

Une recherche dans la bibliothèque renvoie également des uploads avec un namespace et une barre oblique dans le nom, comme someuser/glm-5.2. Une barre oblique signifie qu’un compte utilisateur a publié l’élément. Il s’agit donc d’une republication communautaire, et non de l’entrée officielle. Rien ne garantit quels poids sont inclus. Traitez-la comme n’importe quel binaire non signé trouvé en ligne.

Installer Ollama et récupérer le tag exact

L’installateur Linux d’Ollama s’exécute avec une seule commande.

curl -fsSL https://ollama.com/install.sh | sh
ollama --version

L’installateur crée un service systemd qui s’exécute avec l’utilisateur ollama. Vérifiez qu’il a démarré avant de récupérer quoi que ce soit.

systemctl status ollama --no-pager

Active: active (running) indique que systemd considère le service comme actif. Cela ne confirme pas que l’API est prête ni que le port est en écoute. Vérifiez séparément l’API avec curl -fsS http://127.0.0.1:11434/api/tags à l’adresse et sur le port par défaut. Si l’unité n’existe pas, l’installateur est passé à une installation du binaire seul. La documentation Linux d’Ollama indique alors le fichier de service à créer manuellement.

La page glm-4.7-flash indique une version minimale d’Ollama. Avec un binaire plus ancien, le modèle ne s’exécute pas simplement plus lentement : Ollama le refuse. La commande pull échoue alors avec un message indiquant que le modèle nécessite une version plus récente d’Ollama. Relancez le script d’installation pour effectuer la mise à niveau. Au 2 novembre 2026, la version actuelle est 0.40.13, donc largement supérieure à cette version minimale.

Récupérez maintenant un seul tag par son nom.

ollama pull glm-4.7-flash:q4_K_M
ollama ls

ollama ls doit afficher glm-4.7-flash:q4_K_M avec une taille proche des 19 Go annoncés. Une commande pull qui échoue en cours de route ne laisse aucun modèle utilisable. Relancez donc la même commande. Avec une petite offre, vérifiez l’espace disque avant la récupération : l’installation Linux standard écrit les modèles dans /usr/share/ollama/.ollama/models, sauf si vous modifiez cet emplacement avec OLLAMA_MODELS. Vérifiez-le avec df -h /usr/share/ollama avant de commencer.

Quelle quantité de RAM nécessite chaque quantification ?

Commencez par prendre la taille du téléchargement comme valeur minimale, puis ajoutez la mémoire nécessaire. Les poids doivent rester en mémoire. Le cache KV (cache key/value) s’ajoute aux poids. Il sert au runtime à conserver les tokens déjà présents dans la conversation. Il faut également compter les buffers de calcul et la mémoire utilisée par le système d’exploitation. Une machine avec exactement 19 Go de RAM ne pourra pas exécuter le tag de 19 Go.

Il n’existe pas de coefficient unique valable dans tous les cas. Le cache KV augmente avec la longueur de contexte autorisée, et le reste varie selon les versions du runtime. Mesurez donc au lieu d’estimer. Chargez le modèle avec un prompt minimal, puis vérifiez la quantité de mémoire réservée par le serveur.

ollama run glm-4.7-flash:q4_K_M "Reply with the single word: ready"
ollama ps

ollama ps affiche le modèle chargé avec une colonne SIZE et une colonne PROCESSOR. SIZE correspond à la mémoire effectivement réservée par le runtime. C’est cette valeur qu’il faut comparer à votre capacité prévue. PROCESSOR indique où les calculs sont effectués. Ainsi, 100% CPU signifie qu’aucun GPU n’a été utilisé.

Lorsque le modèle ne tient pas en mémoire, Ollama peut renvoyer une erreur de chargement avant le début de la génération. Une forte pression sur le swap ou un arrêt par manque de mémoire sont également possibles. Consultez les journaux du service avec journalctl -u ollama --no-pager et les journaux du kernel avec journalctl -k | grep -i "out of memory". Ne partez pas du principe que toutes les erreurs de mémoire sont silencieuses.

Le passage du tag Q4 de 19 Go au tag Q8 de 32 Go est le principal levier dont vous disposez sur cette valeur. Q4 réduit légèrement la qualité des sorties. L’ampleur de cette baisse dépend de la tâche. Les sorties structurées et les longues chaînes de raisonnement sont davantage affectées qu’une conversation courante. Différences pratiques entre Q4, Q8 et FP16 mérite d’être lu avant de faire votre choix. Sur un VPS uniquement équipé d’un CPU, la quantification détermine généralement si le modèle peut s’exécuter ou non.

Ce qui se passe sur un VPS sans GPU

La plupart des offres VPS ne fournissent pas de GPU. Ollama exécute alors le modèle sur le CPU sans vous en avertir. Le résultat peut être exploitable ou non selon la charge de travail et votre patience.

L’architecture mixture-of-experts améliore la vitesse. Seuls environ 3 milliards des 30 milliards de paramètres sont utilisés pour chaque token. Les calculs nécessaires pour chaque token sont donc bien moins importants que ceux d’un modèle dense de 30B. En revanche, la mémoire nécessaire ne diminue pas. Chaque expert doit rester en mémoire, car le routeur peut sélectionner n’importe lequel d’entre eux pour le token suivant. Un serveur sans GPU a donc toujours besoin de la totalité des 19 Go ou davantage pour le tag Q4. Son débit dépend principalement de la bande passante mémoire, et non de la fréquence d’horloge.

Cela a une conséquence pratique : deux offres ayant le même nombre de cœurs et la même quantité de RAM peuvent générer du texte à des vitesses sensiblement différentes, car leurs sous-systèmes mémoire ne sont pas identiques. Une offre mutualisée ajoute une seconde variable : le temps CPU volé par un voisin bruyant se traduit par un nombre de tokens par seconde qui varie d’une heure à l’autre. C’est pourquoi aucun chiffre publié par un autre utilisateur ne permet de prédire le vôtre, et pourquoi la section suivante propose une méthode de mesure plutôt qu’un tableau de résultats.

Mesurez votre propre nombre de tokens par seconde

Le point d’accès generate d’Ollama renvoie des champs de durée dans son objet JSON final. Divisez le nombre de tokens générés par la durée de génération pour obtenir votre résultat, avec votre offre et votre invite.

sudo apt install -y jq
curl -s http://localhost:11434/api/generate -d '{
  "model": "glm-4.7-flash:q4_K_M",
  "prompt": "Write a 200 word explanation of how TCP congestion control works.",
  "stream": false,
  "options": {"num_ctx": 8192}
}' | jq '{
  tokens: .eval_count,
  tokens_per_second: (.eval_count / .eval_duration * 1e9),
  prompt_seconds: (.prompt_eval_duration / 1e9),
  load_seconds: (.load_duration / 1e9)
}'

eval_count correspond au nombre de tokens générés et eval_duration à la durée, en nanosecondes, nécessaire pour les générer. eval_count / eval_duration * 1e9 correspond donc au nombre de tokens par seconde. prompt_eval_duration couvre la lecture de votre invite, c’est-à-dire le délai que vous percevez avant l’apparition du premier token. load_duration correspond au temps nécessaire pour charger le modèle depuis le disque. Cette valeur est donc élevée lors du premier appel après un redémarrage et presque nulle lors du suivant.

Exécutez la commande trois fois et conservez les deuxième et troisième résultats, car le premier inclut ce chargement. Exécutez-la ensuite avec une invite beaucoup plus longue, car le traitement de l’invite évolue avec la longueur de l’entrée, tandis que la vitesse de génération ne change pas. Notez les valeurs à côté du nom de votre offre et de votre quantification. Cette mesure est plus utile que n’importe quel benchmark que vous pourriez consulter, car elle a été réalisée sur le matériel que vous payez.

La longueur du contexte multiplie la mémoire

Sur une machine sans GPU, ou avec moins de 24 GiB de VRAM, Ollama utilise par défaut un contexte de 4096 tokens. Le modèle en annonce un bien plus grand, de 198K tokens pour glm-4.7-flash, mais cette valeur n’est pas utilisée par défaut et son activation n’est pas gratuite.

Le cache KV contient un vecteur de clés et un vecteur de valeurs pour chaque token, dans chaque couche. Sa taille augmente linéairement avec le nombre de tokens autorisés. Passer de 4096 à 32768 tokens multiplie le contexte par huit, et donc le cache KV environ par huit. Sur une machine dimensionnée pour contenir tout juste les poids, cette allocation supplémentaire suffit à provoquer l’utilisation du swap. C’est pourquoi une machine qui traitait correctement les requêtes courtes se met soudainement à fonctionner très lentement lorsqu’un utilisateur colle un long document. Si vous avez besoin d’un contexte plus long sur la même machine, stocker le cache KV en q8_0 plutôt qu’en f16 réduit environ de moitié cette allocation sans modifier les poids. La FAQ d’Ollama indique que q8_0 utilise environ deux fois moins de mémoire que f16, qui est la valeur par défaut pour OLLAMA_KV_CACHE_TYPE. Le cache quantifié ne s’applique que lorsque flash attention est activé. Ollama active automatiquement flash attention lorsque le backend et les périphériques le prennent en charge, et OLLAMA_FLASH_ATTENTION=1 force son activation.

Définissez cette valeur pour chaque requête avec num_ctx dans l’objet d’options, comme dans la commande curl ci-dessus, ou modifiez la valeur par défaut du serveur.

sudo install -d -m 755 /etc/systemd/system/ollama.service.d
printf '[Service]\nEnvironment="OLLAMA_CONTEXT_LENGTH=16384"\n' \
  | sudo tee /etc/systemd/system/ollama.service.d/override.conf
sudo systemctl daemon-reload
sudo systemctl restart ollama
systemctl show ollama --property=Environment

La dernière commande doit afficher votre valeur OLLAMA_CONTEXT_LENGTH. Si elle affiche une valeur Environment= vide, le fichier override se trouve dans le mauvais répertoire ou le rechargement n’a pas été effectué. Après le prochain chargement du modèle, ollama ps doit afficher une valeur SIZE nettement plus élevée que celle observée avec 4096. Augmentez cette valeur par étapes et surveillez ce nombre à chaque fois. Définir la longueur du contexte d’Ollama avec num_ctx explique comment ce paramètre interagit avec keep-alive et les requêtes parallèles, qui multiplient tous deux le même coût. Si plusieurs clients doivent utiliser le serveur, définissez les limites de concurrence en même temps que le contexte, car chaque slot parallèle possède son propre cache KV et le paramètre de file d’attente détermine si une deuxième requête attend ou est refusée immédiatement.

Quand l’API coûte moins cher que le serveur

L’auto-hébergement n’est pas automatiquement moins cher. Pour cette famille de modèles, les tarifs publics le montrent particulièrement clairement.

GraphiqueZ.ai published list prices per million tokens, checked 2026-10-25
Les données de ce graphique
[
  {
    "label": "GLM-5.2 input",
    "usd_per_million_tokens": 1.4
  },
  {
    "label": "GLM-5.2 output",
    "usd_per_million_tokens": 4.4
  },
  {
    "label": "GLM-4.7-Flash input",
    "usd_per_million_tokens": 0
  },
  {
    "label": "GLM-4.7-Flash output",
    "usd_per_million_tokens": 0
  }
]

Au 25 octobre 2026, Z.ai affiche GLM-5.2 à $1.4 par million de tokens d’entrée et à $4.4 par million de tokens de sortie. Le fournisseur affiche GLM-4.7-Flash, le modèle utilisé localement dans ce guide, à $0 dans les deux sens. Ces tarifs sont publics et peuvent changer. Consultez donc la page actuelle avant d’établir un budget avec l’un ou l’autre.

L’argument financier en faveur de l’auto-hébergement glm-4.7-flash est donc faible actuellement. Un VPS doté de suffisamment de RAM coûte réellement de l’argent chaque mois, tandis que l’éditeur fournit le même modèle gratuitement. En l’exécutant vous-même, vous obtenez autre chose : vos prompts restent sur une machine que vous contrôlez, et la version du modèle ne change jamais sauf si vous la modifiez. Ce sont de bonnes raisons d’opter pour l’auto-hébergement. Pour ce modèle et à ces tarifs, le coût n’en est pas une.

Le calcul change lorsque le modèle voulu n’est pas gratuit ou lorsque vos données ne peuvent légalement pas sortir de votre réseau. Le seuil de rentabilité entre un GPU VPS et les tokens d’API détaille ce calcul en nommant chaque variable. Si vous êtes encore en train de choisir la machine, ce que coûte réellement un VPS par mois constitue l’autre moitié de la somme.

Conserver le point de terminaison sur localhost

C’est l’étape que l’on oublie souvent, alors que c’est la plus importante.

Par défaut, Ollama se lie à 127.0.0.1 sur le port 11434. Il n’est donc accessible que depuis le serveur lui-même. Vérifiez ce point sur votre serveur au lieu de le supposer.

ss -ltnp | grep 11434

Vous devez voir 127.0.0.1:11434. Si vous voyez 0.0.0.0:11434 ou *:11434, cela signifie que l’API écoute sur toutes les interfaces, y compris l’interface publique.

C’est important, car l’API locale d’Ollama n’exige aucune authentification par défaut. Il n’y a ni mot de passe, ni token, ni allowlist. Toute personne pouvant atteindre le port 11434 peut lister vos modèles, lancer des générations sur le matériel que vous financez, télécharger de nouveaux modèles jusqu’à remplir votre disque et supprimer ceux que vous possédez. Le port 11434 est le port par défaut connu ; OLLAMA_HOST permet de modifier à la fois l’adresse d’écoute et le port.

Ne définissez pas OLLAMA_HOST=0.0.0.0. Cette variable modifie l’adresse sur laquelle Ollama se lie. De nombreux tutoriels la recommandent lorsque le client de votre laptop ne peut pas se connecter. Ce n’est pas la bonne solution. Transférez plutôt le port.

ssh -N -L 11434:127.0.0.1:11434 you@your-server

SSH écoute sur le port 11434 de votre laptop et transfère chaque connexion vers 127.0.0.1:11434 tel qu’il est vu depuis le serveur. C’est l’adresse sur laquelle Ollama écoute déjà par défaut. Le tunnel ne nécessite donc aucune modification de OLLAMA_HOST, tout client configuré pour http://localhost:11434 continue de fonctionner sans changement et rien de nouveau n’est exposé. Pour plusieurs personnes ou plusieurs machines, placez le serveur sur un réseau de tunnel privé et liez Ollama à l’adresse du tunnel, jamais à 0.0.0.0.

Vérifiez le résultat depuis un autre emplacement que le serveur. Depuis votre laptop, avec le tunnel SSH fermé :

curl -m 5 http://your-server-ip:11434/api/tags

curl: (28) Connection timed out ou curl: (7) Failed to connect est le résultat attendu. Une liste JSON de vos modèles signifie que le port est ouvert sur Internet et qu’il faut corriger le problème immédiatement. Le firewall réseau de votre fournisseur est un contrôle distinct de celui qui s’exécute sur le serveur. Vérifiez donc les deux. La question plus générale de la sécurité de l’hébergement VPS couvre le reste des mesures de base pour une machine que vous laissez allumée.

Si glm-4.7-flash reste trop volumineux

Lorsque le tag Q4 ne tient pas dans votre offre, il faut choisir un modèle plus petit, pas réduire le contexte. Réduire le contexte pour faire tenir le modèle donne un modèle qui se charge, puis échoue dès la première invite longue. Qwen 3 en 8B et 27B sur un VPS suit la même procédure d’installation avec des tailles adaptées aux serveurs modestes, tandis que le guide général pour auto-héberger un LLM avec Ollama sur un VPS couvre les éléments qui restent identiques quel que soit le modèle choisi. Quel que soit votre choix, figez le tag, mesurez les performances sur votre propre offre et laissez le endpoint en écoute sur loopback.

FAQ

GLM 5.2 peut-il fonctionner localement sur un VPS ?

Oui, avec les poids publiés par Z.ai et un runtime compatible comme SGLang ou vLLM. Au 25 octobre 2026, GLM 5.2 existe dans la bibliothèque Ollama uniquement sous la forme de glm-5.2:cloud, un tag qui s’exécute sur l’infrastructure d’Ollama et qui nécessite ollama signin avant de fonctionner. Le dépôt de poids de Z.ai indique environ 753 milliards de paramètres pour le modèle. Même avec quatre bits par paramètre, les poids seuls occupent donc environ 377 GB. Les offres de VPS à grande capacité mémoire dépassent cette valeur, notamment l’E-48 de 512 GB de Paragon. Vous devez toutefois prévoir de l’espace pour le runtime et le contexte. Le modèle GLM plus petit avec des poids téléchargeables utilisé dans ce guide est glm-4.7-flash.

De quelle quantité de RAM glm-4.7-flash a-t-il besoin ?

Considérez la taille de téléchargement du tag comme un minimum, puis ajoutez l’espace nécessaire au cache KV et au système d’exploitation. Ollama indique 19 GB pour le tag Q4, 32 GB pour Q8 et 60 GB pour le tag bfloat16. Aucun coefficient fixe ne convient à tous les cas, car la taille du cache KV augmente avec la longueur de contexte configurée. Chargez le modèle, exécutez ollama ps, puis consultez la colonne SIZE pour connaître la valeur réelle sur votre machine.

Comment mesurer le nombre de tokens par seconde sur mon propre VPS ?

Envoyez une requête à http://localhost:11434/api/generate avec "stream": false, puis lisez eval_count et eval_duration dans la réponse. Le nombre de tokens par seconde correspond à eval_count / eval_duration * 1e9, car eval_duration est exprimé en nanosecondes. Ignorez la première exécution, car load_duration inclut alors la lecture des poids depuis le disque. Répétez aussi le test avec un prompt long, car prompt_eval_duration augmente avec la longueur de l’entrée, tandis que la vitesse de génération ne change pas.

Pourquoi ne dois-je pas définir OLLAMA_HOST sur 0.0.0.0 ?

Parce que l’API locale d’Ollama n’exige aucune authentification par défaut. La lier à 0.0.0.0 l’expose donc sur toutes les interfaces IPv4. L’accès public dépend alors du routage et des firewalls. Toute personne qui atteint le port 11434 peut lancer des générations sur votre matériel et modifier les modèles installés. Conservez la liaison par défaut sur 127.0.0.1, vérifiez-la avec ss -ltnp | grep 11434 et accédez à l’API depuis votre ordinateur portable via un tunnel SSH tel que ssh -N -L 11434:127.0.0.1:11434 you@your-server.

Cet article vous a-t-il été utile ?