Ollama en 2026 : Exécuter des LLM localement sur votre serveur Linux — Un guide complet pour administrateurs système

Le paysage de l'IA a connu une transformation spectaculaire et, en 2026, l'exécution locale de grands modèles de langage n'est plus l'apanage des laboratoires de recherche équipés de clusters GPU. Grâce à Ollama, tout administrateur système disposant d'un serveur moderne peut déployer des modèles de langage performants en quelques minutes, avec un contrôle total, sans frais d'API et sans que les données ne quittent l'infrastructure. Que vous souhaitiez automatiser l'analyse des journaux, créer des chatbots internes, générer des modèles de configuration ou simplement expérimenter les capacités de l'IA, ce guide vous fournit tout ce dont vous avez besoin pour exécuter des modèles de langage de manière professionnelle sur une infrastructure Linux.

Pourquoi exécuter les LLM en local ? Le cas de l’administrateur système

Avant d'aborder les détails techniques, penchons-nous sur le « pourquoi ». Les services d'IA dans le cloud comme OpenAI et Anthropic sont excellents, mais pour de nombreux cas d'utilisation en entreprise, ils ne constituent pas une option :

• Souveraineté des données : les journaux, les configurations et la documentation interne ne peuvent pas quitter le réseau.
• Prévisibilité des coûts : aucune surprise concernant la facturation par jeton — le coût de calcul est fixe
• Latence : L’inférence locale élimine le temps d’aller-retour Internet.
• Fonctionnalités hors ligne : environnements isolés (sans contact), zones démilitarisées (DMZ) et réseaux isolés.
• Personnalisation : Affinez les modèles avec vos propres données, créez des invites système personnalisées.
• Conformité : RGPD, HIPAA, SOC2 — la conservation des données en local simplifie les pistes d'audit

Ollama rend tout cela accessible. Il intègre llama.cpp et d'autres moteurs d'inférence dans une interface en ligne de commande (CLI) claire et similaire à Docker, avec une API REST qui imite l'interface d'OpenAI, simplifiant ainsi la migration du cloud vers une installation locale.

Configuration matérielle requise en 2026

Les performances d'inférence LLM dépendent fortement du matériel. Voici un guide pratique pour 2026 :

En 2026, les GPU grand public comme la NVIDIA RTX 4090 (24 Go de VRAM) permettent d'exécuter des modèles de 13 milliards de données à une vitesse quasi temps réel. Pour les serveurs, les GPU NVIDIA RTX 3090/4090 ou de la série A (A10, A30, A100) offrent le meilleur compromis. L'inférence basée uniquement sur le CPU avec les processeurs Xeon ou EPYC modernes est envisageable pour les modèles de 7 milliards de données avec une quantification appropriée.

Installation d'Ollama sous Linux

Installation en une ligne (Officiel)

# Official installer -- handles GPU detection automatically
curl -fsSL https://ollama.com/install.sh | sh

# Verify installation
ollama --version

# Check service status
systemctl status ollama

Installation manuelle (recommandée en production)

# Download latest release manually
OLLAMA_VERSION=$(curl -s https://api.github.com/repos/ollama/ollama/releases/latest | grep tag_name | cut -d'"' -f4)
curl -L "https://github.com/ollama/ollama/releases/download/${OLLAMA_VERSION}/ollama-linux-amd64.tgz" -o /tmp/ollama.tgz

# Extract and install
sudo tar -C /usr/local -xzf /tmp/ollama.tgz

# Create dedicated user for security
sudo useradd -r -s /bin/false -U -m -d /usr/share/ollama ollama

# For GPU access, add to render and video groups
sudo usermod -a -G render,video ollama

# Enable and start the systemd service
sudo systemctl daemon-reload
sudo systemctl enable --now ollama
sudo systemctl status ollama

Configuration du GPU NVIDIA

# Verify NVIDIA drivers are installed
nvidia-smi

# Check CUDA availability for Ollama
ollama run llama3.2:3b "Hello" 2>&1 | head -5
# Should show GPU utilization

# Monitor GPU usage during inference
watch -n 1 nvidia-smi

# Check which layers are on GPU
OLLAMA_DEBUG=1 ollama run llama3.2:3b "test"

Modèles recommandés pour les administrateurs système en 2026

La bibliothèque de modèles d'Ollama s'est considérablement enrichie. Voici les modèles les plus adaptés aux cas d'utilisation des administrateurs système :

Usage général

# Llama 3.2 -- Meta's latest, excellent reasoning
ollama pull llama3.2:3b      # ~2GB, fast on CPU
ollama pull llama3.2:11b     # ~7GB, good balance

# Llama 3.1 70B -- best open-source general model
ollama pull llama3.1:70b     # ~40GB, needs 48GB VRAM or 64GB RAM

# Qwen2.5 -- excellent for technical content
ollama pull qwen2.5:14b      # ~9GB

# Mistral -- fast, efficient, good for automation
ollama pull mistral:7b       # ~4.1GB

Spécifique au code et au DevOps

# Qwen2.5-Coder -- best code model in 2026 for local use
ollama pull qwen2.5-coder:14b  # ~9GB, excellent for bash/python/ansible

# DeepSeek-Coder v2 -- competitive with GPT-4 for code
ollama pull deepseek-coder-v2:16b  # ~9GB

# CodeLlama -- Meta's dedicated code model
ollama pull codellama:13b   # ~7.4GB

# Test a code model
ollama run qwen2.5-coder:14b "Write a bash script to check disk usage on all mounted filesystems and alert if over 85%"

Modèles légers pour l'intégration CI/CD

# Phi-3.5 Mini -- Microsoft's tiny but capable model
ollama pull phi3.5:3.8b    # ~2.2GB

# Gemma 2 -- Google's efficient model
ollama pull gemma2:2b      # ~1.6GB, runs on anything

# List all installed models
ollama list

# Remove unused models to free disk space
ollama rm llama2:7b

L'API REST d'Ollama : Intégrer les LLM à votre infrastructure

C’est grâce à son API REST qu’Ollama révèle toute sa puissance pour l’automatisation. Compatible avec le format d’API OpenAI, elle s’intègre facilement aux solutions d’IA cloud dans de nombreux outils.

Utilisation de base de l'API

# Check API health
curl http://localhost:11434/api/tags

# Generate a response (streaming)
curl http://localhost:11434/api/generate -d '{
  "model": "llama3.2:3b",
  "prompt": "Explain what a Linux inode is in 2 sentences"
}'

# Non-streaming response
curl http://localhost:11434/api/generate -d '{
  "model": "llama3.2:3b",
  "prompt": "Write a one-liner to find all SUID binaries",
  "stream": false
}' | python3 -c "import json,sys; print(json.load(sys.stdin)['response'])"

# Chat format (OpenAI-compatible)
curl http://localhost:11434/v1/chat/completions 
  -H "Content-Type: application/json" 
  -d '{
    "model": "llama3.2:3b",
    "messages": [
      {"role": "system", "content": "You are a Linux sysadmin assistant."},
      {"role": "user", "content": "How do I check which process is using port 8080?"}
    ]
  }'

Fichiers de modèles personnalisés : Assistants optimisés pour l’administration système

# Create a Modelfile for a sysadmin-tuned assistant
# /etc/ollama/Modelfile.sysadmin
# FROM llama3.2:11b
# SYSTEM You are an expert Linux/Windows sysadmin. Provide precise, production-ready commands.
# PARAMETER temperature 0.3

# Build the custom model
ollama create sysadmin-assistant -f /etc/ollama/Modelfile.sysadmin

# Test it
ollama run sysadmin-assistant "How do I safely rotate a Let's Encrypt certificate with minimal downtime?"

Cas d'utilisation réels d'administrateur système avec des scripts pratiques

Automatisation de l'analyse des journaux

#!/bin/bash
# ai-log-analyzer.sh -- Analyze system logs with local LLM

LOG_FILE="${1:-/var/log/syslog}"
RECENT_LOGS=$(tail -100 "$LOG_FILE" | grep -E "error|warn|crit|fail" | head -50)

PROMPT="Analyze these Linux system log entries and identify: 1) Critical issues requiring immediate attention, 2) Recurring patterns, 3) Recommended actions.

LOG ENTRIES:
$RECENT_LOGS"

echo "=== AI Log Analysis Report - $(date) ==="
curl -s http://localhost:11434/api/generate 
  -d "{"model": "llama3.2:11b", "prompt": $(echo "$PROMPT" | python3 -c "import json,sys; print(json.dumps(sys.stdin.read()))"), "stream": false}" 
  | python3 -c "import json,sys; print(json.load(sys.stdin)['response'])"

Générateur automatisé de rapports d'incidents

#!/usr/bin/env python3
# incident-report.py -- Generate incident reports from system state

import subprocess, json, urllib.request, datetime

def ask_ollama(prompt, model="qwen2.5:14b"):
    url = "http://localhost:11434/api/generate"
    data = json.dumps({"model": model, "prompt": prompt, "stream": False}).encode()
    req = urllib.request.Request(url, data=data, headers={"Content-Type": "application/json"})
    resp = json.loads(urllib.request.urlopen(req, timeout=120).read())
    return resp["response"]

disk_usage = subprocess.getoutput("df -h")
top_processes = subprocess.getoutput("ps aux --sort=-%cpu | head -15")
recent_errors = subprocess.getoutput("journalctl -p err --since '1 hour ago' --no-pager | tail -30")
memory_info = subprocess.getoutput("free -h")

prompt = f"Generate a professional incident investigation report for system state at {datetime.datetime.now().isoformat()}.nnDISK:n{disk_usage}nnTOP PROCESSES:n{top_processes}nnERRORS:n{recent_errors}nnMEMORY:n{memory_info}nnFormat: Executive Summary, Key Findings, Immediate Actions, Preventive Recommendations."

report = ask_ollama(prompt)
print(report)

with open(f"/var/log/ai-incident-{datetime.date.today()}.txt", "w") as f:
    f.write(report)

Examen de sécurité des fichiers de configuration

#!/bin/bash
# ai-config-review.sh -- Security review of config files

CONFIG_FILE="${1:-/etc/nginx/nginx.conf}"
CONFIG_CONTENT=$(cat "$CONFIG_FILE" | head -200)

curl -s http://localhost:11434/v1/chat/completions 
  -H "Content-Type: application/json" 
  -d "{
    "model": "qwen2.5-coder:14b",
    "messages": [
      {"role": "system", "content": "You are a security-focused sysadmin. Review configuration files for security issues."},
      {"role": "user", "content": "Review this config for security issues:nn$CONFIG_CONTENT"}
    ]
  }" | python3 -c "
import json, sys
data = json.load(sys.stdin)
print(data['choices'][0]['message']['content'])
"

Déploiement en production : sécurité et performances

Sécurisation de l'API Ollama

# By default, Ollama listens on all interfaces -- restrict this!
# Edit /etc/systemd/system/ollama.service

# Localhost only (for same-server applications)
# Environment="OLLAMA_HOST=127.0.0.1:11434"

# Add authentication via Nginx reverse proxy
# upstream ollama { server 127.0.0.1:11434; }
# auth_basic "Ollama API";
# auth_basic_user_file /etc/nginx/.htpasswd;
# proxy_pass http://ollama;
# proxy_read_timeout 300s;

# Create password file for nginx basic auth
htpasswd -c /etc/nginx/.htpasswd ollama-user

# Reload nginx
systemctl reload nginx

Réglage des performances

# Ollama environment variables for performance tuning
# Add to /etc/systemd/system/ollama.service [Service] section:

# Number of layers to offload to GPU (0=CPU only, -1=all layers)
# Environment="OLLAMA_GPU_LAYERS=-1"

# Number of parallel requests
# Environment="OLLAMA_NUM_PARALLEL=4"

# Max loaded models in memory
# Environment="OLLAMA_MAX_LOADED_MODELS=2"

# Context size (tokens)
# Environment="OLLAMA_NUM_CTX=4096"

# Flash attention (faster on supported GPUs)
# Environment="OLLAMA_FLASH_ATTENTION=1"

# Apply changes
systemctl daemon-reload && systemctl restart ollama

Surveillance avec Prometheus

# Ollama exposes metrics at /metrics (Prometheus format)
curl http://localhost:11434/metrics | head -20

# Add to Prometheus scrape config (/etc/prometheus/prometheus.yml):
# - job_name: 'ollama'
#   static_configs:
#     - targets: ['localhost:11434']
#   metrics_path: '/metrics'

# Key metrics to monitor:
# ollama_requests_total -- request count
# ollama_request_duration_seconds -- latency
# ollama_model_load_duration_seconds -- model load time
# process_resident_memory_bytes -- RAM usage

Intégration d'Ollama aux outils existants

L'API d'Ollama étant compatible avec OpenAI, elle fonctionne avec un vaste écosystème d'outils sans modification :

# Open-WebUI -- full ChatGPT-like UI for Ollama
docker run -d -p 3000:8080 
  --add-host=host.docker.internal:host-gateway 
  -e OLLAMA_BASE_URL=http://host.docker.internal:11434 
  -v open-webui:/app/backend/data 
  --name open-webui 
  ghcr.io/open-webui/open-webui:main

# Access at http://your-server:3000

# Continue.dev (VS Code AI assistant) -- point to Ollama
# In ~/.continue/config.json:
# {
#   "models": [{"title": "Ollama", "provider": "ollama",
#                "model": "qwen2.5-coder:14b",
#                "apiBase": "http://localhost:11434"}]
# }

# Test OpenAI compatibility
curl http://localhost:11434/v1/models
# Should list your installed models in OpenAI format

Conclusion

Ollama a démocratisé le déploiement local de modèles LLM au point que n'importe quel administrateur système peut disposer d'un serveur d'inférence IA opérationnel en moins de 30 minutes. En 2026, grâce à la disponibilité locale de modèles tels que Llama 3.1, Qwen2.5-Coder et DeepSeek, l'écart de performance entre l'IA locale et l'IA cloud s'est considérablement réduit pour la plupart des tâches pratiques.

Les cas d'usage pour les administrateurs système sont convaincants : l'analyse des journaux, la génération de rapports d'incidents, la revue de configuration, l'automatisation des procédures opérationnelles et les bases de connaissances internes bénéficient toutes d'une IA qui conserve les données sur site. Commencez par un modèle 7B unique, validez-le par rapport à votre cas d'usage, puis faites évoluer la solution en fonction de votre niveau de confiance et de votre matériel. La simplicité d'Ollama, son interface web intuitive pour les utilisateurs non techniques et son API REST pour l'automatisation font de cette solution un investissement judicieux pour toute équipe informatique moderne.