Ollama : sécuriser une API sans mot de passe
Ollama n’active aucune authentification : toute machine joignant le port 11434 peut exécuter vos modèles, en télécharger et les supprimer. Voici 3 correctifs.
L’API Ollama n’a pas de mot de passe
L’API Ollama n’utilise aucune authentification. Il n’y a ni utilisateur, ni mot de passe ni vérification de clé API pour les clients entrants. Toute personne pouvant ouvrir une connexion TCP vers le port 11434 peut lister vos modèles, les exécuter, en télécharger de nouveaux et supprimer ceux que vous avez installés.
La documentation officielle l’indique clairement : « L’API locale à http://localhost:11434 ne nécessite pas d’authentification. » Le terme locale définit à lui seul le modèle de sécurité. Ollama est lié par défaut à 127.0.0.1. Sur un ordinateur portable, l’interface loopback constitue donc le contrôle d’accès. Déplacez cette écoute vers une adresse publique et le contrôle d’accès disparaît, car rien ne le remplace.
C’est la raison pour laquelle ce point est important sur un VPS (virtual private server). La configuration par défaut est sûre. La première modification effectuée par la plupart des utilisateurs consiste à ouvrir l’écoute pour qu’une deuxième machine puisse utiliser le modèle. C’est précisément la modification qui supprime toutes les protections en une seule fois.
Ce qu’un port 11434 ouvert révèle
Chaque endpoint est accessible. Il n’existe ni mode en lecture seule ni port d’administration distinct. Voici les requêtes réelles, envoyées à l’adresse du serveur au lieu de localhost :
# List every model on the box
curl http://SERVER_IP:11434/api/tags
# See what is loaded into memory right now
curl http://SERVER_IP:11434/api/ps
# Run a prompt on your hardware
curl http://SERVER_IP:11434/api/generate -d '{"model":"llama3.2","prompt":"Why is the sky blue?"}'
# Write several gigabytes to your disk
curl http://SERVER_IP:11434/api/pull -d '{"model":"llama3.2"}'
# Remove a model
curl -X DELETE http://SERVER_IP:11434/api/delete -d '{"model":"llama3.2"}'Pour l’opérateur, quatre problèmes se posent :
- Votre CPU ou votre GPU exécute des inférences pour quelqu’un d’autre. Avec une offre qui applique une limite d’utilisation raisonnable du CPU, une charge soutenue consomme cette allocation pour le compte d’un inconnu. Maîtriser les coûts des workloads d’IA sur un VPS devient beaucoup plus difficile dès lors que vous n’êtes plus le seul appelant.
/api/pullécrit sur votre disque. La taille des modèles varie ; mêmellama3.2:1bfait 1.3 GB. Une boucle de téléchargements remplit le volume, et un disque plein interrompt tous les autres services de la machine, pas seulement Ollama.- Les requêtes arrivent dans votre processus et sont journalisées. Avec le niveau de log par défaut, Ollama enregistre uniquement les métadonnées : endpoint, statut, latence et adresse du client, mais pas le texte du prompt. Cela constitue tout de même une trace de l’utilisateur de votre machine et de son usage, stockée dans votre journal, sans que vous ayez choisi de la collecter.
/api/deletesupprime des modèles. Pour les récupérer, vous devez les télécharger à nouveau en utilisant votre propre bande passante.
Aucun exploit n’est nécessaire. Il s’agit de l’API documentée, qui fonctionne exactement comme prévu.
La clé Ed25519 ne contrôle pas l’accès
Recherchez « Ollama API key » et vous trouverez deux éléments différents. Aucun des deux n’est le mot de passe de votre serveur. Les distinguer élimine la plupart des confusions.
Le premier est la paire de clés d’identité. Ollama génère une paire de clés Ed25519 lors de sa première exécution. Sous Linux, le script d’installation crée un utilisateur système nommé ollama, avec son répertoire personnel dans /usr/share/ollama. La paire se trouve donc ici :
/usr/share/ollama/.ollama/id_ed25519
/usr/share/ollama/.ollama/id_ed25519.pubCette clé sert pour les connexions sortantes. ollama signin enregistre la partie publique auprès de votre compte ollama.com. C’est elle qui vous autorise à pousser un modèle vers le registre ou à en extraire un modèle privé. Elle authentifie votre machine auprès d’ollama.com. Elle ne demande rien aux clients qui se connectent à votre machine. La supprimer, la renouveler ou ne jamais la créer ne change rien aux personnes autorisées à appeler votre API.
Le second est OLLAMA_API_KEY. Cette variable contient une clé que vous créez dans https://ollama.com/settings/keys. Votre client l’envoie sous la forme Authorization: Bearer $OLLAMA_API_KEY lorsqu’il appelle l’API hébergée à l’adresse https://ollama.com/api. Il s’agit d’un identifiant d’authentification pour leur service, que vous utilisez en tant que client. Votre propre ollama serve ne l’utilise pas pour authentifier les requêtes entrantes. Définir OLLAMA_API_KEY sur votre VPS n’ajoute pas de mot de passe à votre VPS.
Il n’y a donc aucun paramètre à activer. Les trois protections ci-dessous fonctionnent de la même manière : rendez le port inaccessible et placez devant lui un composant qui effectue réellement un contrôle.
Vérifiez ce sur quoi votre serveur est actuellement en écoute
sudo ss -tlnp | grep 11434Le résultat sûr mentionne l’adresse loopback :
LISTEN 0 4096 127.0.0.1:11434 0.0.0.0:* users:(("ollama",pid=812,fd=3))Le résultat exposé mentionne toutes les interfaces :
LISTEN 0 4096 0.0.0.0:11434 0.0.0.0:* users:(("ollama",pid=812,fd=3))0.0.0.0 désigne toutes les adresses IPv4 de la machine, y compris l’adresse publique. *:11434 et [::]:11434 sont des listeners wildcard sur toutes les adresses IPv6. Leur capacité à accepter aussi l’IPv4 dépend de l’option IPV6_V6ONLY du socket, que Linux désactive par défaut (net.ipv6.bindv6only=0). Considérez donc chacun des trois résultats comme une exposition.
Vérifiez maintenant depuis l’extérieur. Exécutez cette commande sur votre ordinateur portable, et non sur le serveur :
curl -m 5 http://YOUR_SERVER_IP:11434/api/versioncurl: (28) Connection timed out after 5001 milliseconds est le résultat attendu, tout comme curl: (7) Failed to connect ... Connection refused. Un objet JSON contenant un champ version signifie que toute l’API est accessible à quiconque en fait la demande. Tester avec curl directement sur le serveur ne permet pas d’établir si une autre machine peut y accéder. Si le serveur possède une adresse IPv6, répétez le test avec curl -6 -m 5 http://[YOUR_SERVER_IPV6]:11434/api/version, car un port IPv4 fermé ne dit rien sur un listener IPv6.
L’exposition survient généralement de deux façons. La première est une modification volontaire, parce qu’une personne devait permettre à une deuxième machine d’accéder au modèle :
sudo systemctl edit ollama.service[Service]
Environment="OLLAMA_HOST=0.0.0.0:11434"Cette seule ligne suffit à exposer le service. La deuxième façon est Docker, qui ne vous demande aucune modification. Cette méthode fait l’objet d’une section distincte plus loin dans ce document.
Défense 1 : le laisser sur localhost et créer un tunnel
Commencez par cette solution. Elle ne nécessite aucun nouveau logiciel et ne crée aucun identifiant susceptible de fuir. Le port n’existe jamais sur une interface publique. Un scan ne peut donc pas le trouver.
Définissez explicitement l’adresse d’écoute au lieu de vous fier à la valeur par défaut :
sudo systemctl edit ollama.service[Service]
Environment="OLLAMA_HOST=127.0.0.1:11434"Cette commande écrit /etc/systemd/system/ollama.service.d/override.conf. Appliquez la modification et vérifiez :
sudo systemctl daemon-reload
sudo systemctl restart ollama
sudo ss -tlnp | grep 11434ss doit maintenant afficher 127.0.0.1:11434. Si 0.0.0.0 s’affiche encore, un second fichier drop-in est prioritaire. Exécutez systemctl cat ollama.service pour lister l’unité et tous les fichiers drop-in avec leur chemin, puis supprimez celui qui est obsolète.
Pour utiliser le modèle depuis votre ordinateur portable, transférez le port via SSH :
ssh -N -L 11434:127.0.0.1:11434 you@your-server-L 11434:127.0.0.1:11434 ouvre le port 11434 sur votre ordinateur portable et envoie tout ce qui y arrive vers 127.0.0.1:11434, du point de vue du serveur. -N indique à SSH de ne pas exécuter de commande distante. Le processus maintient donc simplement le tunnel ouvert. Tant que le tunnel fonctionne, cette commande fonctionne sur votre ordinateur portable :
curl -s http://localhost:11434/api/tagsVous rencontrerez deux erreurs. bind [127.0.0.1]:11434: Address already in use signifie que cette adresse et ce port locaux sont déjà utilisés, par Ollama, un autre tunnel SSH ou un autre programme. Choisissez donc un autre port local avec -L 11500:127.0.0.1:11434 et configurez votre client pour utiliser le port 11500. Si une requête effectuée via le tunnel renvoie une réponse vide, vérifiez ss sur le serveur et la sortie d’erreur de SSH avant de déterminer quel service a échoué.
Pour plusieurs machines clientes, un réseau privé est préférable à un tunnel par utilisateur. Connectez les machines à WireGuard ou Tailscale, puis liez Ollama à son adresse sur ce réseau plutôt qu’à 0.0.0.0 :
[Service]
Environment="OLLAMA_HOST=10.8.0.1:11434"Le port n’existe alors que sur une interface dont l’accès nécessite une clé. Cette solution résiste également à une erreur de pare-feu, car une règle qui autoriserait accidentellement tout le monde ne peut toujours pas exposer un service d’écoute absent de l’interface publique.
Défense 2 : un reverse proxy qui vérifie un bearer token
Lorsqu’un élément sur Internet doit appeler le modèle, laissez Ollama sur l’interface loopback et placez un proxy devant lui. Le proxy termine le TLS (Transport Layer Security) et rejette les requêtes qui ne contiennent pas le bon en-tête. Ollama continue d’accepter les connexions uniquement depuis 127.0.0.1 : le proxy est donc le seul point d’accès.
Générez d’abord un véritable token. N’en inventez pas un manuellement :
openssl rand -base64 36Voici un site nginx qui le vérifie :
map $http_authorization $ollama_ok {
default 0;
"Bearer PASTE_YOUR_GENERATED_TOKEN_HERE" 1;
}
server {
listen 443 ssl;
server_name llm.example.com;
ssl_certificate /etc/letsencrypt/live/llm.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/llm.example.com/privkey.pem;
location = /api/pull { return 403; }
location = /api/delete { return 403; }
location = /api/push { return 403; }
location / {
if ($ollama_ok = 0) { return 401; }
proxy_pass http://127.0.0.1:11434;
proxy_set_header Host 127.0.0.1:11434;
proxy_buffering off;
proxy_read_timeout 600s;
}
}Cinq lignes jouent ici un rôle réel. Chacune évite une erreur qui se produirait autrement.
if dans un bloc location est généralement une mauvaise idée avec nginx. Toutefois, un corps de exactement return est l’une des deux formes dont le comportement est prévisible. Cette utilisation est donc sûre.
location = /api/pull est une correspondance exacte. nginx lui donne la priorité sur le préfixe location /. Ces trois endpoints sont donc refusés avant même la vérification du token. Un token valide donne toujours accès aux autres endpoints de gestion du modèle, notamment /api/create et /api/blobs/:digest. Ces trois blocs n’empêchent donc pas toutes les écritures sur disque.
proxy_set_header Host 127.0.0.1:11434; est important, car Ollama examine les en-têtes entrants Host et Origin. Transmettre directement le nom d’hôte public du proxy peut produire un 403 Forbidden provenant d’Ollama plutôt que de nginx, ce qui complique le diagnostic. OLLAMA_ORIGINS est l’autre paramètre important pour un client browser qui doit être autorisé depuis une origine précise.
proxy_buffering off; est important, car Ollama diffuse sa réponse token par token. Lorsque le buffering est activé, nginx met la réponse en mémoire tampon avant de la transmettre. Cela retarde donc l’envoi des tokens diffusés.
proxy_read_timeout 600s; est important, car nginx utilise par défaut une valeur de 60 secondes. Ce délai s’applique entre deux lectures successives depuis Ollama, et non à l’ensemble de la réponse. Une réponse en streaming qui continue à produire des tokens réinitialise le délai à chaque token. Une requête pour laquelle Ollama n’envoie rien pendant 60 secondes déclenche ce délai. C’est notamment le cas d’une requête envoyée avec "stream": false, qui renvoie toute la réponse en une seule fois à la fin, ou lorsqu’un long silence précède l’arrivée du premier token. Le client reçoit 504 Gateway Time-out et /var/log/nginx/error.log enregistre upstream timed out (110: Connection timed out) while reading response header from upstream. La requête fonctionnait toujours. nginx a abandonné.
Rechargez la configuration et testez les deux chemins :
sudo nginx -t && sudo systemctl reload nginx
curl -s -o /dev/null -w '%{http_code}\n' https://llm.example.com/api/tags
curl -s -H "Authorization: Bearer YOUR_TOKEN" https://llm.example.com/api/tagsLa première commande doit afficher 401. La seconde doit afficher la liste de vos modèles. Si la première renvoie également la liste des modèles, vérifiez quel serveur et quelle location ont traité la requête, et si le rechargement a réussi. Un bloc map placé dans la mauvaise portée rend la configuration invalide. Il doit se trouver au niveau http. Placez-le donc dans un fichier sous /etc/nginx/conf.d/ ou au-dessus du bloc server, jamais à l’intérieur de server.
Caddy fournit le même service avec une authentification basic en quatre lignes. Cette solution convient mieux à un client browser qu’un bearer token :
llm.example.com {
basic_auth {
apiuser PASTE_BCRYPT_HASH_HERE
}
reverse_proxy 127.0.0.1:11434
}Exécutez caddy hash-password pour produire le hash bcrypt attendu. Notez le changement de nom : la directive s’appelait basicauth avant Caddy v2.8 et s’appelle désormais basic_auth. Caddy accepte toujours l’ancienne syntaxe comme alias obsolète. Une configuration copiée depuis un ancien guide se charge donc, mais Caddy avertit que basicauth est obsolète et vous demande d’utiliser basic_auth à la place. Renommez-la lorsque cet avertissement apparaît.
Quel que soit le proxy choisi, il s’agit d’un secret partagé unique pour tous les utilisateurs. Chaque client qui le détient dispose des mêmes accès. Pour le révoquer, vous devez modifier la configuration et mettre à jour tous les appelants en même temps.
Défense 3 : une gateway qui délivre des clés par client
Dès que plusieurs personnes ou applications appellent le modèle, un token partagé atteint vite ses limites. Vous ne pouvez pas déterminer quel client est à l’origine de la charge ni en isoler un sans les isoler tous. Une gateway prend la place du proxy, utilise la même API compatible avec OpenAI, délivre une clé distincte à chaque client et enregistre l’utilisation associée à chaque clé. Une gateway LiteLLM auto-hébergée est généralement la solution retenue. Elle ajoute des budgets par clé et des journaux de requêtes au contrôle d’accès.
La règle de la défense 1 ne change pas. Ollama est lié à 127.0.0.1, la gateway est le seul processus à lui parler et elle est le seul service à écouter sur un port public. Une gateway installée sur une machine où le port 11434 est toujours ouvert à Internet ne sert à rien, car les clients peuvent simplement la contourner.
Le piège du firewall : un port de conteneur publié contourne UFW
C’est pourquoi des instances exposées existent sur des serveurs dont les propriétaires ont correctement configuré le firewall.
UFW (uncomplicated firewall) écrit ses règles dans la chaîne INPUT de la table filter du kernel, et INPUT traite les paquets destinés à l’hôte lui-même. L’option -p de Docker écrit une règle de destination NAT (network address translation) dans la chaîne PREROUTING de la table nat, que le kernel évalue avant de déterminer la destination du paquet. Au moment où la décision de routage intervient, la destination a déjà été réécrite vers l’adresse du conteneur. Le paquet est donc forwardé plutôt que livré localement, et il traverse FORWARD au lieu de INPUT. Les règles INPUT d’UFW ne sont jamais consultées. Le paquet contourne donc le firewall au lieu de le traverser.
C’est pourquoi cette séquence laisse le port 11434 ouvert sur Internet :
sudo ufw default deny incoming
sudo ufw enable
docker run -d -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollamaet sudo ufw status indique toujours que le firewall est actif avec une politique par défaut qui refuse les connexions. Ces deux informations sont correctes en même temps. C’est précisément pour cette raison que l’on se fie à la mauvaise. Vous pouvez voir la règle responsable :
sudo iptables -t nat -L DOCKER -nLa correction consiste à indiquer une adresse dans l’option de publication :
docker rm -f ollama
docker run -d -v ollama:/root/.ollama -p 127.0.0.1:11434:11434 --name ollama ollama/ollama-p 11434:11434 n’indique aucune adresse de l’hôte. Docker publie donc le port sur toutes les adresses de l’hôte, en IPv4 (0.0.0.0) comme en IPv6 ([::]). En indiquant 127.0.0.1, vous liez le côté hôte du mapping à l’interface loopback. Votre tunnel SSH et votre reverse proxy peuvent toujours y accéder, mais pas Internet. Les versions de Docker antérieures à 28.0.0 comportent une exception : les machines du même segment réseau peuvent atteindre les ports publiés sur localhost. Effectuez donc la mise à niveau avant de compter sur cette protection. Recréer le conteneur ne présente aucun risque ici, car les modèles se trouvent dans le volume nommé ollama, et non dans le conteneur.
Vérifiez que les deux vues concordent :
docker port ollama
sudo ss -tlnp | grep 11434docker port ollama doit afficher 11434/tcp -> 127.0.0.1:11434. S’il affiche 0.0.0.0:11434 ou [::]:11434, le service est toujours exposé. Comprenez ce mécanisme une fois : il s’applique à chaque conteneur que vous publierez. Pourquoi les ports publiés par Docker contournent UFW détaille la chaîne DOCKER-USER et les règles qui persistent après un redémarrage de Docker. Si vous construisez encore la politique du firewall de l’hôte, Les règles UFW nécessaires sur un nouveau VPS présente la base à utiliser. Sur Rocky ou AlmaLinux, UFW n’est pas disponible. Consultez donc La même politique de base avec firewalld pour commencer.
Quel compte exécute le processus
Le script d’installation Linux crée un compte dédié et exécute le service avec ce compte :
useradd -r -s /bin/false -U -m -d /usr/share/ollama ollamaL’unité située dans /etc/systemd/system/ollama.service définit ensuite User=ollama et Group=ollama. Ne modifiez pas ces paramètres. Un ollama serve lancé manuellement dans un terminal s’exécute avec le compte de la session ouverte. Si ce compte est root, une API non authentifiée écrit alors des fichiers en tant que root. Vérifiez le compte utilisé :
ps -o user= -C ollamaLa réponse doit être ollama. Toute autre réponse signifie qu’un processus lancé manuellement s’exécute en parallèle de l’unité ou à sa place. Le même principe s’applique à chaque daemon que vous ajouterez ensuite, et la exécution des services avec des comptes disposant des privilèges minimaux permet de le faire correctement.
Vérifier que le endpoint de l’API Ollama est sécurisé
Quel que soit votre choix, un test permet de trancher. Il doit être exécuté depuis une autre machine :
curl -m 5 http://YOUR_SERVER_IP:11434/api/version
curl -m 5 http://YOUR_SERVER_IP:11434/api/tagsLes deux requêtes doivent expirer ou être refusées. Si vous avez mis en place un proxy, les deux mêmes chemins sur le hostname du proxy doivent renvoyer 401 sans identifiants, et du vrai JSON avec des identifiants.
Consultez ensuite une fois l’access log pour les requêtes effectuées pendant que le port était ouvert :
journalctl -u ollama --since "-30 days" | grep GINOllama écrit une ligne par requête et inclut l’adresse du client :
[GIN] 2026/08/12 - 14:01:10 | 200 | 103.965898ms | 127.0.0.1 | POST "/api/generate"Cette adresse provient de ClientIP() de Gin, qui vérifie également les en-têtes X-Forwarded-For et X-Real-IP envoyés par des trusted proxies. Une requête passant par un reverse proxy loopback peut donc afficher l’adresse publique du client, alors qu’Ollama est correctement lié à 127.0.0.1. La présence d’une adresse publique dans cette colonne ne prouve pas un accès direct au port 11434. De même, l’absence de lignes correspondantes ne prouve pas que personne n’a atteint ce port. Comparez les horodatages avec les journaux et la configuration de votre proxy. Utilisez le test de connexion externe pour vérifier l’exposition actuelle. Si la partie concernant les modèles est nouvelle pour vous, exécuter Ollama sur un VPS couvre l’installation, le dimensionnement du modèle et les limites de mémoire qui déterminent ce qui pourra réellement être chargé.
FAQ
Ollama possède-t-il une clé API ou un mot de passe ?
Non. Le serveur que vous exécutez n’utilise aucun mécanisme d’authentification, et la documentation officielle indique que l’API locale ne nécessite pas d’authentification. Les deux éléments appelés « clé API Ollama » servent à autre chose. La paire Ed25519 dans /usr/share/ollama/.ollama/ authentifie votre machine auprès de ollama.com afin que vous puissiez pousser des modèles et récupérer des modèles privés. OLLAMA_API_KEY est un identifiant que votre client envoie à l’API hébergée sur https://ollama.com/api. Votre propre ollama serve n’utilise aucun de ces éléments pour authentifier les clients entrants. Le contrôle d’accès doit donc être assuré par le réseau ou par un proxy placé en amont.
OLLAMA_HOST=0.0.0.0 est-il sûr si j’ai un firewall ?
Uniquement si le firewall bloque correctement l’accès à ce listener. 0.0.0.0 signifie que le listener existe réellement sur l’interface publique et que vous comptez uniquement sur le firewall pour empêcher l’accès. Un port Ollama publié par Docker nécessite une attention particulière, car la règle DNAT ajoutée par Docker dans la table nat est évaluée avant que le paquet n’atteigne la chaîne INPUT, où intervient UFW. Le paquet est donc forwardé et les règles INPUT d’UFW ne le voient jamais. Un bind sur 127.0.0.1 ou sur l’adresse d’un tunnel privé retire le listener de l’interface publique. Une erreur de configuration du firewall n’a alors plus rien à exposer.
Comment vérifier si mon port Ollama est ouvert sur Internet ?
Exécutez sudo ss -tlnp | grep 11434 sur le serveur, puis curl -m 5 http://YOUR_SERVER_IP:11434/api/version depuis une autre machine. Si ss affiche 127.0.0.1:11434 et que curl expire depuis la machine distante, c’est le résultat attendu. Si ss affiche 0.0.0.0:11434 ou *:11434 et que curl renvoie du JSON depuis la machine distante, l’API complète est accessible. Tester avec curl directement sur le serveur ne permet pas de déterminer si une autre machine peut y accéder.
Puis-je simplement remplacer le port 11434 par un port aléatoire ?
Non, et la raison mérite d’être précisée. Un autre port ne ralentit qu’un scan portant sur un seul port. Les scanners parcourent toute la plage, et une requête vers /api/tags identifie le service, quel que soit le port utilisé. Changer de port casse également les valeurs par défaut de tous les clients et rend votre configuration plus difficile à comprendre par la suite. Faites plutôt un bind sur loopback. Le listener est ainsi supprimé, au lieu d’être déplacé.
Quelqu’un a accédé à mon Ollama ouvert. Que dois-je vérifier ?
Faites d’abord un bind sur 127.0.0.1, puis redémarrez le service afin de stopper l’exposition avant de commencer l’analyse. Exécutez ensuite journalctl -u ollama --since "-30 days" | grep GIN pour examiner les adresses des clients, les endpoints et les horodatages. Gin lit également les en-têtes d’adresse client transmis par un proxy. Comparez donc ces entrées avec les journaux de votre proxy avant de considérer une adresse comme la preuve d’un accès direct. Comparez ollama list avec les modèles que vous étiez censé avoir, car /api/pull ne requiert aucune authentification et un modèle que vous n’avez pas récupéré représente à la fois de l’espace disque utilisé et un élément probant. Vérifiez l’espace libre avec df -h. Le journal d’accès par défaut enregistre les métadonnées des requêtes, mais pas le nom du modèle, le texte du prompt ni la réponse générée.