# Comment installer son propre serveur Ollama ?

Selon l’utilisation prévue, différents types de serveurs peuvent être pertinents pour faire fonctionner Ollama. Pour de petits chatbots, un VPS suffisamment puissant suffit souvent. En revanche, les agents IA, les charges de travail liées au coding ou les modèles très volumineux nécessitent généralement un GPU, voire un matériel dédié. Ollama simplifie considérablement l’exécution de grands modèles de langage en local ou sur un serveur : il gère les modèles, les lance et les rend accessibles via une API simple.

## Qu’est-ce qu’Ollama ?

Ollama est un logiciel qui permet d’exécuter des [grands modèles de langage (LLM)](https://www.ionos.fr/digitalguide/serveur/know-how/large-language-model/) comme Gemma, Qwen, DeepSeek ou d’autres modèles compatibles **localement ou sur votre propre serveur**. Le logiciel propose une interface en ligne de commande simple ainsi qu’une API [REST](https://www.ionos.fr/digitalguide/serveur/know-how/rest-la-solution-http-pour-les-services-web/), qui permettent de lancer des modèles et de les intégrer dans vos propres applications. Ollama ne sert donc pas seulement à discuter avec un modèle dans le terminal, mais aussi de **moteur d’exécution de modèles** pour vos propres outils, assistants ou environnements de développement.

Ollama est particulièrement intéressant pour les utilisatrices et utilisateurs qui ne souhaitent pas interroger des modèles via un service [Cloud](https://www.ionos.fr/digitalguide/serveur/know-how/quest-ce-que-le-cloud/) tiers, mais **les exécuter sur leur propre infrastructure**. Lorsque vous utilisez des modèles locaux, les interactions se font en local, et le logiciel prend en charge le chargement et l’exécution des modèles ainsi que l’accès via la CLI ou l’[API](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/quest-ce-quune-api/). Pour les débutants, c’est pratique, car ils n’ont pas besoin de créer eux-mêmes un environnement d’inférence complet à partir de zéro et peuvent démarrer avec quelques commandes seulement.

Note Dans de nombreux projets d’IA, Ollama sert uniquement de backend de modèles : il exécute les modèles de langage localement ou sur un serveur Ollama et les expose via une API. Sur cette base, il est possible d’utiliser des frameworks d’agents comme OpenClaw avec Ollama pour automatiser des flux de travail complexes. Dans ce type de configuration, Ollama prend en charge l’inférence des modèles, tandis qu’OpenClaw gère des tâches comme l’utilisation d’outils, les processus d’agents multi-étapes ou les actions automatisées.

## Quel serveur convient à votre projet ?

Avant de commencer l’installation, vous devez définir précisément l’usage prévu pour Ollama. **Toutes les applications n’ont pas besoin d’un GPU**, mais les exigences augmentent rapidement dès que vous souhaitez obtenir des réponses fluides, traiter plusieurs requêtes en parallèle ou utiliser des modèles d’[intelligence artificielle](https://www.ionos.fr/digitalguide/web-marketing/vendre-sur-internet/quest-ce-que-lintelligence-artificielle/) plus volumineux. **La taille du modèle est un facteur déterminant** : à titre indicatif, Ollama recommande au moins 8 Go de [mémoire vive (RAM)](https://www.ionos.fr/digitalguide/serveur/know-how/quest-ce-quune-memoire-vive/) pour les modèles 7B, au moins 16 Go de RAM pour les modèles 13B et au moins 64 Go de RAM pour les modèles 70B, mais les besoins réels varient selon le modèle, la quantification et la taille du contexte. La quantité de VRAM disponible sur le GPU joue également un rôle important, car elle influence fortement la vitesse, la longueur du contexte et l’utilisabilité pratique.

### Cas d’usage 1 : tâches textuelles simples, tests et petits chatbots

Si vous souhaitez utiliser Ollama principalement pour des essais, de la génération de texte simple, de petits bots d’assistance ou des tests internes, un [serveur privé virtuel (VPS)](https://www.ionos.fr/serveurs/vps "VPS | Serveur virtuel pas cher | IONOS France") suffisamment performant sans GPU dédié est suffisant. Dans ce scénario, ce sont dans la plupart des cas **de petits modèles d’IA** qui tournent. Ceux-ci nécessitent au minimum 8 Go de RAM, mais en pratique, il est **judicieux de prévoir une marge** afin que le système d’exploitation, [Docker](https://www.ionos.fr/digitalguide/serveur/know-how/quest-ce-que-docker/) et les processus en arrière-plan ne ralentissent pas le serveur. Pour un serveur Ollama de démarrage, 16 Go de RAM constituent donc une base plus confortable, même si certains petits modèles d’IA peuvent fonctionner avec moins de mémoire. Prévoyez un espace de stockage suffisant, car en plus de l’installation Docker, il faut enregistrer les fichiers de modèles, qui peuvent rapidement atteindre plusieurs gigaoctets.

Le grand avantage d’un VPS réside dans ses **coûts maîtrisables et sa mise à disposition simple**. Son principal inconvénient est une vitesse nettement inférieure à celle des serveurs GPU. Pour l’apprentissage, les projets de démonstration et les API simples, un VPS avec 4 vCPU, 16 Go de RAM et un stockage [SSD](https://www.ionos.fr/digitalguide/serveur/know-how/quest-ce-quun-ssd/) constitue néanmoins une bonne option de départ.

### Cas d’usage 2 : bots de connaissances internes, petites API et embeddings

Si vous souhaitez utiliser Ollama comme backend pour une petite base de connaissances interne, pour la [Retrieval-Augmented Generation (RAG)](https://www.ionos.fr/digitalguide/serveur/know-how/retrieval-augmented-generation/) ou pour des embeddings, les exigences deviennent plus élevées. Il ne s’agit plus seulement de générer une réponse de chat ponctuelle, mais souvent de gérer des appels API répétés, des traitements en arrière-plan et un fonctionnement plus stable dans la durée. Ces scénarios peuvent encore fonctionner sur un serveur [CPU](https://www.ionos.fr/digitalguide/serveur/know-how/cpu/) ou un grand VPS, mais **davantage de mémoire vive** devient important afin que les modèles et les données n’aient pas à être rechargés en permanence. Un serveur avec 16 à 32 Go de RAM est nettement plus confortable pour ce type de tâches.

Si plusieurs utilisateurs accèdent simultanément au service, il peut aussi être intéressant d’opter pour un processeur avec plus de cœurs ou de passer à un [serveur GPU](https://www.ionos.fr/digitalguide/serveur/know-how/gpu-server/). Ollama prend en charge, en plus de la génération de texte, les embeddings via l’API, ce qui le rend intéressant pour les applications de recherche et de gestion des connaissances. Pour de petites équipes ou des outils internes, un grand VPS ou un petit [serveur dédié](https://www.ionos.fr/serveurs/serveurs-dedies "Serveurs Dédiés | Hébergement pas cher avec Windows ou Linux | IONOS") sans GPU peut donc déjà suffire, à condition de ne pas exiger des temps de réponse extrêmement faibles. En revanche, ceux qui souhaitent une **expérience utilisateur vraiment fluide** devraient envisager un GPU, même dans ce cas. De manière générale, plus votre service est interactif et utilisé en parallèle, plus un serveur purement CPU atteindra rapidement ses limites.

### Cas d’usage 3 : assistants de programmation et agents fluides

Dès qu’Ollama doit être utilisé pour des assistants de programmation, des agents semi-autonomes ou d’autres flux de travail interactifs, un GPU devient fortement recommandé. La raison est simple : ce type d’applications profite énormément d’une génération de réponses rapide et de modèles capables de traiter un contexte plus large de manière fluide. Les longueurs de contexte standard dépendent notamment **de la quantité de VRAM disponible**. Pour les agents, la recherche Web, les outils de développement ou des contextes de travail plus longs, la documentation recommande au moins 64 000 [AI‑Tokens](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/les-token-ia/) de contexte.

Il devient ainsi clair qu’un simple VPS avec CPU n’est généralement pas le choix idéal pour de tels projets. Un [serveur Cloud](https://www.ionos.fr/digitalguide/serveur/know-how/quest-ce-quun-serveur-cloud/) avec GPU NVIDIA récent, combiné à une quantité suffisante de RAM et à un stockage [NVMe](https://www.ionos.fr/digitalguide/serveur/know-how/quest-ce-que-nvme/) rapide, est plus approprié. Cela permet d’exécuter des modèles de taille moyenne de manière nettement plus confortable. Des **flux de travail d’agents multi‑étapes** deviennent également praticables de cette façon. Pour des projets individuels ambitieux, des prototypes et des équipes de développement, c’est le meilleur compromis entre coûts et performances.

### Cas d’usage 4 : applications professionnelles avec plusieurs utilisateurs

Si vous souhaitez utiliser Ollama comme **élément fixe d’une application professionnelle**, les exigences évoluent à nouveau. Il ne s’agit plus seulement de savoir si un modèle fonctionne en principe, mais s’il tourne de manière stable, reproductible et performante sous charge. Dans de tels scénarios, vous devez prévoir suffisamment de RAM, un GPU performant, des marges pour plusieurs processus parallèles, de la supervision et assez d’espace de stockage pour plusieurs modèles. Comme Ollama met les modèles à disposition via une API, il peut très bien servir de backend de modèles interne, mais le choix du serveur doit être conçu en fonction de la disponibilité et du comportement sous charge.

Un serveur dédié GPU performant ou un serveur Cloud GPU professionnel est ici, en règle générale, un bien meilleur choix qu’un petit VPS. Dans ce domaine, 64 Go de RAM ou plus sont judicieux, associés à un GPU NVIDIA puissant et à une **infrastructure d’exploitation propre avec stockage persistant** pour les fichiers de modèles. Pour les applications en production en particulier, il est important que Docker et, le cas échéant, la configuration de NVIDIA Container Toolkit soient correctement mis en place, afin que le GPU puisse réellement être utilisé dans le [conteneur Docker](https://www.ionos.fr/digitalguide/serveur/know-how/les-docker-containers/).

### Cas d’usage 5 : modèles très grands et inférence haut de gamme

Si vous souhaitez exécuter des modèles très volumineux de l’ordre de 70B ou plus, vous entrez clairement dans le segment haut de gamme. Pour les modèles 70B, Ollama indique au moins 64 Go de RAM comme exigence minimale approximative. En pratique, les serveurs basés sur la [virtualisation](https://www.ionos.fr/digitalguide/serveur/configuration/la-virtualisation/) ne suffisent pas dans ce cas, en particulier si les temps de réponse doivent être bons ou si plusieurs processus tournent en parallèle. Pour de tels scénarios, un **serveur dédié avec un matériel GPU très performant** est nettement plus réaliste qu’un VPS classique.

Dans un contexte professionnel, cela implique des systèmes GPU spécialisés avec beaucoup de VRAM, par exemple des serveurs équipés de cartes NVIDIA A100 ou [NVIDIA H100](https://www.ionos.fr/digitalguide/serveur/know-how/nvidia-h100/) ou d’environnements haute performance dotés de caractéristiques comparables. C’est coûteux, mais pour les grands modèles, les contextes longs et les charges de travail productives haut de gamme, c’est **quasiment incontournable**.

### Vue d’ensemble : quel serveur pour quel usage ?

<table>
  <thead>
    <tr>
      <th><strong>Objectif</strong></th>
      <th><strong>Matériel recommandé</strong></th>
      <th><strong>Coûts estimés</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><strong>Bot ou API simple</strong></td>
      <td>VPS avec 4 vCPU, 16 Go de RAM et SSD</td>
      <td>+</td>
    </tr>
    <tr>
      <td><strong>Bots internes de gestion des connaissances ou embeddings</strong></td>
      <td>Grand VPS ou petit serveur dédié avec 16 à 32 Go de RAM</td>
      <td>+ / ++</td>
    </tr>
    <tr>
      <td><strong>Coding et agents IA</strong></td>
      <td>Serveur Cloud GPU avec GPU moderne</td>
      <td>++</td>
    </tr>
    <tr>
      <td><strong>Applications professionnelles</strong></td>
      <td>Serveur Cloud GPU performant ou serveur dédié avec beaucoup de RAM</td>
      <td>++ / +++</td>
    </tr>
    <tr>
      <td><strong>High-end, 70B et plus</strong></td>
      <td>Serveur dédié avec A100, H100 ou GPU haut de gamme comparable</td>
      <td>+++</td>
    </tr>
  </tbody>
</table>

**Légende des coûts** : + = faible, ++ = moyen, +++ = élevé

## Comment installer Ollama avec Docker sur un serveur ?

Dans la section suivante, nous présentons l’installation d’Ollama avec Docker sur un serveur Linux. Pour les débutants, la combinaison **Ollama avec Docker** est particulièrement pratique, car Ollama s’exécute dans un conteneur et nécessite moins de modifications directes du système. Pour utiliser l’accélération GPU sous Linux avec une carte NVIDIA, vous avez en plus besoin du NVIDIA Container Toolkit afin que Docker puisse transmettre le GPU au conteneur.

### Étape 1 : se connecter au serveur

Connectez-vous d’abord en SSH à votre serveur. Pour cela, vous avez besoin de l’adresse IP du serveur ainsi que d’un utilisateur disposant de droits sudo.

```bash
ssh NOM_UTILISATEUR@ADRESSE_IP_DU_SERVEUR
```

Lorsque vous vous connectez pour la première fois, votre système vous demande de confirmer la clé de l’hôte. Saisissez `yes`, puis votre mot de passe ou utilisez votre clé SSH. Vous vous trouvez ensuite dans le **terminal de votre serveur** et pouvez commencer la configuration.

### Étape 2 : mettre le système à jour

Avant d’installer Docker et Ollama, vous devez mettre à jour les listes de paquets et actualiser les paquets existants. Vous vous assurez ainsi que votre système utilise les dernières mises à jour de sécurité et versions de paquets. Sur les serveurs fraîchement déployés, c’est une première étape judicieuse avant d’installer d’autres logiciels.

```bash
sudo apt update && sudo apt upgrade -y
```

### Étape 3 : installer Docker

Pour Ubuntu 24.04, Docker recommande l’installation via le dépôt APT officiel. Le fichier de dépôt actuel au format Deb822 est alors configuré sous `/etc/apt/sources.list.d/docker.sources`. Sont notamment pris en charge Ubuntu 24.04 et plusieurs architectures comme amd64 et arm64. Pour cela, installez d’abord les paquets auxiliaires nécessaires :

```bash
sudo apt install ca-certificates curl -y
```

Créez ensuite le répertoire pour le trousseau de clés :

```bash
sudo install -m 0755 -d /etc/apt/keyrings
```

Téléchargez ensuite la clé officielle de Docker :

```bash
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc
```

Configurez maintenant le dépôt Docker comme suit :

```bash
sudo tee /etc/apt/sources.list.d/docker.sources <<EOF
Types: deb
URIs: https://download.docker.com/linux/ubuntu
Suites: $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}")
Components: stable
Signed-By: /etc/apt/keyrings/docker.asc
EOF
```

Mettez ensuite de nouveau à jour la liste des paquets :

```bash
sudo apt update
```

Installez Docker Engine, y compris le plugin Compose :

```bash
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y
```

Vérifiez ensuite que Docker fonctionne correctement :

```bash
sudo systemctl status docker
```

Vous devriez voir l’indication `active (running)`, qui confirme que Docker est en cours d’exécution.

[![Image: Indicateur d’état de Docker sur votre serveur Ollama](https://www.ionos.fr/digitalguide/fileadmin/_processed_/4/5/csm_ollama-docker-status_f2f06d92e5.webp "Indicateur d’état de Docker sur votre serveur Ollama")](https://www.ionos.fr/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/ollama-docker-status.jpg) L’indication « active » confirme que Docker est en cours d’exécution. Vous pouvez lancer un conteneur de test :

```bash
sudo docker run hello-world
```

Si un message de confirmation s’affiche, Docker est installé avec succès.

[![Image: Conteneur Hello-World sur votre serveur Ollama](https://www.ionos.fr/digitalguide/fileadmin/_processed_/1/4/csm_ollama-docker-hello-world_8f4acb83c1.webp "Conteneur Hello-World sur votre serveur Ollama")](https://www.ionos.fr/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/ollama-docker-hello-world.jpg) Si Docker est installé avec succès, vous pouvez lancer le conteneur Hello-World comme premier test. ### Étape 4 : utiliser Docker sans sudo (optionnel)

Par défaut, Docker est généralement exécuté avec `sudo` sous Linux. Si vous souhaitez malgré tout utiliser Docker sans `sudo`, exécutez ces commandes :

```bash
sudo groupadd docker
sudo usermod -aG docker $USER
newgrp docker
```

Vous devrez peut-être vous déconnecter puis vous reconnecter pour que l’appartenance au groupe soit pleinement prise en compte. Vous pouvez ensuite tester si Docker fonctionne sans `sudo` :

```bash
docker run hello-world
```

### Étape 5 : installer le NVIDIA Container Toolkit pour les GPU NVIDIA

Cette étape est **nécessaire uniquement si votre serveur dispose d’un GPU NVIDIA** et si vous souhaitez qu’Ollama utilise ce GPU dans le conteneur Docker. Commencez par installer les paquets nécessaires :

```bash
sudo apt-get update && sudo apt-get install -y --no-install-recommends ca-certificates curl gnupg2
```

Ajoutez ensuite le dépôt NVIDIA :

```bash
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg
curl -s -L 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
```

Mettez à jour la liste des paquets et installez le toolkit :

```bash
sudo apt-get update
sudo apt-get install -y nvidia-container-toolkit
```

Configurez Docker pour la prise en charge du runtime NVIDIA :

```bash
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker
```

Si vos pilotes GPU sont correctement installés et que nvidia-smi fonctionne sur l’hôte, Docker pourra ensuite transmettre les ressources GPU aux conteneurs.

### Étape 6 : démarrer le conteneur Ollama

Vous pouvez maintenant démarrer Ollama lui‑même comme conteneur Docker. L’image officielle s’appelle `ollama/ollama`. Pour un fonctionnement uniquement sur CPU, utilisez la commande suivante :

```bash
sudo docker run -d \
-v ollama:/root/.ollama \
-p 11434:11434 \
--name ollama \
ollama/ollama
```

Si vous utilisez un GPU NVIDIA et que vous avez déjà terminé l’étape 5, démarrez le conteneur de cette façon :

```bash
sudo docker run -d \
--gpus=all \
-v ollama:/root/.ollama \
-p 11434:11434 \
--name ollama \
ollama/ollama
```

### Étape 7 : vérifier si le conteneur est en cours d’exécution

Vérifiez ensuite avec la commande suivante dans le terminal si le conteneur a bien été démarré sur votre serveur Ollama :

```bash
sudo docker ps
```

Dans la sortie, un conteneur portant le nom `ollama` doit apparaître. Vous devez également voir que le port 11434 a été publié ; dans cette configuration, il peut être accessible depuis d’autres machines selon les règles réseau et firewall.

[![Image: Capture d’écran de la sortie de docker ps](https://www.ionos.fr/digitalguide/fileadmin/_processed_/4/3/csm_ollama-docker-container_e2e71f111b.webp "Capture d’écran de la sortie de docker ps")](https://www.ionos.fr/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/ollama-docker-container.jpg) La commande « docker ps » fournit un aperçu de vos conteneurs. Le conteneur Ollama devrait maintenant y apparaître. ### Étape 8 : télécharger et démarrer un premier modèle

Dès que le conteneur est en cours d’exécution, vous pouvez **démarrer un modèle**. La documentation officielle montre à titre d’exemple l’appel via `docker exec`. Vous exécutez ainsi la commande Ollama directement dans le conteneur en cours d’exécution.

```bash
sudo docker exec -it ollama ollama run llama3
```

Lors du premier démarrage, Ollama télécharge d’abord le modèle. Selon la taille du modèle et la connexion de votre serveur, cela peut **prendre un certain temps**. Vous accédez ensuite à une console interactive dans laquelle vous pouvez poser des questions directement.

[![Image: Ollama avec Llama3](https://www.ionos.fr/digitalguide/fileadmin/_processed_/e/1/csm_ollama-run-llama3_a8fb667e84.webp "Ollama avec Llama3")](https://www.ionos.fr/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/ollama-run-llama3.jpg) Après avoir démarré Llama3 (ou un autre modèle de langage), vous pouvez interagir avec le LLM dans la console de chat. Si vous préférez essayer un autre modèle que [Llama3](https://www.ionos.fr/digitalguide/serveur/know-how/llama-3/), vous pouvez utiliser un autre nom de modèle en conséquence. Vous trouverez les modèles disponibles dans la bibliothèque Ollama. La documentation y mentionne notamment des modèles récents comme **Gemma 3, Qwen3, DeepSeek-R1** et d’autres.

### Étape 9 : tester l’API Ollama

Ollama met automatiquement à disposition une API locale après le démarrage. Selon la documentation officielle, l’URL de base par défaut est `http://localhost:11434/api`. Vous pouvez effectuer un test simple directement sur le serveur avec `curl`.

Un exemple de requête de génération simple avec le modèle précédemment téléchargé pourrait ressembler à ceci :

```bash
curl http://localhost:11434/api/generate -d '{
"model": "gemma3",
"prompt": "Expliquez en deux phrases ce qu’est Ollama.",
"stream": false
}'
```

Si tout fonctionne correctement, vous recevez une réponse JSON du modèle. Vous savez ainsi que non seulement le conteneur est en cours d’exécution, mais aussi que l’API est accessible correctement.

[![Image: Appel à l’API Ollama](https://www.ionos.fr/digitalguide/fileadmin/_processed_/7/8/csm_ollama-api-answer-json_1ebf695bf6.webp "Appel à l’API Ollama")](https://www.ionos.fr/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/ollama-api-answer-json.jpg) L’API vous fournit directement la réponse au format JSON. ### Étape 10 : utiliser Docker Compose comme alternative

Pour un serveur Ollama fonctionnant en continu, [Docker Compose](https://www.ionos.fr/digitalguide/serveur/configuration/tutoriel-docker-compose/) est souvent **plus pratique** qu’une longue commande `docker run`. Vous pouvez ainsi enregistrer la configuration dans un fichier et la modifier plus facilement par la suite. Créez d’abord un répertoire pour votre configuration :

```bash
mkdir -p ~/ollama
cd ~/ollama
```

Créez ensuite un fichier nommé `compose.yaml`. Nous utilisons ici l’éditeur nano, mais vous pouvez utiliser n’importe quel éditeur de texte :

```bash
nano compose.yaml
```

Pour un fonctionnement sur CPU, insérez le contenu suivant :

```yaml
services:
    ollama:
        image: ollama/ollama
        container_name: ollama
        ports:
            - "11434:11434"
        volumes:
            - ollama:/root/.ollama
        restart: unless-stopped
volumes:
    ollama:
```

Pour un fonctionnement sur GPU NVIDIA, vous pouvez ajouter une configuration GPU selon votre environnement Docker. En pratique, pour les débutants, la variante la plus simple et la plus facile à reproduire reste le démarrage direct avec `docker run --gpus=all`, car les configurations Compose peuvent légèrement varier selon la version de Docker. L’essentiel est dans tous les cas que Docker utilise correctement l’environnement d’exécution NVIDIA. NVIDIA décrit explicitement cette condition préalable dans la documentation de son Toolkit.

Démarrez ensuite le service avec la commande suivante :

```bash
sudo docker compose up -d
```

[![Image: Démarrer le conteneur avec Compose](https://www.ionos.fr/digitalguide/fileadmin/_processed_/7/1/csm_ollama-docker-compose_c5242c6946.webp "Démarrer le conteneur avec Compose")](https://www.ionos.fr/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/ollama-docker-compose.jpg) La gestion du conteneur Ollama avec Docker Compose est plus pratique en cas d’utilisation fréquente. Vérifiez à nouveau le statut :

```bash
sudo docker compose ps
```

[![Image: Statut du conteneur](https://www.ionos.fr/digitalguide/fileadmin/_processed_/7/3/csm_ollama-container-status-compose_c12a87cd84.webp "Statut du conteneur")](https://www.ionos.fr/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/ollama-container-status-compose.jpg) Vous pouvez afficher le statut de votre conteneur Ollama avec Compose. ### Étape 11 : indications importantes pour l’utilisation pratique

Si vous souhaitez utiliser Ollama avec Docker en production ou le mettre à disposition d’autres appareils sur le réseau, vous ne devez pas exposer le service sur Internet sans mesures de protection. Ollama utilise par défaut le port 11434. Dans la configuration Docker présentée ici, l’API est publiée sur l’hôte via `-p 11434:11434`. Selon la configuration de votre réseau et de votre [firewall](https://www.ionos.fr/digitalguide/serveur/securite/quest-ce-quun-pare-feu/), elle peut donc être accessible depuis l’extérieur. Pour limiter l’accès au serveur lui-même, liez plutôt le port uniquement à `127.0.0.1`, par exemple avec `-p 127.0.0.1:11434:11434`, puis définissez des règles de firewall adaptées et restrictives.

Gardez à l’esprit que les modèles sont stockés localement et qu’il faut donc prévoir suffisamment d’espace disque. Les modèles sont stockés dans le volume Docker ollama, ce qui peut rapidement représenter plusieurs gigaoctets selon les modèles téléchargés. Sous Linux, le même principe s’applique : les modèles occupent beaucoup d’espace. Pour les contextes longs, les agents IA ou les applications de développement, **la quantité de VRAM disponible est également importante**, car Ollama adapte la longueur de contexte standard en fonction de la VRAM disponible.


This is a markdown version of: [https://www.ionos.fr/digitalguide/serveur/configuration/ollama-docker/](https://www.ionos.fr/digitalguide/serveur/configuration/ollama-docker/) for AI/LLM consumption.