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
- tarifs publics d'OVHcloud — ovhcloud.com
- AI Notebooks — ovhcloud.com
- Ollama — github.com
- Modelfile — docs.ollama.com
- OpenCode — opencode.ai
Reprendre cet article avec une IA
Choisissez une demande, puis l'assistant. L'article lui est transmis avec la question.



