Ollama : installer et utiliser des LLM locaux 2026

À la fin de ce tutoriel ollama llm locaux, vous saurez installer Ollama sur Linux, tirer un modèle léger, dialoguer en CLI, appeler l’API native /api/chat et l’endpoint OpenAI-compatible /v1/chat/completions sur localhost:11434, créer un Modelfile runbook DevOps, et gérer le service systemd — labs sous /tmp/lab-ollama, sans secrets cloud.

Niveau : Débutant–Intermédiaire · Temps estimé : 40–55 min · Versions testées : Ubuntu 22.04 / 24.04, Debian 12 ; notes Rocky/Alma 9 · Ollama CLI récente (script ollama.com/install.sh) · Dernière vérification : 2026-09-11

Statut : HOLD — draft only (ne pas publier sur WordPress)

Prérequis

• Hub IA pour DevOps : parcours 2026 (contexte série : cloud LLM puis stack locale)
• Machine Linux avec ~8–16 Go RAM pour un petit modèle (CPU OK ; GPU optionnel)
• curl, droits sudo pour l’install systemd, terminal bash
• Lab entièrement dans /tmp/lab-ollama ; aucun token cloud, clé API réelle ou log prod non redacté
• Notion basique HTTP JSON (POST, headers) — utile pour Continue.dev / scripts ops

Coût : 0 € en local (téléchargement des poids modèle depuis la bibliothèque Ollama). Les options cloud Ollama existent hors scope de ce lab : ici, les prompts restent sur la machine.

Ce que nous allons construire

/tmp/lab-ollama
  ├── chat-native.json       (POST /api/chat, stream:false)
  ├── chat-openai.json       (POST /v1/chat/completions)
  ├── Modelfile              (SYSTEM runbook DevOps)
  └── notes-cli.txt          (list / ps / show)
       API locale : http://localhost:11434
       CLI : pull · run · list · ps · show · create · stop
       systemd : ollama.service · journalctl

(Schéma à remplacer par une image locale Excalidraw / draw.io, alt : « Ollama LLM locaux : install Linux, modèle léger, API 11434 native et OpenAI-compatible, Modelfile DevOps ».)

Angle DevOps 2026 : runbooks offline, revue de logs sans envoyer de secrets vers un SaaS, assistants CLI/IDE (Continue, Aider, etc.) pointant vers localhost. Les tags de modèles évoluent sur ollama.com/library : toujours prendre le tag exact affiché (ex. llama3.2, gemma3:4b, qwen2.5-coder:1.5b).

Étape 1 — Installer Ollama

Le script officiel installe le binaire, l’utilisateur système et le service systemd ollama (docs : docs.ollama.com/linux). Domaine d’install : ollama.com (pas l’ancien domaine marketing confus).

mkdir -p /tmp/lab-ollama && cd /tmp/lab-ollama

# Install officiel Linux
curl -fsSL https://ollama.com/install.sh | sh

# Vérifications
ollama -v
systemctl status ollama --no-pager
curl -s http://localhost:11434
# Attendu : Ollama is running

Pourquoi systemd dès l’install : l’API écoute en permanence sur le port 11434, ce qui permet aux outils IDE et scripts CI locaux de s’y connecter sans relancer ollama serve à la main.

Étape 2 — Tirer et lancer un modèle léger

Choisissez un tag petit pour le lab (RAM limitée). Exemples réalistes 2026 : llama3.2, gemma3:4b, ou un coder léger type qwen2.5-coder:1.5b. Vérifiez le tag exact sur la bibliothèque avant le pull.

cd /tmp/lab-ollama

# Télécharger les poids (une fois)
ollama pull llama3.2
# Alternative légère : ollama pull gemma3:4b

# Session interactive (Ctrl+D pour quitter)
ollama run llama3.2 "En une phrase : qu'est-ce qu'un runbook DevOps ?"

# Inventaire et introspection
ollama list | tee notes-cli.txt
ollama ps
ollama show llama3.2

list (alias ls) montre les modèles locaux ; ps les instances chargées ; show les métadonnées (template, paramètres). Pour libérer la RAM : ollama stop llama3.2.

Étape 3 — API native /api/chat

L’API REST native est idéale pour scripts bash et automatisation ops. On force "stream": false pour une réponse JSON complète (pratique en CI ou cron).

cd /tmp/lab-ollama

cat > chat-native.json << 'EOF'
{
  "model": "llama3.2",
  "stream": false,
  "messages": [
    {
      "role": "system",
      "content": "Tu es un assistant DevOps. Réponds en français, concis, sans inventer de secrets."
    },
    {
      "role": "user",
      "content": "Donne 3 checks read-only avant un rollback Kubernetes."
    }
  ]
}
EOF

curl -s http://localhost:11434/api/chat 
  -H "Content-Type: application/json" 
  -d @chat-native.json | tee /tmp/lab-ollama/out-native.json

# Extraire le contenu message (si jq installé)
command -v jq >/dev/null && jq -r '.message.content' out-native.json

Pourquoi /api/chat plutôt que /api/generate : le format messages (system/user/assistant) aligne runbooks, agents et clients IDE sur le même contrat conversationnel.

Étape 4 — Endpoint OpenAI-compatible

Beaucoup d’outils (Continue.dev, SDKs OpenAI, agents) parlent déjà le protocole OpenAI. Ollama expose /v1/chat/completions ; la clé API est requise par le client mais ignorée — utilisez la valeur factice ollama.

cd /tmp/lab-ollama

cat > chat-openai.json << 'EOF'
{
  "model": "llama3.2",
  "messages": [
    {"role": "user", "content": "Résume le théorème CAP en 2 phrases (lab local)."}
  ]
}
EOF

curl -s http://localhost:11434/v1/chat/completions 
  -H "Content-Type: application/json" 
  -H "Authorization: Bearer ollama" 
  -d @chat-openai.json | tee out-openai.json

command -v jq >/dev/null && jq -r '.choices[0].message.content' out-openai.json

Base URL pour les clients : http://localhost:11434/v1 (parfois avec slash final selon le SDK). Aucune donnée de ce lab ne doit pointer vers api.openai.com.

Étape 5 — Modelfile minimal (SYSTEM DevOps)

Un Modelfile fige le prompt système et le modèle de base : utile pour un assistant « runbook » reproductible entre laptops d’équipe.

cd /tmp/lab-ollama

cat > Modelfile << 'EOF'
FROM llama3.2
SYSTEM """
Tu es un assistant runbook DevOps Elastic Hayway.
- Réponds en français, clair et actionnable.
- Propose d'abord des commandes read-only.
- N'invente jamais de tokens, mots de passe ou kubeconfig.
- Si le contexte manque, pose une question courte.
"""
PARAMETER temperature 0.2
EOF

ollama create devops-runbook -f Modelfile
ollama run devops-runbook "Un pod CrashLoopBackOff : 4 étapes de triage."
ollama list | grep devops-runbook

Pourquoi un modèle nommé : Continue / Aider / scripts peuvent cibler devops-runbook sans retaper le SYSTEM à chaque appel. Pour supprimer : ollama rm devops-runbook.

Étape 6 — systemd, logs et durcissement lab

# Service (install script le gère en général)
sudo systemctl enable --now ollama
sudo systemctl status ollama --no-pager
journalctl -u ollama -n 50 --no-pager

# Variables utiles (lab seulement — ne pas exposer en prod sans auth)
# OLLAMA_HOST=0.0.0.0:11434  # bind LAN : AVERTISSEMENT SÉCU
# Préférez localhost + tunnel SSH / firewall strict

Sécurité : par défaut Ollama écoute en local. OLLAMA_HOST=0.0.0.0:11434 expose l’API sur le LAN sans authentification — réservez ça à un lab isolé, jamais à un bastion public. GPU optionnel : le script d’install détecte souvent CUDA (NVIDIA) ou ROCm (AMD) ; sans GPU, le CPU suffit pour les petits tags.

# Nettoyage lab (conserve Ollama système)
cd /tmp && rm -rf /tmp/lab-ollama
echo "lab ollama nettoyé — OK"

Tableau — CLI Ollama utiles

Commande	Rôle
ollama pull <tag>	Télécharger un modèle
ollama run <tag>	Chat interactif / one-shot
ollama list / ls	Modèles locaux
ollama ps	Modèles chargés en mémoire
ollama show <tag>	Métadonnées / template
ollama stop <tag>	Décharger de la RAM
ollama create	Construire depuis Modelfile
ollama rm <tag>	Supprimer un modèle
ollama serve	Lancer le serveur (si pas systemd)

Erreurs fréquentes

Symptôme	Cause	Correction
connection refused :11434	Service down	sudo systemctl start ollama ; curl localhost:11434
Process tué / freeze	OOM (modèle trop gros)	Tag plus petit (:1.5b / :4b) ; ollama stop ; plus de RAM
pull échoue / not found	Mauvais tag / typo	Vérifier ollama.com/library — tag exact
Port déjà pris	Autre process sur 11434	ss -lntp | grep 11434 ; arrêter le conflit
Install / docs introuvables	Confusion ollama.ai vs ollama.com	Utiliser ollama.com et docs.ollama.com
Client OpenAI 401 / mauvais host	Mauvaise base URL	http://localhost:11434/v1 + clé factice ollama

Quiz (4 questions)

1. Quel port écoute l’API Ollama par défaut ?
– A. 8080
– B. 11434
– C. 443

2. Quelle commande tire un modèle localement ?
– A. ollama pull llama3.2
– B. docker pull openai
– C. apt install llm

3. Pour un client OpenAI SDK, quelle base URL locale ?
– A. https://api.openai.com/v1
– B. http://localhost:11434/v1
– C. http://localhost:3000

4. Pourquoi éviter OLLAMA_HOST=0.0.0.0:11434 sur un serveur exposé ?
– A. Ça ralentit le GPU
– B. L’API n’a pas d’auth native — risque d’accès LAN/WAN non contrôlé
– C. systemd refuse le bind

Réponses : 1‑B · 2‑A · 3‑B · 4‑B

Compléments opérationnels

Standard de brief réutilisable

Pour ollama-llm-locaux, adoptez un brief unique partagé par l’équipe. Il contient toujours cinq champs : objectif mesurable, contexte borné (lab/staging), liste blanche de fichiers ou ressources, interdits explicites (secrets, réseau, prod), et definition of done exécutable (commande de test ou checklist). Sans ces champs, l’outil improvisera — parfois avec élégance, souvent hors périmètre.

Stockez les briefs gagnants sous briefs/ollama-llm-locaux/ dans un dépôt de documentation interne. Chaque brief cite le commit de référence et le modèle utilisé. Au troisième succès comparable, ouvrez une PR qui transforme le brief en rule, Skill ou slash command. Voir ai-skills-concept, claude-skills-instructions et evaluer-qualite-skill.

Revue de diff comme compétence P0

La vitesse d’un agent n’a aucune valeur si personne ne sait lire un diff. Instituez une règle simple : aucun apply massif sans parcours hunk par hunk. Posez-vous trois questions : ce changement est-il demandé ? est-il testé ? est-il réversible ? Si une réponse est non, refusez ou exigez un plan plus petit.

En atelier, faites commenter un diff à voix haute pendant cinq minutes. Les juniors apprennent ainsi le vocabulaire du refus. Reliez cette pratique à ai-code-review-pr et aux workflows ai-agent-workflows.

Sécurité continue

Les surfaces ollama-llm-locaux multiplient les occasions d’injection et de fuite. Traitez tickets, README upstream, logs et ressources MCP comme des données non fiables. Séparez instructions et données. Allowlist tools. Confirmation humaine avant mutation. Guide : ai-prompt-injection-securite, mcp-servers-devops, claude-code-mcp.

Secrets : variables d’environnement de session, gestionnaire d’équipe, rotation, jamais de commit. Si un secret fuit dans un chat vendor, supposez-le compromis et rotatez.

Coûts, modèles et mode dégradé

Documentez un mapping fast/strong et un soft-cap mensuel dans la stack perso. OpenRouter peut aider à basculer — openrouter-multi-modeles. Le local (ollama-llm-locaux + continue-dev) sert de mode dégradé ou de bac à sable confidentialité.

Surveillez les changements silencieux de modèle par défaut : une régression de qualité est souvent un routing vendor, pas « l’équipe qui a oublié comment prompter ».

Ancrage parcours

ollama-llm-locaux n’est qu’une étape du parcours IA DevOps 2026. Tronc commun d’abord (prompts, injection, skills), puis surface spécialisée, puis industrialisation (routines, MCP, RAG). Hub de navigation : /ia/. Comparatifs utiles : claude-vs-gpt-code, codex-vs-claude-code, claude-vs-cursor-vs-copilot.

Rituals hebdomadaires

Hebdo : promouvoir un brief en Skill/rule ; archiver un échec instructif ; vérifier le budget tokens. Mensuel : revoir la stack (retirer l’inutile) ; rejouer un lab gold ; mettre à jour les versions d’outils. Ces rituals valent mieux que d’ajouter un cinquième abonnement.

Exemple de NOTES.md

# NOTES ollama-llm-locaux
Date:
Modèle:
Brief (résumé):
Fichiers touchés:
Commande DoD:
Refus utiles:
Commit:
Leçon:

Sans ce journal, vous réapprendrez les mêmes leçons chaque sprint. Avec ce journal, vous construisez un avantage composé d’équipe.

Quand arrêter l’outil

Arrêtez la session si : le DoD échoue deux fois de suite sans diagnostic clair ; l’outil insiste pour sortir du scope ; une commande dangereuse revient après refus ; vous ne comprenez plus le diff. Dans ces cas, revenir à l’éditeur manuel + checklist est un succès de gouvernance, pas un échec personnel.

Ponts concrets vers d’autres tutoriels

Après ce lab, enchaînez selon besoin : agent CLI (claude-code-demarrer, openai-codex-intro-2026, aider-pair-programming), IDE (windsurf-cascade, continue-dev, cursor-agent-composer-2026), qualité (evaluer-qualite-skill, ai-routines-agents), ou recherche ([gemini-cli

FAQ

Quel voisin lire après ollama-llm-locaux ?
Parcours · /ia/ · stack perso.

Peut-on skipper le lab Git ?
Non — sans livrable versionné, pas de preuve d’apprentissage.

Les prompts quittent-ils ma machine avec Ollama local ?
Non pour ce lab : inférence locale, poids sur disque, API sur localhost. Ollama propose aussi des options cloud séparées — hors scope ici ; ne les activez pas si votre contrainte est la confidentialité des logs/runbooks.

CPU ou GPU pour démarrer ?
CPU suffit pour llama3.2 / gemma3:4b en lab (latence plus haute). CUDA/ROCm accélère les sessions longues et les modèles plus gros ; ce n’est pas un prérequis pour valider l’API et le Modelfile.

Comment brancher Continue.dev ou Aider ?
Pointez le fournisseur OpenAI-compatible vers http://localhost:11434/v1, modèle = tag Ollama (llama3.2 ou devops-runbook), clé = ollama. Voir voisins Continue / Aider / MCP dans le maillage ci-dessous.

Pour aller plus loin

• Docs : docs.ollama.com · Bibliothèque de modèles · OpenAI compatibility
• Hub : IA pour DevOps : parcours 2026
• Voisins : Continue.dev · Aider · MCP servers DevOps · stack IA perso (Open WebUI, agents locaux)

Maillage série IA Outils 2026

Précédent	Grok / xAI Code
Suite	OpenRouter multi-modèles
Hub	IA pour DevOps : parcours 2026

• seo_title : Ollama : installer et utiliser des LLM locaux 2026
• seo_desc : Installez Ollama, tirez un modèle, API locale OpenAI-compatible pour Continue/Aider.