Ollama avec Docker : installation et premier modèle

#Ollama dans Docker : ce que ça change vraiment

L'image officielle s'appelle ollama/ollama et se trouve sur Docker Hub, où elle dépasse les 100 millions de téléchargements. Elle repose sur Ubuntu 24.04 et lance directement le serveur Ollama : la variable OLLAMA_HOST y vaut 0.0.0.0:11434, donc l'API écoute sur le port 11434 à l'intérieur du conteneur. Il reste quatre décisions à prendre. Publier ce port vers l'hôte, monter un volume sur /root/.ollama pour conserver les modèles, donner l'accès au GPU avec --gpus=all si vous avez une carte NVIDIA, et choisir la version de l'image. Le conteneur démarre sans aucun modèle : vous les téléchargez ensuite avec la commande ollama, exécutée dans le conteneur. Ces quatre décisions se retrouvent à l'identique dans un fichier Compose.

On gagne une installation isolée, sans service système, décrite par un seul fichier et facile à faire cohabiter avec d'autres conteneurs (interface web, base vectorielle, n8n). On paie un accès au GPU à configurer, aucun accès au GPU sous macOS, et un port réseau dont il faut maîtriser l'exposition, point que la plupart des tutoriels omettent.

#Quelle commande selon votre matériel

Une seule image couvre tous les cas ; seules les options de lancement changent avec le GPU. Le tableau reprend la documentation d'Ollama, avec la contrainte qui piège le plus souvent.

#Prérequis

Docker

Docker Engine sur Linux, Docker Desktop sur Windows ou macOS, avec la commande docker compose pour la section 5.

Mémoire

Le poids du modèle, plus le contexte, plus une marge pour le système. qwen3.5:9b pèse 6,6 Go : visez 16 Go de RAM sur processeur, pas 8.

Disque

20 Go libres pour l'image et un ou deux modèles.

GPU NVIDIA, facultatif

Le pilote s'installe sur l'hôte, jamais dans le conteneur ; le NVIDIA Container Toolkit fait le pont.

#La procédure en cinq étapes

1. 01
   Installer Docker

   Docker Engine sur Linux, Docker Desktop sur Windows ou macOS. La commande docker version doit répondre côté client et côté moteur.
2. 02
   Préparer le GPU NVIDIA (facultatif)

   Installer le NVIDIA Container Toolkit, exécuter nvidia-ctk runtime configure --runtime=docker, redémarrer Docker, puis tester avec docker run --rm --gpus all ubuntu nvidia-smi.
3. 03
   Lancer le conteneur

   docker run avec -d, --name ollama, -v ollama:/root/.ollama, -p 127.0.0.1:11434:11434 et, avec NVIDIA, --gpus=all.
4. 04
   Télécharger un modèle

   docker exec -it ollama ollama pull, suivi de qwen3.5:4b pour une carte de 8 Go, ou de qwen3.5:9b avec plus de marge.
5. 05
   Vérifier

   docker exec ollama ollama ps doit afficher 100% GPU dans la colonne PROCESSOR.

#1. La commande docker run

La documentation d'Ollama donne pour le processeur seul : docker run -d -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama. La version ci-dessous limite la publication du port à la machine locale, ce que la section suivante justifie, et ajoute le redémarrage automatique.

docker run -d \
  --name ollama \
  -p 127.0.0.1:11434:11434 \
  -v ollama:/root/.ollama \
  --restart unless-stopped \
  ollama/ollama

-p 127.0.0.1:11434:11434

Publie le port 11434 du conteneur sur celui de la machine, pour la machine elle-même seulement.

-v ollama:/root/.ollama

Volume nommé monté là où Ollama range ses modèles. Il survit à la suppression du conteneur.

--restart unless-stopped

Relance le conteneur après un redémarrage de Docker ou de la machine, sauf arrêt manuel.

docker ps --filter name=ollama
curl http://localhost:11434/api/version

La réponse est un objet JSON avec le numéro de version, par exemple {"version":"0.34.4"}, la version stable en date du 29 septembre 2026.

#Port 11434 : qui peut vraiment y accéder

Installé nativement, Ollama écoute par défaut sur 127.0.0.1 : seule la machine peut lui parler. Dans le conteneur, l'image fixe au contraire OLLAMA_HOST à 0.0.0.0:11434, sinon le port serait injoignable de l'extérieur. La protection dépend donc de la façon dont vous publiez le port.

Selon la documentation de Docker, publier le port d'un conteneur est peu sûr par défaut : il devient accessible au monde extérieur, pas seulement à l'hôte. La commande -p 11434:11434 l'associe à toutes les adresses de la machine. Or l'API locale d'Ollama n'exige aucune authentification : quiconque atteint le port peut lister vos modèles, en télécharger ou occuper votre GPU.

-p 11434:11434

Toutes les interfaces de l'hôte : joignable depuis le réseau local, voire depuis Internet.

-p 127.0.0.1:11434:11434

Machine locale uniquement. C'est le choix par défaut de ce guide.

-p 192.168.1.10:11434:11434

Une seule adresse de l'hôte ; remplacez-la par la vôtre.

Pour ouvrir volontairement Ollama à un réseau, placez un reverse proxy avec authentification devant, comme l'explique le guide de sécurisation cité en fin de page.

#Changer le port côté hôte

Le port 11434 est pris si une autre instance tourne déjà, souvent l'application native. Ne touchez pas au côté conteneur : changez seulement le numéro de gauche. Avec -p 127.0.0.1:11435:11434, votre machine parle à Ollama sur le port 11435 ; à l'intérieur du conteneur, rien ne change.

#Joindre Ollama depuis un autre conteneur

Deux services d'un même fichier Compose partagent un réseau où chacun se joint par le nom de son service. Open WebUI utilise ainsi http://ollama:11434, sans publier le port vers l'extérieur. Si Ollama tourne plutôt sur l'hôte, la documentation d'Open WebUI signale l'écueil : il écoute sur 127.0.0.1 et reste invisible depuis le conteneur. Il faut l'atteindre par host.docker.internal et le faire écouter ailleurs.

#2. Activer le GPU NVIDIA

Docker ne voit pas votre GPU par défaut. Il faut, sur l'hôte, un pilote NVIDIA à jour, le NVIDIA Container Toolkit, puis le drapeau --gpus. Ollama exige un pilote 550 ou plus récent, et 570 pour les cartes anciennes de compute capability 5.0 à 6.2. Les conteneurs utilisent le pilote de l'hôte, ils n'en embarquent pas.

curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey \
  | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg
curl -fsSL https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list \
  | sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' \
  | sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list
sudo apt-get update
sudo apt-get install -y nvidia-container-toolkit
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker

La commande nvidia-ctk modifie le fichier /etc/docker/daemon.json pour que Docker connaisse le runtime NVIDIA, d'où le redémarrage. Pour Fedora ou RHEL, la documentation d'Ollama donne la variante yum ou dnf. Avant de toucher à Ollama, isolez le problème avec un conteneur jetable : s'il échoue, Ollama ne verra pas non plus votre GPU.

docker run --rm --gpus all ubuntu nvidia-smi

Relancez ensuite Ollama avec l'accès GPU. Le volume est conservé : les modèles déjà téléchargés restent là.

docker rm -f ollama

docker run -d \
  --name ollama \
  --gpus=all \
  -p 127.0.0.1:11434:11434 \
  -v ollama:/root/.ollama \
  --restart unless-stopped \
  ollama/ollama

Pour une Radeon sous Linux, le tag rocm et les périphériques /dev/kfd et /dev/dri remplacent --gpus ; le pilote ROCm v7 reste à installer sur l'hôte.

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

• Ollama et GPU AMD : configurer ROCm pas à pas
• Ollama sous WSL2 ou Windows natif : lequel choisir

#3. Premier modèle

Le conteneur tourne mais il est vide. La commande ollama vit dans le conteneur : on l'appelle avec docker exec. Ce guide utilise qwen3.5:9b, que la bibliothèque Ollama décrit avec 6,6 Go, une fenêtre de 256K et la prise en charge du texte et de l'image.

docker exec -it ollama ollama pull qwen3.5:9b

Ces 6,6 Go doivent tenir en mémoire avant même que le contexte n'entre en jeu. Sur une carte de 8 Go, la marge est mince : la variante 4B est le choix prudent.

Les repères de la dernière colonne sont des ordres de grandeur, pas des mesures : la place réelle dépend du contexte et de la quantification. Pour discuter avec le modèle, lancez ollama run dans le conteneur.

docker exec -it ollama ollama run qwen3.5:9b

L'usage courant passe par l'API HTTP : n'importe quel client parle au conteneur comme à un Ollama natif, et la documentation précise que l'API accepte un sous-ensemble du format OpenAI.

curl http://localhost:11434/api/generate -d '{
  "model": "qwen3.5:9b",
  "prompt": "Explique la quantification Q4 en deux phrases.",
  "stream": false
}'

docker exec ollama ollama ps

Dans la colonne PROCESSOR, 100% GPU signifie que le modèle est entièrement dans la carte, 100% CPU qu'il est en mémoire système, et 48%/52% CPU/GPU qu'il est réparti entre les deux. Une répartition ralentit nettement la génération : mieux vaut un modèle plus petit qu'un modèle qui déborde.

#Le contexte se règle sur le conteneur

La fenêtre de contexte par défaut dépend de la mémoire : 4k sous 24 GiB de VRAM, 32k entre 24 et 48 GiB, 256k au-delà. La documentation recommande au moins 64 000 tokens pour les agents et les outils de code. Un contexte plus grand consomme plus de mémoire : passez -e OLLAMA_CONTEXT_LENGTH=8192 au docker run, puis contrôlez la colonne CONTEXT de ollama ps.

#4. Volume persistant : où vivent vos modèles

Le -v ollama:/root/.ollama crée un volume Docker nommé ollama, distinct du conteneur. La documentation de Docker le confirme : un volume persiste après la suppression du conteneur, ce qui permet de remplacer l'image sans retélécharger les modèles. La commande docker volume inspect ollama indique son Mountpoint, l'emplacement des fichiers sur l'hôte.

Sous Linux, l'installation native range les siens dans /usr/share/ollama/.ollama/models. Ce dossier n'a aucun lien avec le volume Docker : un modèle téléchargé d'un côté n'apparaît pas de l'autre.

docker run --rm \
  -v ollama:/data \
  -v $(pwd):/backup \
  alpine tar czf /backup/ollama-models.tar.gz -C /data .

#5. Docker Compose : la même chose, dans un fichier

Le fichier ci-dessous fait la même chose que les commandes précédentes, se relit d'un coup d'œil et se versionne dans git. Il fige la version de l'image : remplacez 0.34.4 par la dernière version stable au moment où vous lisez.

services:
  ollama:
    image: ollama/ollama:0.34.4
    container_name: ollama
    ports:
      - "127.0.0.1:11434:11434"
    volumes:
      - ollama:/root/.ollama
    restart: unless-stopped
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

volumes:
  ollama:

Le bloc deploy réserve le GPU ; d'après la documentation de Compose, le champ capabilities est obligatoire, faute de quoi le déploiement échoue. Sans GPU NVIDIA, supprimez le bloc en entier : le reste fonctionne sur processeur.

docker compose up -d        # démarrer
docker compose logs -f      # suivre les logs
docker compose pull         # télécharger l'image du tag indiqué
docker compose down         # arrêter, volume conservé
docker compose down -v      # arrêter et supprimer le volume : efface tous les modèles

#Mettre à jour Ollama sans perdre ses modèles

Au 29 septembre 2026, la page des versions d'Ollama sur GitHub marque la 0.34.4 comme dernière version stable, alors que la 0.35.0 y figure en préversion. Le tag 0.35.0 existe pourtant déjà sur Docker Hub, parmi des tags rc, pour release candidate. Épinglez donc un numéro stable plutôt que de suivre le dernier tag publié : la mise à jour arrive quand vous la décidez.

Avec Compose, changez le numéro dans le fichier, puis lancez docker compose pull et docker compose up -d. Avec docker run, tirez la nouvelle image, supprimez l'ancien conteneur et relancez la même commande : tant que le volume est le même, les modèles suivent. Contrôlez enfin la version avec curl http://localhost:11434/api/version.

• Ollama : mettre à jour, supprimer un modèle, désinstaller

#Docker ou installation native : le choix

Les deux méthodes donnent le même serveur sur le même port. Le tableau s'appuie sur la documentation d'Ollama ; il ne compare pas les vitesses, faute de mesure publiée et citable.

Choisissez Docker pour empiler plusieurs services, épingler une version ou partager un poste. Choisissez le natif sur un Mac, ou quand Docker n'apporte rien à un usage individuel.

#Dépannage

could not select device driver "nvidia"

Le NVIDIA Container Toolkit manque, ou Docker n'a pas été redémarré après nvidia-ctk runtime configure. Refaites la configuration, redémarrez Docker, retestez avec docker run --rm --gpus all ubuntu nvidia-smi.

Le GPU marche, puis Ollama retombe sur le processeur

Symptôme documenté : le journal signale des échecs de découverte du GPU après un moment. Ollama conseille de désactiver la gestion cgroup de systemd dans Docker : ajoutez "exec-opts": ["native.cgroupdriver=cgroupfs"] à /etc/docker/daemon.json, puis redémarrez Docker.

Erreurs GPU 3, 46, 100 ou 999

Rechargez le pilote UVM avec sudo rmmod nvidia_uvm puis sudo modprobe nvidia_uvm, ou redémarrez la machine.

Port 11434 déjà utilisé

Une autre instance écoute, souvent l'application native. Arrêtez-la, ou publiez sur un autre port avec -p 127.0.0.1:11435:11434.

Réponses tronquées

Le contexte par défaut dépend de la VRAM. Ajoutez -e OLLAMA_CONTEXT_LENGTH=8192 au lancement, en surveillant la mémoire.

Téléchargement bloqué derrière un proxy

Passez -e HTTPS_PROXY=https://proxy.example.com au conteneur. La documentation déconseille HTTP_PROXY, qui peut perturber les clients.

Inaccessible depuis le réseau local

Normal avec -p 127.0.0.1:11434:11434. Ouvrez le port seulement derrière une authentification.

#Questions fréquentes

#Pour aller plus loin

Vous avez un Ollama fonctionnel, isolé, avec un modèle sur le GPU. Les suites logiques : une interface de discussion, la sécurisation avant tout partage réseau, puis une pile de production.

• Installer Ollama sur tous les systèmes : le guide général
• Dépanner Ollama : GPU non détecté, lenteurs, erreurs mémoire
• Docker Model Runner : lancer des LLM avec Docker, sans Ollama

• Source : documentation Ollama, page Docker
• Source : image ollama/ollama sur Docker Hub
• Source : Docker, publication de ports
• Source : NVIDIA Container Toolkit, guide d'installation
• Source : documentation Ollama, GPU pris en charge