Accueil›Guides›Ollama dans Docker : la commande, le volume, le port et le GPU, testés en v0.40.15

Installer · Guide

Ollama dans Docker : la commande, le volume, le port et le GPU, testés en v0.40.15

Pour lancer Ollama dans Docker : docker run -d -v ollama:/root/.ollama -p 127.0.0.1:11434:11434 --name ollama ollama/ollama, puis docker exec -it ollama ollama run llama3.2. Le volume garde vos modèles même si vous supprimez le conteneur ; le 127.0.0.1 garde le port sur votre machine. Testé en v0.40.15 : 3,4 Go à télécharger, 8,5 Go sur le disque.

Mesuré et rédigé par Local AI ScopePublié le Chiffres mesurés par Local AI Scope

Pour lancer Ollama dans Docker : docker run -d -v ollama:/root/.ollama -p 127.0.0.1:11434:11434 --name ollama ollama/ollama, puis docker exec -it ollama ollama run llama3.2. Le volume garde vos modèles même si vous supprimez le conteneur ; le 127.0.0.1 garde le port sur votre machine. Testé en v0.40.15 : 3,4 Go à télécharger, 8,5 Go sur le disque.

Docker est une belle façon de faire tourner Ollama : une commande, rien d’installé sur le système, et une mise à jour se résume à changer d’image. Mais l’image officielle n’est pas simplement « Ollama dans une boîte » : elle change l’adresse d’écoute d’Ollama, ce qui éteint l’une de ses 2 protections. Le 6 novembre 2026, nous avons donc téléchargé ollama/ollama:0.40.15 sur un serveur Linux (Docker 29.9.3, ufw actif, pas de carte NVIDIA, un GPU intégré AMD), chargé un modèle minuscule de 135 millions de paramètres (smollm2:135m) et mesuré l’effet de chaque option : ports, volumes, variables, GPU et Compose. Tout ce qui, ici, dit « nous avons mesuré » vient de ces essais, entre 15 h 52 et 16 h 01 UTC, et d’un dernier le 7 novembre à 8 h 21 UTC avec la commande de la première section ; ce qui vient de la documentation est signalé comme tel.

OllamaOllamaFiche logiciel

Ollama dans Docker en 1 commande (et les 2 détails qui comptent)

Voici la commande que nous vous conseillons. Nous l’avons lancée le 7 novembre à 8 h 21 UTC, avec notre modèle minuscule à la place de llama3.2 et une question isolée (« Name one planet. ») au lieu de la discussion :

docker run -d -v ollama:/root/.ollama -p 127.0.0.1:11434:11434 --name ollama ollama/ollama
docker exec -it ollama ollama run llama3.2
curl http://127.0.0.1:11434/api/version

La première ligne démarre le serveur en arrière-plan, la deuxième télécharge un modèle et ouvre une discussion avec lui dans le conteneur (le nôtre a récupéré ses 270 Mo et répondu sans citer la moindre planète, ce qui est à peu près ce qu’on peut attendre de 135 millions de paramètres), la troisième vérifie que l’API répond depuis votre machine (chez nous : {"version":"0.40.15"}, et docker port n’a affiché que 127.0.0.1:11434). Le 127.0.0.1: devant le port est le premier détail qui compte, et les sections suivantes montrent pourquoi. Le second, c’est le -v : sans lui, vos modèles vivent et meurent avec le conteneur.

Ce que contient l’image, lu dans sa configuration et son Dockerfile : Ubuntu 24.04, le binaire ollama (44,2 Mo) et 4,64 Go de bibliothèques GPU dans /usr/lib/ollama, d’où son poids. Elle tourne en root (aucune ligne USER ; id à l’intérieur a répondu uid=0(root)), elle fixe OLLAMA_HOST=0.0.0.0:11434 pour que le serveur écoute sur toutes les interfaces du conteneur, et elle ne déclare aucun volume. Le téléchargement a représenté 3,39 Go, une minute et quelques sur la fibre de notre serveur ; sur le disque, elle occupe 8,51 Go. Votre disque le sentira davantage que votre facture d’électricité.

Étiquette (au 7-11-2026) Ce qu’elle contient Plateformes Téléchargement
latest = 0.40.15 Processeur et NVIDIA (CUDA 12 et 13) ; Vulkan en amd64, Jetson (JetPack) en arm64 amd64 et arm64 3,39 Go (amd64) · 2,87 Go (arm64)
rocm = 0.40.15-rocm Processeur et AMD ROCm 7.2.1 amd64 seulement 1,46 Go

Au 7-11-2026, latest était la même image que 0.40.15 (même digest sur Docker Hub) ; depuis le 9-11-2026, il pointe vers 0.40.16 (et rocm vers 0.40.16-rocm). En écrivant la version, comme dans ollama/ollama:0.40.15, c’est vous qui décidez quand mettre à jour, au lieu de le découvrir après un docker pull.

Page Docker Hub de l’image officielle ollama/ollama, onglet Tags : rocm pour linux/amd64 et latest pour linux/amd64 et linux/arm64
L’image officielle ollama/ollama sur Docker Hub. Ses tailles sont en unités binaires : les 3,16 GB affichés pour latest en amd64 (des Gio en réalité) correspondent aux 3,39 milliards d’octets que nous avons téléchargés Capture : Docker Hub, 7-11-2026

Dans cette vidéo (en anglais), le port est publié avec -p 11434:11434, sans 127.0.0.1 : cette version ouvre Ollama à tout votre réseau. Si vous ne l’utilisez que sur votre ordinateur, ajoutez 127.0.0.1 comme nous l’expliquons plus bas, dans la partie sur le port.

S’ouvre sur YouTube (sans cookies) seulement si vous appuyez.

Garder vos modèles : volume nommé ou dossier

Sans -v, un modèle téléchargé atterrit dans la couche inscriptible du conteneur lui-même. Nous l’avons vérifié : modèle copié dans le conteneur, ollama list l’affichait, puis docker rm -f et le même docker run… et ollama list est revenu vide. Avec un volume nommé (-v ollama:/root/.ollama), la même suppression suivie de la même recréation a laissé le modèle en place. Sous Linux, Docker a rangé notre volume de test dans /var/lib/docker/volumes/<nom>/_data (le vôtre : …/ollama/_data), propriété de root.

L’autre option est un dossier à vous : -v /home/utilisateur/ollama:/root/.ollama. Ça fonctionne, avec un inconvénient que nous avons constaté : les fichiers créés apparaissent sur votre machine comme appartenant à root (uid 0), même si le dossier est le vôtre ; pour les supprimer ensuite, il vous faudra sudo. Pour placer les modèles ailleurs dans le conteneur, -e OLLAMA_MODELS=/datos/models les y déplace, à condition d’y monter aussi le volume (-v ollama:/datos) : c’est ainsi que nous l’avons testé, et ollama list a bien trouvé le modèle à cet endroit.

Le volume conserve aussi un petit fichier auquel on ne pense pas. Au premier démarrage, le serveur crée /root/.ollama/id_ed25519, la clé avec laquelle cet Ollama s’identifie auprès d’ollama.com. Sans volume, chaque nouveau conteneur repart avec une nouvelle clé.

Pour mettre à jour, le volume fait tout le travail : docker pull ollama/ollama:<nouvelle version>, docker rm -f ollama et le même docker run avec la nouvelle étiquette. Les modèles restent où ils étaient. Pour tout retirer : docker rm -f ollama, docker volume rm ollama et docker rmi ollama/ollama (ou l’étiquette utilisée), qui libère cet espace. Pour retirer un Ollama installé hors de Docker, sur Mac, Windows ou Linux, voyez comment désinstaller Ollama.

Le port : 127.0.0.1 ou tout votre réseau (et ufw ne l’arrête pas)

C’est la section que nous soulignerions deux fois. Avec -p 127.0.0.1:11434:11434, nous avons mesuré que Docker n’ouvre le port que sur l’adresse locale : ss -ltn a montré une seule ligne 127.0.0.1, curl 127.0.0.1 a renvoyé la version et une requête vers l’adresse réseau du serveur lui-même a été refusée (ce dernier test sur un port haut, le 18434).

La forme courte, -p 11434:11434, c’est une autre affaire. Nous l’avons testée avec un petit serveur web leurre à la place d’Ollama, pendant 2 secondes, pour ne pas laisser un modèle exposé : docker port a affiché 0.0.0.0 et [::], autrement dit toutes les adresses IPv4 et IPv6 de la machine, et une requête vers son adresse réseau a obtenu un 200. Avec ufw actif et aucune règle pour ce port. Docker fait passer ce trafic par ses propres règles (une redirection dans la table nat et ses chaînes placées avant celles d’ufw dans FORWARD), et sa documentation l’écrit noir sur blanc : les ports publiés contournent les réglages d’ufw. Notre requête partait du serveur lui-même vers son adresse réseau ; qu’une autre machine entre de la même façon, c’est ce que documente Docker, et les règles que nous avons lues disent la même chose.

Un détail tiré de la documentation de Docker : avant Docker 28.0.0, les machines du même segment de réseau local pouvaient atteindre des ports publiés sur 127.0.0.1. Vérifiez votre version avec docker version ; à partir de la 28, 127.0.0.1 veut bien dire ce qu’il dit. Et si vous voulez vraiment utiliser Ollama depuis une autre machine, un tunnel SSH (ssh -L 11434:127.0.0.1:11434 utilisateur@serveur) vous y donne l’API sans rien ouvrir au réseau.

Ce qui change dans le conteneur : le contrôle de l’en-tête Host et le CORS

Avec son adresse d’usine (127.0.0.1), Ollama dispose de 2 barrières contre les pages web qui tentent d’atteindre votre serveur local. La première examine l’en-tête Host et refuse les noms qu’elle ne connaît pas, ce qui bloque l’astuce d’un domaine pointé vers 127.0.0.1 (DNS rebinding). La seconde est le CORS, la liste des origines que le navigateur laisse passer. Dans notre guide de l’API d’Ollama, nous avons testé la première avec le binaire seul, à l’écoute sur 127.0.0.1 : un 403.

Dans l’image officielle, la première s’éteint. Avec l’image telle quelle et le port sur 127.0.0.1, notre requête avec un Host inventé (atacante.example) a obtenu un 200. La même image avec -e OLLAMA_HOST=127.0.0.1:11434, dans un conteneur sans réseau et interrogée de l’intérieur : 403. Avec -p, cette variable ne sert à rien (le serveur n’écouterait que dans le conteneur). La raison est dans le code (server/routes.go) : quand le serveur écoute sur une adresse qui n’est pas celle de bouclage, il ne contrôle pas le Host, et l’image fixe 0.0.0.0. Le CORS, lui, fonctionne toujours : une origine étrangère (https://ejemplo.com) a reçu un 403, et http://localhost:3000 un 200.

Logo d’Ollama
Logo d’Ollama. Dans son image officielle, la v0.40.15 écoute sur 0.0.0.0 et le contrôle de l’en-tête Host reste éteint Logo : Ollama

Pas de quoi s’affoler : sur 2 barrières, une s’éteint et l’autre reste. Si vous voulez les 2 sous Linux, il existe une solution que nous avons testée : --network host -e OLLAMA_HOST=127.0.0.1:11435 (nous avons pris le 11435 pour n’entrer en conflit avec rien ; sans autre Ollama sur la machine, le 11434 convient). Le conteneur utilise alors le réseau de la machine, ss n’a montré que 127.0.0.1:11435, et le Host inventé a de nouveau reçu son 403. Pas de -p : avec --network host, il n’y a rien à publier. Et jamais --network host sans cette variable : l’OLLAMA_HOST=0.0.0.0 de l’image écouterait alors sur toutes les adresses de votre machine.

Docker Compose : un fichier minimal que nous avons testé

La même chose, dans un fichier que vous pouvez conserver. Nous avons démarré ce compose.yaml avec docker compose up -d (Compose v5.7.0) :

services:
  ollama:
    image: ollama/ollama:0.40.15
    ports:
      - "127.0.0.1:11434:11434"   # cette machine seulement ; sans l’IP, ouvert sur toutes les adresses
    volumes:
      - ollama:/root/.ollama      # les modèles survivent à down/up et aux changements de version
    environment:
      - OLLAMA_NO_CLOUD=1         # ni modèles ni routes du cloud d’Ollama
    restart: unless-stopped

volumes:
  ollama:

Ce que nous avons vu : le port uniquement sur 127.0.0.1:11434, l’API qui répond avec sa version, la politique de redémarrage sur unless-stopped (selon Docker, il revient après un plantage ou un redémarrage de Docker, sauf si vous l’avez arrêté vous-même) et le volume monté sur /root/.ollama. Un docker compose down suivi de up -d a conservé le modèle, qui a répondu de nouveau. docker compose down -v supprime aussi le volume, modèles compris : gardez le -v pour quand vous le voulez vraiment. Pour discuter avec un modèle : docker compose exec ollama ollama run llama3.2. Et OLLAMA_NO_CLOUD=1 ne vous empêche pas de télécharger des modèles : le matin même du 6 novembre, lors d’un essai précédent avec le binaire seul, nous en avons récupéré un sur ollama.com avec la variable activée.

GPU dans Docker : NVIDIA, AMD (ROCm), Vulkan et GPU intégré

L’image est prête pour la carte graphique, mais Docker ne la lui confie pas sans qu’on le demande. Ce qui suit sur NVIDIA et ROCm, nous l’avons lu dans la documentation d’Ollama pour la v0.40.15 ; la partie GPU intégré, nous l’avons testée.

Station de travail avec RTX 4090 24 GoStation de travail avec RTX 4090 24 GoFiche matériel

NVIDIA. D’abord le NVIDIA Container Toolkit sur l’hôte (depuis le dépôt apt ou yum de NVIDIA), puis sudo nvidia-ctk runtime configure --runtime=docker et sudo systemctl restart docker, et enfin le même docker run avec --gpus=all. Sous Windows, cela passe par WSL2 avec le même toolkit. Dans Compose, la documentation de Docker (lue le 7 novembre) demande un bloc deploy sous le service ; capabilities est obligatoire et count accepte un nombre ou all. Nous ne l’avons pas exécuté, faute de carte NVIDIA :

    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
Carte graphique NVIDIA GeForce RTX 4090
NVIDIA GeForce RTX 4090. Dans Docker, Ollama ne voit une carte NVIDIA qu’avec le Container Toolkit installé et --gpus=all (ou le bloc deploy dans Compose) Photo : NVIDIA

AMD avec ROCm. L’autre image : docker run -d --device /dev/kfd --device /dev/dri -v ollama:/root/.ollama -p 127.0.0.1:11434:11434 --name ollama ollama/ollama:rocm. Elle n’existe qu’en amd64 et vise les cartes AMD qui fonctionnent avec ROCm.

Vulkan et GPU intégré (testé). L’image normale en amd64 embarque aussi Vulkan, activé d’office dès qu’il voit les périphériques. Sur notre serveur, avec --device /dev/kfd --device /dev/dri, Ollama a trouvé le GPU intégré AMD (« AMD Radeon Graphics (RADV RENOIR) »), puis l’a écarté : dropping integrated GPU; to enable, set OLLAMA_IGPU_ENABLE=1. Nous avons ajouté -e OLLAMA_IGPU_ENABLE=1, et le journal a affiché library=Vulkan, type=iGPU, avec les 31 couches du modèle, toutes, sur le GPU. Avec un modèle de 135M, il n’a pas été plus rapide que le processeur : lisez-le comme « ça s’active ainsi », pas comme une vitesse.

PC avec Ryzen AI Max+ 395 et 128 Go unifiésPC avec Ryzen AI Max+ 395 et 128 Go unifiésFiche matériel
Framework Desktop, l’un des PC équipés de cette puce
Framework Desktop, avec l’AMD Ryzen AI Max+ 395 et son gros GPU intégré. Avec l’image normale (Vulkan), il faut OLLAMA_IGPU_ENABLE=1 ; d’après le code d’Ollama 0.40.15, l’image rocm l’accepte d’office Photo : Framework

Sur un Mac, mieux vaut se passer de Docker. La FAQ d’Ollama le dit sans détour : Docker Desktop sous macOS ne transmet pas le GPU au conteneur, qui travaille donc sur le seul processeur. L’application Ollama pour Mac, elle, utilise bien le GPU de la puce, via Metal.

Mac avec M4 et 16 Go unifiésMac avec M4 et 16 Go unifiésFiche matériel

Si le GPU fonctionne un moment puis que le modèle retombe sur le processeur, c’est un piège connu de Docker (le pilote de cgroups), que nous expliquons, avec le test nvidia-smi dans un conteneur, dans Ollama ne fonctionne pas.

S’ouvre sur YouTube (sans cookies) seulement si vous appuyez.

Cette courte vidéo (en anglais) montre les 4 vérifications hors de Docker : ollama ps, le journal du serveur, la sortie d’ollama serve et le moniteur de performances du système. Dans un conteneur, ce sont les mêmes avec docker exec ollama devant, et le journal s’obtient avec docker logs ollama.

Hors ligne et sans cloud : OLLAMA_NO_CLOUD, keep_alive et ce qu’il tente de joindre

Les variables passent par -e, et nous avons vérifié que l’image les respecte. Avec -e OLLAMA_NO_CLOUD=1 -e OLLAMA_KEEP_ALIVE=30s -e OLLAMA_MODELS=/datos/models, le journal du serveur a listé les 3 et affiché Ollama cloud disabled: true. /api/balance, une route qui interroge ollama.com sur votre compte, a répondu 403 sans tenter de sortir. Et le modèle, après avoir répondu, est resté en mémoire 30 secondes pile (l’expires_at de /api/ps), au lieu des 5 minutes d’usine.

Que tente-t-il de joindre si vous ne réglez rien ? Nous avons démarré l’image sans cette variable et sans réseau : dès la première milliseconde, elle a tenté 2 appels vers ollama.com, le catalogue des modèles recommandés et la liste des modèles cloud, et les 2 ont échoué avec « network is unreachable ». Avec OLLAMA_NO_CLOUD=1, aucun. Pour un conteneur 100 % hors ligne, --network none fait l’affaire, à condition que les modèles soient déjà dans le volume ; le revers, c’est qu’il ne publie aucun port non plus, et l’on y entre par docker exec.

Si vous préférez installer Ollama directement sur le système, notre guide démarrer Ollama en local part de zéro, avec le tunnel SSH pas à pas. Les routes de l’API que vous venez de publier, le CORS et keep_alive sont dans l’API d’Ollama, et si les réponses sortent tronquées, la longueur de contexte dans Ollama explique comment l’augmenter. Et pour une fenêtre de chat façon ChatGPT par-dessus ce conteneur, Open WebUI avec Ollama tourne dans un second conteneur sur le même réseau Docker ; nous avons mesuré ce qu’il contacte et comment ramener cela à zéro.