Docker Ollama : exécutez des LLM en local pour la confidentialité et à coût zéro

La plupart des développeurs veulent essayer les LLM en local, sans savoir par où commencer.

L'essor des modèles open source comme Llama et Mistral rend l'IA locale plus accessible que jamais. Inutile de dépenser un centime chez OpenAI ou Anthropic ni de craindre d'envoyer vos données à des tiers. Le hic : la plupart des guides d'installation impliquent la gestion d'environnements Python, de pilotes CUDA et de dépendances qui cassent souvent quand on change de machine.

Ollama résout ce problème en offrant une façon simple d'exécuter des LLM en local avec un minimum de configuration. Associé à Docker, vous obtenez une solution propre et portable, identique d'un système à l'autre.

Dans ce guide, je vous montre comment configurer Ollama dans Docker, télécharger votre premier modèle et commencer à exécuter des LLM locaux accessibles depuis n'importe quelle application.

Si vous débutez totalement avec Docker, nous vous recommandons de suivre notre cours Introduction to Docker pour en maîtriser les fondamentaux.

Qu'est-ce qu'Ollama ?

Considérez Ollama comme la façon la plus simple d'exécuter de grands modèles de langage sur votre propre matériel.

C'est un runtime léger qui prend en charge tout le lourd pour les LLM locaux. Inutile de gérer des environnements Python, d'installer à la main des pilotes CUDA ou de jongler avec les poids et tokenizers des modèles. Ollama s'occupe de télécharger, charger et servir des modèles comme LLaMA, Mistral et Gemma avec une seule commande.

La confidentialité est native. Vos conversations ne quittent jamais votre machine. Pas de clés d'API, pas de suivi d'usage, pas de données envoyées à des serveurs externes. Idéal pour les cas sensibles où vous ne pouvez pas exposer du code privé ou des informations personnelles à des services tiers.

L'outil est conçu d'abord pour les développeurs. Il fonctionne nativement sur macOS et Linux, propose une API REST simple pour l'intégration et s'exécute désormais dans des conteneurs Docker. Vous pouvez ainsi utiliser la même configuration en local pendant le développement et la déployer partout où Docker tourne.

Vous obtenez un serveur LLM prêt pour la production, qui démarre en une commande et fonctionne hors ligne.

Ollama n'est pas le seul runtime LLM – testez aussi n8n et Qdrant.

Pourquoi utiliser Docker avec Ollama ?

La réponse est simple : vous profitez pleinement d'Ollama tout en gardant votre système propre.

Exécuter Ollama directement sur votre machine fonctionne très bien : il est fourni avec un installateur ( .exe pour Windows, .dmg pour Mac ) qui gère tout. Mais Docker apporte un atout clé : l'isolation.

Avec Docker, Ollama tourne dans son propre conteneur. Votre système hôte reste propre. Pas d'empreinte d'installation, pas de fichiers résiduels après vos tests, suppression facile pour changer de version ou repartir à zéro.

La même configuration fonctionne pour toute votre équipe grâce à la reproductibilité. Partagez une commande Docker et chacun peut exécuter exactement le même environnement Ollama, qu'il soit sur macOS, Linux ou Windows.

Le déploiement est simplifié grâce au support multiplateforme. Le même conteneur tourne sur votre ordinateur portable, un serveur cloud, un pipeline CI ou la machine d'un collègue, sans modification.

Démarrage et nettoyage express : lancez Ollama en quelques secondes et supprimez-le tout aussi vite. Pas de scripts de désinstallation, pas de chasse aux fichiers de config, pas de ménage système.

Docker est idéal pour :

• Tester différents modèles sans installation complète
• Construire des applications qui s'intègrent à des LLM locaux
• Créer des environnements de développement partagés par plusieurs membres de l'équipe
• Exécuter Ollama sur des serveurs sans modifier le système de base

En bref, vous profitez des LLM locaux sans les démêlés d'installation.

Vous cherchez des ressources Docker concrètes ? Ces 12 images de conteneurs Docker pour le machine learning et l'IA vous mettront sur les rails.

Configurer Ollama dans Docker

Il vous faut exactement trois commandes pour exécuter Ollama dans Docker.

Commencez par récupérer l'image officielle Ollama depuis Docker Hub :

docker pull ollama/ollama

Téléchargement de l'image ollama

Ensuite, lancez le conteneur avec les bons mappings de port et de volume :

docker run -d --name my-ollama-docker -p 11434:11434 -v ollama:/root/.ollama ollama/ollama

Démarrage d'ollama

Voici à quoi servent les options :

• -d exécute le conteneur en arrière-plan
• --name my-ollama.docker donne un nom explicite à votre conteneur
• -p 11434:11434 mappe le port par défaut d'Ollama sur votre machine hôte
• -v ollama:/root/.ollama crée un volume persistant pour les modèles téléchargés

Le conteneur démarre immédiatement et écoute sur http://localhost:11434.

Ollama en exécution en local

Téléchargez maintenant un modèle pour valider le fonctionnement :

docker exec -it my-ollama-docker  ollama pull llama3.1

Téléchargement du modèle Llama3.1

Cela télécharge le modèle Llama 3.1 8b dans votre conteneur. Le modèle fait environ 5 Go, le téléchargement peut donc prendre quelques minutes.

Vous pouvez vérifier la configuration en listant les modèles disponibles :

docker exec -it my-ollama-docker ollama list

Liste des modèles disponibles

Le mapping de volume est essentiel. Sans lui, vous perdrez tous les modèles téléchargés à l'arrêt du conteneur. Le volume ollama:/root/.ollama pérennise vos modèles entre les redémarrages et mises à jour.

En production, vous pouvez construire des images personnalisées avec des modèles préchargés. Créez un Dockerfile qui télécharge des modèles pendant la construction :

FROM ollama/ollama
RUN ollama serve & sleep 5 && ollama pull llama3.1 && pkill ollama
CMD ["ollama", "serve"]

Le modèle est alors inclus dans l'image : les nouveaux conteneurs démarrent prêts à l'emploi.

Utiliser Ollama via Docker

Une fois votre conteneur lancé, Ollama se comporte comme n'importe quelle API REST.

Le service écoute sur http://localhost:11434 et accepte des requêtes HTTP standard. Pas besoin de clients ou SDK spéciaux : envoyez du JSON et récupérez les réponses.

Voici comment générer du texte avec une simple commande curl :

curl http://localhost:11434/api/generate -d '{
  "model": "llama3.1",
  "prompt": "Why is the sky blue?",
  "stream": false
}'

Accès à ollama avec curl

L'API renvoie une réponse JSON avec le texte généré. Définissez "stream": false pour obtenir la réponse complète d'un coup, ou "stream": true pour recevoir les tokens au fil de l'eau.

L'intégration Python est tout aussi simple :

import requests

response = requests.post(
    "http://localhost:11434/api/generate",
    json={
        "model": "llama3.1",
        "prompt": "Explain Docker containers in one sentence.",
        "stream": False,
    },
)

print(response.json()["response"])

Accès à ollama avec Python

Ollama est parfait comme backend pour des applications locales. Vous pouvez créer des interfaces de chat, des outils d'autocomplétion de code ou des systèmes d'analyse documentaire qui dialoguent avec votre LLM conteneurisé, sans envoyer de données à l'extérieur.

Pour des workflows plus avancés, l'intégration LangChain fonctionne nativement :

from langchain_ollama import ChatOllama

llm = ChatOllama(model="llama3.1", base_url="http://localhost:11434")
response = llm.invoke("Explain the benefits of containerization in 2 sentences")
print(response)

Accès à ollama avec LangChain

Vous bénéficiez de toute la puissance des LLM locaux avec la simplicité des requêtes HTTP.

Vous vous demandez comment déployer des applications LLM ? Découvrez notre guide pas à pas sur le déploiement d'applications LLM avec Docker.

Points de performance à considérer

Les LLM locaux exigent un matériel solide, et Docker ajoute sa propre surcharge.

CPU vs GPU change tout. Ollama peut tourner sur des systèmes uniquement CPU, mais l'inférence sera lente : comptez 30 secondes ou plus pour des réponses simples. Avec un GPU moderne, la même requête se termine en moins de 5 secondes. Les GPU NVIDIA sont idéaux, mais les Mac Apple Silicon offrent aussi de bonnes performances et un excellent rapport qualité-prix.

La RAM nécessaire croît avec la taille du modèle. Les petits modèles comme Llama3.1 8B requièrent au moins 8 Go de RAM système, tandis que les versions 70B demandent 64 Go ou plus. Le modèle reste chargé en mémoire pendant l'usage : vous ne pourrez pas faire tourner un 13B sur une machine avec 8 Go de RAM.

L'espace disque grimpe vite. Chaque modèle consomme plusieurs gigaoctets :

• Modèles 7B : 4–8 Go
• Modèles 13B : 8–16 Go
• Modèles 70B : 40–80 Go

La multiplication des versions et quantifications augmente très vite les besoins de stockage. Vous pouvez déporter les modèles sur un disque externe si nécessaire.

La surcharge du conteneur est minime pour le calcul, mais compte pour le stockage. L'image de base Ollama fait moins de 1 Go, mais les modèles persistent dans des volumes Docker. Si vous construisez des images personnalisées avec des modèles préchargés, prévoyez plusieurs gigaoctets supplémentaires par image.

En revanche, l'allocation mémoire dans Docker mérite souvent une attention particulière. Par défaut, Docker Desktop limite la mémoire des conteneurs. Pour les gros modèles, augmentez ces limites ou utilisez l'option --memory au lancement.

Le goulot d'étranglement est le plus souvent la RAM, pas le CPU ni le disque.

Cas d'usage courants

Docker + Ollama vous apporte des capacités d'IA tout en gardant vos données privées et vos coûts d'inférence LLM à exactement 0 $ (hors électricité et maintenance).

Les assistants d'IA locaux sont le terrain de jeu idéal. Créez des outils d'autocomplétion de code, des générateurs de documentation ou des assistants rédactionnels qui tournent entièrement sur votre machine. Pas de coûts d'API, pas de limites de taux, pas de données qui sortent de votre réseau. Pointez simplement votre éditeur ou IDE vers localhost:11434 et commencez à construire.

Les pipelines RAG privés deviennent également bien plus simples à déployer.

Vous pouvez charger les documents de votre entreprise dans une base vectorielle, puis utiliser Ollama pour répondre à leur sujet. L'ensemble de la base de connaissances reste interne : essentiel pour des informations légales, financières ou privatives qui ne doivent pas transiter par des API externes.

Le développement de chatbots hors ligne vous permet de prototyper et tester des IA conversationnelles sans dépendance à Internet. Idéal pour les déploiements en périphérie, les environnements isolés ou en cas de connectivité aléatoire. Votre bot fonctionne de la même façon que vous soyez en ligne ou à 10 000 mètres d'altitude.

L'expérimentation de modèles avant un déploiement cloud fait gagner temps et argent. Testez différents modèles, prompts et configurations en local avant de vous engager dans une inférence cloud coûteuse. Vous pouvez benchmarker, affiner les paramètres et valider les sorties sans brûler vos crédits d'API.

Les équipes utilisent aussi Docker et Ollama pour :

• Génération de données d'entraînement lorsque de grands volumes de texte synthétique sont nécessaires
• Modération de contenus traités en interne et potentiellement sensibles
• Environnements de recherche où la reproductibilité et l'isolation comptent
• Applications de démo qui fonctionnent sans dépendances externes

Vous bénéficiez de capacités d'IA de niveau entreprise sans la facture qui va avec.

Astuces, limites et dépannage

Quelques pièges peuvent vous freiner lors de l'exécution d'Ollama dans Docker.

Le support GPU nécessite une configuration supplémentaire. L'image Docker officielle d'Ollama prend en charge les GPU NVIDIA, mais vous devez d'abord installer le NVIDIA Container Toolkit et passer l'option --gpus all au lancement du conteneur :

docker run -d --gpus all --name ollama -p 11434:11434 -v ollama:/root/.ollama ollama/ollama

Sans cela, Ollama bascule en mode CPU uniquement : ça marche, mais nettement plus lentement. Si vous êtes sur un MacBook Apple Silicon, cela ne vous concerne pas.

Les problèmes de droits d'accès peuvent compliquer l'usage des volumes. Si vous montez un répertoire hôte au lieu d'un volume nommé, Ollama peut ne pas être en mesure d'écrire les fichiers de modèle à cause d'incohérences de permissions. Les volumes nommés comme -v ollama:/root/.ollama évitent totalement ce problème.

La mise en cache des modèles entre redémarrages fonctionne automatiquement avec un montage de volume adéquat. Vos modèles téléchargés persistent dans le volume Docker : arrêter et redémarrer les conteneurs ne nécessite pas de tout rétélécharger. Mais si vous supprimez par erreur le volume ou oubliez l'option -v, vous perdrez tous vos modèles.

Gardez ces remèdes en tête :

• Le conteneur ne démarre pas ? Vérifiez si le port 11434 est déjà utilisé
• Les modèles se téléchargent lentement ? Contrôlez votre connexion et les ressources allouées à Docker
• Les requêtes API expirent ? Augmentez les limites mémoire de Docker pour les gros modèles
• Le GPU n'est pas détecté ? Vérifiez les pilotes NVIDIA et l'installation du Container Toolkit

L'oubli du montage de volume et la disparition des modèles est le problème le plus courant.

Conclusion

Docker rend l'exécution de LLM locaux simple, portable et propre.

Vous bénéficiez d'une confidentialité par conception : vos données ne quittent jamais votre machine. Vous obtenez des coûts prévisibles : pas de factures d'API surprises ni de limitations. Et vous gardez le contrôle total de votre stack IA, sans verrouillage fournisseur ni dépendance Internet.

La configuration prend quelques minutes.

Récupérez l'image, lancez le conteneur, téléchargez un modèle, et vous pouvez commencer à construire. Que vous prototypiez un assistant IA, exécutiez des pipelines RAG privés ou testiez simplement différents modèles, cette combinaison vous apporte des capacités de niveau entreprise sur votre ordinateur portable.

Essayez maintenant. Choisissez un modèle adapté à votre matériel, lancez le conteneur Ollama et passez à l'action. La barrière à l'entrée n'existe pas.

Pour aller plus loin, nous vous recommandons de configurer et d'exécuter DeepSeek R1 en local avec Ollama.