Louer une H100 chez OVHcloud pour faire tourner Qwen avec Ollama et OpenCode

Récit d'un montage : un notebook IA OVHcloud avec une carte H100, Ollama installé sans droits administrateur, Qwen 3.8 en local et OpenCode branché dessus par un tunnel SSH. Avec les pièges.

Résumer avec l'IA
Que demander ?
Ouvrir dans
Rendu 3D sombre : une carte graphique à deux ventilateurs, au carénage de métal brossé, dressée à la verticale sur un socle bas ; un filet de lumière blanche part de la carte et descend jusqu’à un ordinateur portable ouvert posé au sol à droite, écran allumé et vide ; faisceau de lumière tombant du haut, reflet bordeaux au sol à gauche
Une carte graphique louée à l’heure, reliée au PC par un tunnel — Image générée par IA (Qwen-Image 2.1, ComfyUI)
Sommaire

Ce week-end, j'ai loué une carte graphique de centre de données à l'heure pour y faire tourner un modèle de langage ouvert, puis je l'ai branché à un agent de code sur mon PC. L'installation finale tient en quelques commandes. Ce récit parle surtout de celles qui ont échoué avant.

À retenir

  • Un notebook IA d'OVHcloud donne accès à une carte NVIDIA H100 de 80 Go, facturée à l'heure. C'est un conteneur avec JupyterLab, un terminal et un disque persistant, sans droits administrateur.
  • Ollama s'y installe sans ces droits, à condition de décompresser l'archive à la main. Le modèle, un Qwen 3.8 de 27 milliards de paramètres, se télécharge directement sur place.
  • Rien n'est exposé sur Internet : le PC rejoint le serveur par un tunnel SSH. La clé doit être rattachée au notebook dès sa création, ce que j'ai raté deux fois.
  • OpenCode se branche sur ce tunnel en quelques lignes de configuration. Le vrai piège est ailleurs : la fenêtre de contexte. Trop petite, elle tronque les réponses sans message d'erreur clair.
  • Tout a été monté en dialoguant avec Claude Code, qui a mené l'installation par SSH et lu les journaux à ma place.

1. Pourquoi louer plutôt qu'acheter

Mon PC portable a une carte graphique de 8 Go. C'est assez pour un petit modèle, pas pour celui que je voulais essayer : dans sa version la plus précise, le fichier de ce Qwen pèse 29,3 Go, et il faut encore de la place pour la conversation.

Acheter une carte capable de le porter n'a de sens que si l'on s'en sert tous les jours. Pour un week-end d'essais, la location à l'heure est sans concurrence. Les tarifs publics d'OVHcloud affichent, pour un notebook IA et hors taxes :

Carte Mémoire graphique Prix à l'heure
NVIDIA L4 24 Go 0,83 €
NVIDIA L40S 48 Go 1,55 €
NVIDIA H100 80 Go 3,10 €

J'ai pris la H100, par curiosité autant que par besoin : une L40S aurait suffi pour ce modèle. Une soirée de quatre heures revient à 12,40 €.

J'ai choisi le produit AI Notebooks plutôt qu'une machine virtuelle classique. On obtient en quelques minutes un JupyterLab avec un terminal, PyTorch déjà installé et un disque qui survit à l'arrêt. La contrepartie : on n'y est pas administrateur.

2. Créer le notebook, et la clé qu'il ne faut pas oublier

Le formulaire demande une région, une carte, un environnement et un éditeur. Deux réglages comptent vraiment.

Le premier est la confidentialité : laisser « accès restreint ». En accès public, toute personne qui a le lien utilise la machine.

Le second est la clé SSH, et c'est là que j'ai perdu le plus de temps au départ. Enregistrer sa clé publique dans le projet ne suffit pas : il faut aussi la sélectionner dans le formulaire au moment de créer le notebook. J'en ai créé trois avant de comprendre. Sur les deux premiers, la connexion répondait obstinément :

Permission denied (publickey).

Chercher la clé depuis le terminal du notebook ne mène à rien. Il n'y a ni serveur SSH ni fichier de clés à l'intérieur : c'est une passerelle d'OVHcloud qui contrôle l'accès, d'après la configuration du notebook. Le bon réflexe est de vérifier, dans le récapitulatif de commande, que le compteur de clés SSH n'est pas à zéro.

Dernier point à connaître avant de cliquer : le notebook ne s'arrête tout seul qu'au bout de sept jours. Une H100 oubliée allumée pendant cette durée coûte 520,80 € hors taxes.

3. Installer Ollama sans être administrateur

Ollama est le moyen le plus simple de servir un modèle ouvert : un seul programme, qui télécharge, charge et expose le modèle par une interface web. Son script d'installation officiel suppose des droits administrateur. Sur un notebook, on décompresse donc l'archive dans son dossier personnel.

Premier essai, premier échec : l'adresse de l'archive que je connaissais renvoyait une erreur 404. Ollama ne publie plus son archive Linux au format .tgz, mais au format .tar.zst. Il faut donc l'outil zstd, absent du notebook, que l'on installe par conda puisque le gestionnaire de paquets du système est hors de portée :

conda install -y -c conda-forge zstd
mkdir -p ~/ollama
curl -fsSL https://ollama.com/download/ollama-linux-amd64.tar.zst | zstd -d | tar -xf - -C ~/ollama

Le service se lance ensuite à la main. La forme ci-dessous le détache du terminal, sans quoi il s'arrête à la fermeture de la session :

setsid nohup ~/ollama/bin/ollama serve > ~/ollama.log 2>&1 < /dev/null &

Le journal confirme en quelques secondes que la carte est vue : une H100, avec 79 Go de mémoire graphique.

4. Récupérer le modèle

Le modèle est un Qwen 3.8 de 27 milliards de paramètres, au format GGUF, quantifié en 8 bits, c'est-à-dire presque sans perte par rapport à l'original. J'ai utilisé une variante communautaire publiée sur Hugging Face, dite « uncensored » ; ce n'est pas le sujet de cet article, et tout ce qui suit vaut pour n'importe quel modèle au même format.

Ollama sait télécharger directement depuis Hugging Face. Deux pièges m'attendaient.

Le dépôt que j'utilisais sur mon PC avait été renommé. Hugging Face ne répond pas « introuvable » dans ce cas, mais ceci, qui oriente vers une fausse piste :

Error: pull model manifest: 401: {"error":"Invalid username or password."}

Une fois le bon dépôt trouvé, Ollama a refusé le nom de la version que je voulais : The specified tag is not a valid quantization scheme. L'auteur utilise un suffixe maison que le téléchargement automatique ne reconnaît pas.

La solution qui marche toujours est de télécharger le fichier soi-même, puis de le déclarer à Ollama par un Modelfile de deux lignes :

cd ~/gguf
curl -L -O <adresse du fichier .gguf sur Hugging Face>
printf 'FROM ./<nom du fichier>.gguf\nPARAMETER num_ctx 32768\n' > Modelfile
~/ollama/bin/ollama create qwen38 -f Modelfile

Depuis un centre de données, les 29 Go arrivent en quelques minutes. Premier test : le modèle répond en français, entièrement sur la carte, à 28 jetons par seconde. Le premier chargement prend une minute et demie, le temps de lire le fichier sur le disque réseau.

La seconde ligne du Modelfile, num_ctx, fixe la fenêtre de contexte. Je l'ai réglée à 32 768 jetons sans trop y penser. Retenez ce chiffre.

5. Le tunnel SSH

Ollama n'a aucune authentification. L'exposer tel quel sur Internet reviendrait à offrir la carte à qui la trouve. Le tunnel SSH règle la question : il fait apparaître le port du serveur sur mon PC, à travers la connexion chiffrée.

ssh -i ~/.ssh/ma_cle -L 11435:localhost:11434 <identifiant-du-notebook>@gra.ai.cloud.ovh.net

J'ai pris le port 11435 côté PC parce que mon Ollama local occupe déjà le 11434. Tant que cette fenêtre reste ouverte, le modèle distant répond sur http://localhost:11435. La commande ollama du PC peut même le piloter, en lui indiquant cette adresse :

$env:OLLAMA_HOST = "http://localhost:11435"; ollama run qwen38

L'application de bureau d'Ollama, elle, ne propose aucun réglage pour viser un serveur distant : sa documentation ne connaît que son serveur local.

6. Brancher OpenCode

OpenCode est un agent de code en ligne de commande, qui accepte n'importe quel fournisseur compatible avec l'interface d'OpenAI. Ollama en expose une sous /v1. Il suffit de déclarer le tunnel dans ~/.config/opencode/opencode.json :

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "ovh-tunnel": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "H100 OVHcloud",
      "options": { "baseURL": "http://127.0.0.1:11435/v1", "apiKey": "ollama" },
      "models": {
        "qwen38-128k": {
          "name": "Qwen 3.8 27B",
          "tools": true,
          "limit": { "context": 131072, "output": 16384 }
        }
      }
    }
  },
  "model": "ovh-tunnel/qwen38-128k"
}

Un agent de code ne vaut rien si le modèle ne sait pas appeler des outils. Je l'ai vérifié avant d'aller plus loin, en lui proposant un outil fictif de météo : il a répondu par un appel propre, avec la ville en argument. OpenCode a ensuite lu un fichier et cité son contenu.

Le bloc limit de cette configuration n'était pas là au départ. C'est lui qui m'a coûté le plus de temps.

7. Le piège du contexte

Ma première configuration pointait sur le modèle à 32 768 jetons, sans rien déclarer de sa taille. Les premières réponses étaient correctes. Puis elles se sont mises à arriver coupées, parfois vides, sans erreur lisible côté OpenCode.

L'explication était dans le journal d'Ollama. Voici la taille des requêtes reçues au fil de la session :

Moment Requête reçue Place restante pour répondre
Première question 24 736 jetons environ 8 000
Quelques échanges plus tard 28 782 environ 4 000
Ensuite 32 226 environ 540
Puis à chaque requête plus de 32 500 moins de 180

Trois causes se cumulaient.

Un agent pèse lourd avant même la première question. OpenCode envoie ses instructions, la description de ses outils et la liste des compétences installées sur ma machine : près de 25 000 jetons au démarrage. Les trois quarts de ma fenêtre étaient pris avant que je tape quoi que ce soit.

L'agent ne connaissait pas la limite. Sans le bloc limit, OpenCode ignore la taille de la fenêtre et ne résume jamais la conversation. Il continue d'empiler, et c'est le serveur qui coupe.

Le modèle réfléchit avant d'écrire. Ce Qwen produit un raisonnement interne, qui compte dans la réponse. Quand il ne reste que quelques centaines de jetons, il les consomme à réfléchir et ne renvoie aucun texte : je l'ai reproduit en limitant volontairement la réponse à 200 jetons.

Une quatrième conséquence m'a désorienté un moment : en tronquant une requête trop longue, le serveur supprime la question de l'utilisateur. Le modèle répond alors par une erreur de gabarit, « No user query found in messages », qui ne dit rien de la vraie cause.

La correction tient en deux gestes. Créer une variante du modèle avec une fenêtre de 131 072 jetons :

printf 'FROM qwen38\nPARAMETER num_ctx 131072\n' > Modelfile-128k
~/ollama/bin/ollama create qwen38-128k -f Modelfile-128k

Puis déclarer cette limite à OpenCode, comme dans la configuration plus haut. La fiche du modèle indique un maximum de 262 144 jetons ; je suis resté à la moitié, largement suffisante.

Le coût en mémoire est modeste, ce qui m'a surpris :

Fenêtre de contexte Mémoire graphique occupée
32 768 jetons 31 Go
131 072 jetons 38 Go

8. Ce que ça vaut vraiment

Le montage fonctionne, et il est agréable : un agent de code qui tourne sur un modèle que je contrôle, sur une machine que j'éteins quand j'ai fini, sans qu'aucune ligne de mon code ne parte chez un fournisseur de modèles.

Il faut rester lucide sur le reste. Vingt-huit jetons par seconde, c'est confortable pour discuter, lent pour un agent qui enchaîne les appels d'outils. Un modèle de 27 milliards de paramètres perd le fil sur les tâches longues plus vite que les grands modèles hébergés. Et la sobriété du prix à l'heure ne vaut que si l'on éteint la machine : c'est le seul vrai risque financier du montage.

Ce que j'en retiens dépasse ce modèle et cette carte. La fenêtre de contexte n'est pas un détail de réglage : avec un agent, c'est la première chose à vérifier quand les réponses se dégradent. Et les journaux du serveur disent ce que l'interface cache. Sans eux, j'aurais accusé le modèle.

Ce qu'il faut pour refaire la même chose

  • Un compte OVHcloud avec un projet Public Cloud, et une clé SSH sélectionnée à la création du notebook.
  • Un notebook IA avec une carte dont la mémoire dépasse la taille du fichier du modèle d'une dizaine de gigaoctets.
  • Ollama décompressé dans le dossier personnel, lancé de façon détachée.
  • Le fichier GGUF téléchargé sur place, et un Modelfile qui fixe la fenêtre de contexte.
  • Un tunnel SSH, jamais de port ouvert.
  • Dans OpenCode, la taille du contexte déclarée dans la configuration.
  • L'habitude d'arrêter le notebook en partant.

Sources

  1. tarifs publics d'OVHcloud — ovhcloud.com
  2. AI Notebooks — ovhcloud.com
  3. Ollama — github.com
  4. Modelfile — docs.ollama.com
  5. OpenCode — opencode.ai
Aller plus loin

Reprendre cet article avec une IA

Choisissez une demande, puis l'assistant. L'article lui est transmis avec la question.

Ouvrir dans
Écrit par

Romain Delfosse

Je dirige des plateformes numériques le jour et je bricole ma maison connectée le soir. Un projet de transformation digitale, une marketplace à lancer ou une stratégie IA à cadrer ? Écrivez-moi directement.