« Trace install tas - Ollama » : différence entre les versions
Chemin Quadlet NVIDIA désactivé |
Simplifier la mise à jour du client CLI : version serveur automatique, contrôle sans installation et commande courte |
||
| Ligne 216 : | Ligne 216 : | ||
=== Mise à jour du client CLI utilisateur === | === Mise à jour du client CLI utilisateur === | ||
==== À recopier dans le terminal ==== | |||
'''Exécuter avec le compte utilisateur habituel, sans sudo.''' Le script local ci-dessous met à jour uniquement <code>~/.local/bin/ollama</code> pour l’aligner sur la version du serveur AMD/ROCm. Il ne met à jour ni le conteneur, ni le binaire système, ni les modèles. | |||
'''1. Vérifier sans rien modifier :''' | |||
<pre>bash "$HOME/mediawiki/docs/mettre-a-jour-client-ollama.sh" --check</pre> | |||
'''2. Lancer la mise à jour :''' | |||
<pre>bash "$HOME/mediawiki/docs/mettre-a-jour-client-ollama.sh"</pre> | |||
Chaque commande tient sur une seule ligne ; ne pas ajouter de barre oblique inverse. Le fichier est déjà présent sur le serveur. Aucun numéro de version ni SHA-256 n’est à remplacer à la main. | |||
Le script sélectionne la release officielle correspondant à la version API du serveur, vérifie son SHA-256 publié par GitHub, extrait uniquement <code>bin/ollama</code>, teste sa version puis sauvegarde l’ancien client dans <code>~/backups/ollama/</code> avant un remplacement atomique. Si le client est déjà aligné, il n’est pas remplacé. Les erreurs de téléchargement, d’intégrité ou de version interrompent l’opération. Seuls les fichiers temporaires créés par le script sont nettoyés ; la sauvegarde est conservée. | |||
'''Téléchargement à prévoir :''' environ 1,5 Go pour l’archive générique Linux amd64 de la release vérifiée ici ; le script n’installe pas les bibliothèques GPU de cette archive. <code>--check</code> ne télécharge pas l’archive et n’effectue aucune installation. | |||
OLLAMA_HOST=http://127.0.0.1:11434 ollama --version | ==== État vérifié le 30 octobre 2026 ==== | ||
OLLAMA_HOST=http://127.0.0.1: | * Architecture : <code>x86_64</code> → archive <code>ollama-linux-amd64.tar.zst</code>. | ||
* Client actif : <code>~/.local/bin/ollama</code>, version client <code>0.40.5</code>. | |||
* Serveur AMD/ROCm : version API <code>0.40.13</code> ; instance NVIDIA toujours non joignable lors de ce contrôle. | |||
* L’ancien bloc utilisait encore <code>VERSION=v0.35.1</code> : le recopier aurait rétrogradé le client. Il est remplacé par la sélection automatique de la version du serveur. | |||
* Contrôles exécutés : syntaxe Bash, tests de remplacement et d’échec en environnement isolé, puis <code>--check</code> contre le serveur et les métadonnées GitHub réels. '''Aucune mise à jour du client réel n’a été exécutée pendant cette vérification.''' | |||
Référence : [https://github.com/ollama/ollama/releases/tag/v0.40.13 release officielle v0.40.13]. L’empreinte de l’archive générique relevée est <code>c9490e0f520be21271d969e6703f012268b1d39f8b70dd58854e5bfef7a75bb6</code> ; le script récupère celle de la release cible au moment de son exécution, sans valeur figée. | |||
==== Source du script — pour consultation ou recréation du fichier ==== | |||
La commande courte ci-dessus suffit lorsque le fichier local existe. Le code complet reste disponible ci-dessous pour que la procédure soit autonome ; il n’est pas nécessaire de le recopier à chaque mise à jour. | |||
<div class="mw-collapsible mw-collapsed"> | |||
<pre>#!/usr/bin/env bash | |||
# Aligner uniquement le client utilisateur sur le serveur local AMD/ROCm. | |||
# Usage : bash mettre-a-jour-client-ollama.sh [--check] | |||
# --check : lectures réseau uniquement, sans téléchargement de l'archive. | |||
# Aucun sudo, installateur distant, redémarrage, ni changement des modèles. | |||
set -euo pipefail | |||
export LC_ALL=C | |||
MODE=${1:-update} | |||
if (( $# > 1 )) || [[ "$MODE" != update && "$MODE" != --check ]]; then | |||
    echo "Usage : bash $0 [--check]" >&2 | |||
    exit 2 | |||
fi | |||
for outil in curl python3 uname readlink; do | |||
    command -v "$outil" >/dev/null || { echo "Outil manquant : $outil" >&2; exit 1; } | |||
done | |||
# Refuser une cible différente plutôt que mettre à jour le mauvais exécutable. | |||
BIN="$HOME/.local/bin/ollama" | |||
ACTIVE=$(command -v ollama) | |||
[[ "$ACTIVE" = "$BIN" && -f "$BIN" && ! -L "$BIN" && -w "$BIN" ]] || { echo "Client actif inattendu ou non modifiable : $ACTIVE ; attendu : $BIN" >&2; exit 1; } | |||
case $(uname -m) in | |||
    x86_64) ARCH=amd64 ;; | |||
    aarch64) ARCH=arm64 ;; | |||
    *) echo "Architecture non prise en charge" >&2; exit 1 ;; | |||
esac | |||
# Cible volontairement fixe : ne pas hériter d'un éventuel OLLAMA_HOST distant. | |||
HOST=http://127.0.0.1:11434 | |||
VERSION=$(curl -fsS --connect-timeout 10 --max-time 30 "$HOST/api/version" | python3 -c 'import json,re,sys; v=json.load(sys.stdin)["version"]; assert re.fullmatch(r"[0-9]+\.[0-9]+\.[0-9]+",v), "Version serveur non stable/invalide"; print(v)') | |||
ASSET="ollama-linux-$ARCH.tar.zst" | |||
# Version exacte du serveur, jamais releases/latest. Les métadonnées sont | |||
# parsées comme JSON ; aucun contenu téléchargé n'est évalué comme du shell. | |||
META=$(curl -fsSL --connect-timeout 10 --max-time 60 "https://api.github.com/repos/ollama/ollama/releases/tags/v$VERSION") | |||
INFO=$(printf '%s' "$META" | python3 -c 'import json,re,sys; d=json.load(sys.stdin); v,n=sys.argv[1:]; assert d["tag_name"]=="v"+v and not d["draft"] and not d["prerelease"], "Release non stable"; matches=[a for a in d["assets"] if a["name"]==n]; assert len(matches)==1,"Asset absent/ambigu"; a=matches[0]; digest=a.get("digest") or ""; assert re.fullmatch(r"sha256:[a-f0-9]{64}",digest),"SHA-256 officiel absent/invalide"; expected="https://github.com/ollama/ollama/releases/download/v"+v+"/"+n; assert a["browser_download_url"]==expected,"URL inattendue"; size=a["size"]; assert type(size) is int and size>0,"Taille invalide"; print(digest[7:],expected,size,sep="\n")' "$VERSION" "$ASSET") | |||
mapfile -t FIELDS <<< "$INFO" | |||
EXPECTED_SHA256=${FIELDS[0]} | |||
URL=${FIELDS[1]} | |||
SIZE=${FIELDS[2]} | |||
printf 'Client actif : %s\nVersion cible du serveur : v%s\nArchive : %s (%s octets)\nSHA-256 officiel : %s\n' "$BIN" "$VERSION" "$ASSET" "$SIZE" "$EXPECTED_SHA256" | |||
if [[ "$MODE" = --check ]]; then | |||
    echo "Aucun binaire modifié ; aucune archive téléchargée." | |||
    exit 0 | |||
fi | |||
for outil in sha256sum zstd tar mktemp install cp cmp mv; do | |||
    command -v "$outil" >/dev/null || { echo "Outil manquant : $outil" >&2; exit 1; } | |||
done | |||
# --version contacte normalement le serveur : l'isoler pour lire le client. | |||
client_version() { | |||
    OLLAMA_HOST=http://127.0.0.1:1 "$1" --version 2>&1 | python3 -c 'import re,sys; s=sys.stdin.read(); m=re.findall(r"(?:client version is|ollama version is) ([0-9]+\.[0-9]+\.[0-9]+)",s); assert len(m)==1,"Version client ambiguë/inconnue"; print(m[0])' | |||
} | |||
if [[ $(client_version "$BIN") = "$VERSION" ]]; then | |||
    echo "Client déjà aligné ; aucun téléchargement nécessaire." | |||
    OLLAMA_HOST="$HOST" "$BIN" list | |||
    exit 0 | |||
fi | |||
# Les seuls fichiers supprimés par le nettoyage sont ceux créés par ce script. | |||
# La sauvegarde persistante, le client installé et les modèles sont conservés. | |||
WORK_BASE=${TMPDIR:-$HOME/.cache/ollama-client} | |||
mkdir -p "$WORK_BASE" | |||
TMP=$(mktemp -d "$WORK_BASE/ollama-client.XXXXXXXX") | |||
STAGE= | |||
cleanup() { | |||
    [[ -z "$STAGE" ]] || rm -f -- "$STAGE" | |||
    rm -rf -- "$TMP" | |||
} | |||
trap cleanup EXIT | |||
ARCHIVE="$TMP/$ASSET" | |||
curl -fL --retry 3 --connect-timeout 20 --max-time 3600 "$URL" -o "$ARCHIVE" | |||
printf '%s  %s\n' "$EXPECTED_SHA256" "$ARCHIVE" | sha256sum -c - | |||
zstd -t "$ARCHIVE" | |||
# Archive générique : les bibliothèques GPU restent dans le conteneur serveur. | |||
# Pas d'extraction de lib/ ni d'installation du serveur natif. | |||
tar --use-compress-program=zstd -xOf "$ARCHIVE" bin/ollama > "$TMP/ollama.new" | |||
chmod 0755 "$TMP/ollama.new" | |||
[[ $(client_version "$TMP/ollama.new") = "$VERSION" ]] || { echo "Version du candidat incorrecte" >&2; exit 1; } | |||
# Si le serveur change pendant le téléchargement, recommencer au lieu | |||
# d'installer silencieusement un client qui n'est déjà plus aligné. | |||
CURRENT=$(curl -fsS --connect-timeout 10 --max-time 30 "$HOST/api/version" | python3 -c 'import json,sys; print(json.load(sys.stdin)["version"])') | |||
[[ "$CURRENT" = "$VERSION" ]] || { echo "Version serveur changée ; relancer le script" >&2; exit 1; } | |||
BACKUP_DIR="$HOME/backups/ollama" | |||
mkdir -p "$BACKUP_DIR" | |||
STAMP=$(date +%Y-%m-%dT%H-%M-%S%z)-$$ | |||
BACKUP="$BACKUP_DIR/ollama-client-user.bak-$STAMP" | |||
cp -a -- "$BIN" "$BACKUP" | |||
cmp -s -- "$BIN" "$BACKUP" | |||
printf 'Sauvegarde vérifiée : %s\n' "$BACKUP" | |||
# Renommage dans le répertoire du client : même système de fichiers, atomique. | |||
STAGE=$(mktemp "$HOME/.local/bin/.ollama.new-XXXXXXXX") | |||
install -m 0755 "$TMP/ollama.new" "$STAGE" | |||
mv -f -- "$STAGE" "$BIN" | |||
STAGE= | |||
[[ $(client_version "$BIN") = "$VERSION" ]] | |||
# Échec ici = installation effectuée mais accès serveur non validé, pas succès. | |||
OLLAMA_HOST="$HOST" "$BIN" --version | |||
OLLAMA_HOST="$HOST" "$BIN" list | |||
CURRENT=$(curl -fsS --connect-timeout 10 --max-time 30 "$HOST/api/version" | python3 -c 'import json,sys; print(json.load(sys.stdin)["version"])') | |||
[[ "$CURRENT" = "$VERSION" ]] || { echo "Client installé, mais serveur changé après installation" >&2; exit 1; } | |||
printf 'Client aligné sur le serveur : %s\n' "$VERSION" | |||
</pre> | </pre> | ||
</div> | |||
==== Historique des mises à jour précédentes ==== | |||
Résultat réel le 5 octobre 2026 : client <code>/home/loic/.local/bin/ollama</code> en <code>0.35.1</code>, API ROCm <code>11434</code> en <code>0.35.1</code>, commande <code>ollama list</code> : 100 lignes de sortie. Ancien binaire sauvegardé dans <code>/home/loic/backups/ollama/ollama-client-user.bak-2026-10-05T00-00-29+0200</code>. | Résultat réel le 5 octobre 2026 : client <code>/home/loic/.local/bin/ollama</code> en <code>0.35.1</code>, API ROCm <code>11434</code> en <code>0.35.1</code>, commande <code>ollama list</code> : 100 lignes de sortie. Ancien binaire sauvegardé dans <code>/home/loic/backups/ollama/ollama-client-user.bak-2026-10-05T00-00-29+0200</code>. | ||
Dernière version du 30 octobre 2026 à 09:29
Trace install tas - Ollama
Rôle
API locale de modèles LLM avec deux instances distinctes :
- une instance AMD/ROCm sur la Radeon RX 7900
- une instance NVIDIA/CUDA sur la GeForce RTX 3070
Accès
Instance AMD / ROCm
- Local : http://10.8.0.1:11434
- Depuis le terminal local : `OLLAMA_HOST=http://127.0.0.1:11434`
- Public : https://lololand.hopto.org:25434
Instance NVIDIA / CUDA
- Local : http://10.8.0.1:11435
- Depuis le terminal local : `OLLAMA_HOST=http://127.0.0.1:11435`
- État au 2026-10-17 : lancement désactivé ; le port ne répond pas.
- Pas d'exposition publique dédiée documentée à ce stade
Ports
- 11434/tcp : serveur Ollama AMD / ROCm
- 11435/tcp : port prévu pour Ollama NVIDIA / CUDA ; service actuellement désactivé
- 25434/tcp : proxy public Caddy vers l'instance AMD/ROCm, protégé par basicauth
Exécution / runtime
AMD / ROCm
- Service systemd user généré : `ollama-rocm.service`
- Conteneur : `ollama_roc`
- Image : `docker.io/ollama/ollama:rocm`
- Devices : `/dev/kfd`, `/dev/dri`
NVIDIA / CUDA
- État au 2026-10-17 : désactivé. Le service entrait en boucle de redémarrages en échec (hook NVIDIA, code 1). Le Quadlet a été renommé en `/home/loic/.config/containers/systemd/ollama-nvidia.container.disabled-2026-10-17T11-12-14+0200` ; la sauvegarde est `/home/loic/backups/ollama/ollama-nvidia.container.before-disable-2026-10-17T11-12-14+0200.bak`. Le service est `not-found` après rechargement systemd et aucun conteneur `ollama_nv` ne subsiste.
- Point de vigilance — 2026-10-03 : l'image est en tag
:latest, en contradiction avec la doctrine de tag explicite appliquée aux autres services detas. Combiné àAutoUpdate=registry, un redémarrage peut changer la version sans décision ni traçabilité. Geler en remplaçant par un tag versionné après avoir relevé le digest courant (voir la section Procédure de mise à jour). - Nom du service Quadlet associé (non généré tant que le fichier reste désactivé) : `ollama-nvidia.service`
- Conteneur : `ollama_nv`
- Image : `docker.io/ollama/ollama:latest`
- Intégration GPU : hook OCI NVIDIA rootless (et non injection CDI directe)
- Mécanisme effectif déclaré dans le Quadlet :
PodmanArgs=--hooks-dir=/home/loic/.config/containers/oci-hooks-nvidia-rootless --cgroups=disabled
- Variables :
NVIDIA_VISIBLE_DEVICES=all,NVIDIA_DRIVER_CAPABILITIES=compute,utility,SecurityLabelDisable=true
Chemins de configuration
- `/home/loic/.config/containers/systemd/ollama-rocm.container`
- `/home/loic/.config/containers/systemd/ollama-nvidia.container.disabled-2026-10-17T11-12-14+0200` (Quadlet désactivé)
- `/etc/caddy/Caddyfile`
- `/home/loic/.bashrc` (alias CLI)
- `/home/loic/upgrade/ollama-dual-gpu-plan.md`
Volumes / persistance
- Stockage modèles partagé entre les deux instances : `/media/loic/nem/ollama`
- Montage conteneur : `/media/loic/nem/ollama -> /root/.ollama`
Dépendances
- Caddy 25434 -> 11434 avec basicauth pour l'instance AMD/ROCm
- NVIDIA driver pour la RTX 3070 (carte vérifiée :
NVIDIA GeForce RTX 3070) - Hook OCI NVIDIA rootless :
/home/loic/.config/containers/oci-hooks-nvidia-rootless - clients comme Open WebUI
Le fichier /var/run/cdi/nvidia.yaml existe sur la machine mais n'est pas le chemin
effectif : le Quadlet NVIDIA passe par --hooks-dir. Un diagnostic fondé sur
nvidia-ctk cdi list décrit donc un mécanisme qui ne pilote plus ce conteneur.
Remarques
- L'instance NVIDIA n'a fonctionné correctement qu'après mise en place de NVIDIA Container Toolkit et CDI.
- Le stockage de modèles est partagé entre les deux serveurs pour éviter les doublons disque.
- Par prudence, éviter les `ollama pull` simultanés sur les deux instances.
- Faire préférentiellement les opérations d'écriture (`pull`, `rm`, création de modèles) sur une seule instance à la fois.
- Contrainte plus large que `pull` : ne pas lancer une génération sur AMD et une sur NVIDIA en même temps. Le magasin étant partagé, llama.cpp verrouille le fichier de modèle et la seconde génération attend ou échoue. Le magasin fait 2,8 To au 2026-10-03.
- Le proxy public documenté actuellement cible uniquement l'instance AMD/ROCm.
Utilisation CLI
Sélection explicite du serveur
Pour cibler un serveur particulier depuis le terminal local, utiliser `OLLAMA_HOST`.
Exemples :
OLLAMA_HOST=http://127.0.0.1:11434 ollama list OLLAMA_HOST=http://127.0.0.1:11434 ollama run qwen3 OLLAMA_HOST=http://127.0.0.1:11435 ollama list OLLAMA_HOST=http://127.0.0.1:11435 ollama run qwen3
Alias shell
Alias ajoutés dans `/home/loic/.bashrc` :
alias ollama-amd='OLLAMA_HOST=http://127.0.0.1:11434 ollama' alias ollama-nvidia='OLLAMA_HOST=http://127.0.0.1:11435 ollama'
Exemples :
ollama-amd list ollama-amd run qwen3 ollama-nvidia list ollama-nvidia run qwen3
Exemples de tests
Test basique de disponibilité
curl http://127.0.0.1:11434/api/tags curl http://127.0.0.1:11435/api/tags
Questions de test
OLLAMA_HOST=http://127.0.0.1:11434 ollama run qwen3 "Donne-moi un résumé en 3 phrases de la différence entre ROCm et CUDA." OLLAMA_HOST=http://127.0.0.1:11435 ollama run qwen3 "Donne-moi un résumé en 3 phrases de la différence entre ROCm et CUDA."
OLLAMA_HOST=http://127.0.0.1:11434 ollama run qwen3 "Écris un haïku sur les GPU." OLLAMA_HOST=http://127.0.0.1:11435 ollama run qwen3 "Écris un haïku sur les GPU."
Vérifier le GPU utilisé côté NVIDIA
Les logs de `ollama-nvidia.service` doivent montrer une détection CUDA du type :
- `library=CUDA`
- `description="NVIDIA GeForce RTX 3070"`
Supervision / diagnostic
État des services
systemctl --user status ollama-rocm.service systemctl --user status ollama-nvidia.service
Journaux
journalctl --user -u ollama-rocm.service -n 100 --no-pager journalctl --user -u ollama-nvidia.service -n 100 --no-pager
Vérifier la carte NVIDIA
nvidia-smi watch -n 1 nvidia-smi
Vérifier le chemin d'intégration GPU réellement utilisé
# Hook OCI rootless (chemin effectif du Quadlet NVIDIA) ls -d /home/loic/.config/containers/oci-hooks-nvidia-rootless grep -n 'hooks-dir' /home/loic/.config/containers/systemd/ollama-nvidia.container # Le spec CDI existe sur la machine mais n'est pas injecte par ce Quadlet ls /var/run/cdi/nvidia.yaml
Conteneurs actifs
podman ps | grep -E 'ollama_roc|ollama_nv'
Contrôler la réponse API
curl http://127.0.0.1:11434/api/tags curl http://127.0.0.1:11435/api/tags
Données / emplacements à sauvegarder
- `/media/loic/nem/ollama`
- `/home/loic/.config/containers/systemd/ollama-rocm.container`
- `/home/loic/.config/containers/systemd/ollama-nvidia.container.disabled-2026-10-17T11-12-14+0200` (Quadlet désactivé)
- `/etc/caddy/Caddyfile`
- `/home/loic/.bashrc`
Sauvegarde
- Sauvegarder le répertoire de modèles partagé `/media/loic/nem/ollama`.
- Sauvegarder les deux services systemd user Ollama.
- Sauvegarder la configuration Caddy liée à `25434`.
Restauration
- Restaurer `/media/loic/nem/ollama`.
- Restaurer les fichiers systemd user `ollama-rocm.service` et `ollama-nvidia.service`.
- Recharger systemd user puis relancer les services :
systemctl --user daemon-reload systemctl --user restart ollama-rocm.service systemctl --user restart ollama-nvidia.service
- Vérifier ensuite `curl http://127.0.0.1:11434/api/tags` et `curl http://127.0.0.1:11435/api/tags`.
Procédure de mise à jour — ROCm et client CLI
La procédure ci-dessous met à jour uniquement l’instance AMD/ROCm. Elle ne redémarre pas ollama-nvidia.service et ne modifie pas les modèles.
Mise à jour du conteneur ROCm
# Sauvegarder la définition Quadlet avant modification éventuelle
STAMP=$(date +%Y%m%d-%H%M%S)
mkdir -p /home/loic/backups/ollama
cp -p /home/loic/.config/containers/systemd/ollama-rocm.container \
/home/loic/backups/ollama/ollama-rocm.container.before-update-${STAMP}.bak
# Télécharger l’image flottante ROCm puis recréer le conteneur
podman pull docker.io/ollama/ollama:rocm
systemctl --user daemon-reload
systemctl --user restart ollama-rocm.service
# Contrôler le service et la version API
systemctl --user is-active ollama-rocm.service
podman ps --filter name=ollama_roc
curl -fsS http://127.0.0.1:11434/api/version
curl -fsS http://127.0.0.1:11434/api/tags
Le 14 août 2026, cette procédure a fait passer l’API ROCm de 0.32.0 à 0.32.9. Au 3 octobre 2026, les deux instances répondaient en 0.35.1. Le 17 octobre, l’API ROCm 11434 répond en 0.40.5. L’instance NVIDIA 11435 n’était pas joignable ; sa version n’a pas été relevée, puis son lancement a été désactivé après constat de la boucle de redémarrages en échec (voir la trace datée ci-dessous). Le journal confirme la détection ROCm de la Radeon RX 7900 XTX.
Mise à jour du client CLI utilisateur
À recopier dans le terminal
Exécuter avec le compte utilisateur habituel, sans sudo. Le script local ci-dessous met à jour uniquement ~/.local/bin/ollama pour l’aligner sur la version du serveur AMD/ROCm. Il ne met à jour ni le conteneur, ni le binaire système, ni les modèles.
1. Vérifier sans rien modifier :
bash "$HOME/mediawiki/docs/mettre-a-jour-client-ollama.sh" --check
2. Lancer la mise à jour :
bash "$HOME/mediawiki/docs/mettre-a-jour-client-ollama.sh"
Chaque commande tient sur une seule ligne ; ne pas ajouter de barre oblique inverse. Le fichier est déjà présent sur le serveur. Aucun numéro de version ni SHA-256 n’est à remplacer à la main.
Le script sélectionne la release officielle correspondant à la version API du serveur, vérifie son SHA-256 publié par GitHub, extrait uniquement bin/ollama, teste sa version puis sauvegarde l’ancien client dans ~/backups/ollama/ avant un remplacement atomique. Si le client est déjà aligné, il n’est pas remplacé. Les erreurs de téléchargement, d’intégrité ou de version interrompent l’opération. Seuls les fichiers temporaires créés par le script sont nettoyés ; la sauvegarde est conservée.
Téléchargement à prévoir : environ 1,5 Go pour l’archive générique Linux amd64 de la release vérifiée ici ; le script n’installe pas les bibliothèques GPU de cette archive. --check ne télécharge pas l’archive et n’effectue aucune installation.
État vérifié le 30 octobre 2026
- Architecture :
x86_64→ archiveollama-linux-amd64.tar.zst. - Client actif :
~/.local/bin/ollama, version client0.40.5. - Serveur AMD/ROCm : version API
0.40.13; instance NVIDIA toujours non joignable lors de ce contrôle. - L’ancien bloc utilisait encore
VERSION=v0.35.1: le recopier aurait rétrogradé le client. Il est remplacé par la sélection automatique de la version du serveur. - Contrôles exécutés : syntaxe Bash, tests de remplacement et d’échec en environnement isolé, puis
--checkcontre le serveur et les métadonnées GitHub réels. Aucune mise à jour du client réel n’a été exécutée pendant cette vérification.
Référence : release officielle v0.40.13. L’empreinte de l’archive générique relevée est c9490e0f520be21271d969e6703f012268b1d39f8b70dd58854e5bfef7a75bb6 ; le script récupère celle de la release cible au moment de son exécution, sans valeur figée.
Source du script — pour consultation ou recréation du fichier
La commande courte ci-dessus suffit lorsque le fichier local existe. Le code complet reste disponible ci-dessous pour que la procédure soit autonome ; il n’est pas nécessaire de le recopier à chaque mise à jour.
#!/usr/bin/env bash
# Aligner uniquement le client utilisateur sur le serveur local AMD/ROCm.
# Usage : bash mettre-a-jour-client-ollama.sh [--check]
# --check : lectures réseau uniquement, sans téléchargement de l'archive.
# Aucun sudo, installateur distant, redémarrage, ni changement des modèles.
set -euo pipefail
export LC_ALL=C
MODE=${1:-update}
if (( $# > 1 )) || [[ "$MODE" != update && "$MODE" != --check ]]; then
echo "Usage : bash $0 [--check]" >&2
exit 2
fi
for outil in curl python3 uname readlink; do
command -v "$outil" >/dev/null || { echo "Outil manquant : $outil" >&2; exit 1; }
done
# Refuser une cible différente plutôt que mettre à jour le mauvais exécutable.
BIN="$HOME/.local/bin/ollama"
ACTIVE=$(command -v ollama)
[[ "$ACTIVE" = "$BIN" && -f "$BIN" && ! -L "$BIN" && -w "$BIN" ]] || { echo "Client actif inattendu ou non modifiable : $ACTIVE ; attendu : $BIN" >&2; exit 1; }
case $(uname -m) in
x86_64) ARCH=amd64 ;;
aarch64) ARCH=arm64 ;;
*) echo "Architecture non prise en charge" >&2; exit 1 ;;
esac
# Cible volontairement fixe : ne pas hériter d'un éventuel OLLAMA_HOST distant.
HOST=http://127.0.0.1:11434
VERSION=$(curl -fsS --connect-timeout 10 --max-time 30 "$HOST/api/version" | python3 -c 'import json,re,sys; v=json.load(sys.stdin)["version"]; assert re.fullmatch(r"[0-9]+\.[0-9]+\.[0-9]+",v), "Version serveur non stable/invalide"; print(v)')
ASSET="ollama-linux-$ARCH.tar.zst"
# Version exacte du serveur, jamais releases/latest. Les métadonnées sont
# parsées comme JSON ; aucun contenu téléchargé n'est évalué comme du shell.
META=$(curl -fsSL --connect-timeout 10 --max-time 60 "https://api.github.com/repos/ollama/ollama/releases/tags/v$VERSION")
INFO=$(printf '%s' "$META" | python3 -c 'import json,re,sys; d=json.load(sys.stdin); v,n=sys.argv[1:]; assert d["tag_name"]=="v"+v and not d["draft"] and not d["prerelease"], "Release non stable"; matches=[a for a in d["assets"] if a["name"]==n]; assert len(matches)==1,"Asset absent/ambigu"; a=matches[0]; digest=a.get("digest") or ""; assert re.fullmatch(r"sha256:[a-f0-9]{64}",digest),"SHA-256 officiel absent/invalide"; expected="https://github.com/ollama/ollama/releases/download/v"+v+"/"+n; assert a["browser_download_url"]==expected,"URL inattendue"; size=a["size"]; assert type(size) is int and size>0,"Taille invalide"; print(digest[7:],expected,size,sep="\n")' "$VERSION" "$ASSET")
mapfile -t FIELDS <<< "$INFO"
EXPECTED_SHA256=${FIELDS[0]}
URL=${FIELDS[1]}
SIZE=${FIELDS[2]}
printf 'Client actif : %s\nVersion cible du serveur : v%s\nArchive : %s (%s octets)\nSHA-256 officiel : %s\n' "$BIN" "$VERSION" "$ASSET" "$SIZE" "$EXPECTED_SHA256"
if [[ "$MODE" = --check ]]; then
echo "Aucun binaire modifié ; aucune archive téléchargée."
exit 0
fi
for outil in sha256sum zstd tar mktemp install cp cmp mv; do
command -v "$outil" >/dev/null || { echo "Outil manquant : $outil" >&2; exit 1; }
done
# --version contacte normalement le serveur : l'isoler pour lire le client.
client_version() {
OLLAMA_HOST=http://127.0.0.1:1 "$1" --version 2>&1 | python3 -c 'import re,sys; s=sys.stdin.read(); m=re.findall(r"(?:client version is|ollama version is) ([0-9]+\.[0-9]+\.[0-9]+)",s); assert len(m)==1,"Version client ambiguë/inconnue"; print(m[0])'
}
if [[ $(client_version "$BIN") = "$VERSION" ]]; then
echo "Client déjà aligné ; aucun téléchargement nécessaire."
OLLAMA_HOST="$HOST" "$BIN" list
exit 0
fi
# Les seuls fichiers supprimés par le nettoyage sont ceux créés par ce script.
# La sauvegarde persistante, le client installé et les modèles sont conservés.
WORK_BASE=${TMPDIR:-$HOME/.cache/ollama-client}
mkdir -p "$WORK_BASE"
TMP=$(mktemp -d "$WORK_BASE/ollama-client.XXXXXXXX")
STAGE=
cleanup() {
[[ -z "$STAGE" ]] || rm -f -- "$STAGE"
rm -rf -- "$TMP"
}
trap cleanup EXIT
ARCHIVE="$TMP/$ASSET"
curl -fL --retry 3 --connect-timeout 20 --max-time 3600 "$URL" -o "$ARCHIVE"
printf '%s %s\n' "$EXPECTED_SHA256" "$ARCHIVE" | sha256sum -c -
zstd -t "$ARCHIVE"
# Archive générique : les bibliothèques GPU restent dans le conteneur serveur.
# Pas d'extraction de lib/ ni d'installation du serveur natif.
tar --use-compress-program=zstd -xOf "$ARCHIVE" bin/ollama > "$TMP/ollama.new"
chmod 0755 "$TMP/ollama.new"
[[ $(client_version "$TMP/ollama.new") = "$VERSION" ]] || { echo "Version du candidat incorrecte" >&2; exit 1; }
# Si le serveur change pendant le téléchargement, recommencer au lieu
# d'installer silencieusement un client qui n'est déjà plus aligné.
CURRENT=$(curl -fsS --connect-timeout 10 --max-time 30 "$HOST/api/version" | python3 -c 'import json,sys; print(json.load(sys.stdin)["version"])')
[[ "$CURRENT" = "$VERSION" ]] || { echo "Version serveur changée ; relancer le script" >&2; exit 1; }
BACKUP_DIR="$HOME/backups/ollama"
mkdir -p "$BACKUP_DIR"
STAMP=$(date +%Y-%m-%dT%H-%M-%S%z)-$$
BACKUP="$BACKUP_DIR/ollama-client-user.bak-$STAMP"
cp -a -- "$BIN" "$BACKUP"
cmp -s -- "$BIN" "$BACKUP"
printf 'Sauvegarde vérifiée : %s\n' "$BACKUP"
# Renommage dans le répertoire du client : même système de fichiers, atomique.
STAGE=$(mktemp "$HOME/.local/bin/.ollama.new-XXXXXXXX")
install -m 0755 "$TMP/ollama.new" "$STAGE"
mv -f -- "$STAGE" "$BIN"
STAGE=
[[ $(client_version "$BIN") = "$VERSION" ]]
# Échec ici = installation effectuée mais accès serveur non validé, pas succès.
OLLAMA_HOST="$HOST" "$BIN" --version
OLLAMA_HOST="$HOST" "$BIN" list
CURRENT=$(curl -fsS --connect-timeout 10 --max-time 30 "$HOST/api/version" | python3 -c 'import json,sys; print(json.load(sys.stdin)["version"])')
[[ "$CURRENT" = "$VERSION" ]] || { echo "Client installé, mais serveur changé après installation" >&2; exit 1; }
printf 'Client aligné sur le serveur : %s\n' "$VERSION"
Historique des mises à jour précédentes
Résultat réel le 5 octobre 2026 : client /home/loic/.local/bin/ollama en 0.35.1, API ROCm 11434 en 0.35.1, commande ollama list : 100 lignes de sortie. Ancien binaire sauvegardé dans /home/loic/backups/ollama/ollama-client-user.bak-2026-10-05T00-00-29+0200.
Mise à jour et vérification du 17 octobre 2026 : client /home/loic/.local/bin/ollama mis à niveau de 0.35.1 à 0.40.5 (release officielle v0.40.5) pour l’aligner sur l’API ROCm 11434. SHA-256 publié par GitHub pour ollama-linux-amd64.tar.zst : dc5eabc292f9949546c90a97c820f924b035e05243b0de13c7f366182562169c. L’archive a passé sha256sum -c et zstd -t ; seul bin/ollama a été extrait. La sauvegarde vérifiée de l’ancien exécutable est /home/loic/backups/ollama/ollama-client-user.bak-2026-10-17T06-55-58+0200. Après remplacement atomique, le client annonce 0.40.5, l’API ROCm renvoie {"version":"0.40.5"} et ollama list réussit. Pendant ce contrôle, ollama_roc était actif, ollama-nvidia.service était activating et le port localhost 11435 refusait la connexion ; la version NVIDIA reste à vérifier.
Désactivation du lancement NVIDIA le 17 octobre 2026 : arrêt de la boucle de redémarrages, sauvegarde vérifiée /home/loic/backups/ollama/ollama-nvidia.container.before-disable-2026-10-17T11-12-14+0200.bak, puis renommage du Quadlet en /home/loic/.config/containers/systemd/ollama-nvidia.container.disabled-2026-10-17T11-12-14+0200. Après systemctl --user daemon-reload, ollama-nvidia.service est not-found et aucun conteneur ollama_nv n’est présent. Pour réactiver ultérieurement, remettre le fichier avec le suffixe .container, recharger systemd utilisateur, puis démarrer le service.
Pour remplacer également le binaire système, après validation et avec un compte root :
sudo cp -p /usr/bin/ollama /home/loic/backups/ollama/ollama-client.system.before-update-$(date +%Y%m%d-%H%M%S).bin sudo install -o root -g root -m 0755 /home/loic/.local/bin/ollama /usr/bin/ollama /usr/bin/ollama --version
Retour arrière
# Revenir à l’image actuellement utilisée avant le pull : utiliser son digest podman image ls --digests docker.io/ollama/ollama # Restaurer le Quadlet si nécessaire, puis relancer systemctl --user daemon-reload systemctl --user restart ollama-rocm.service # Désactiver le client utilisateur pour revenir au client système mv /home/loic/.local/bin/ollama /home/loic/.local/bin/ollama.disabled hash -r /usr/bin/ollama --version
État GPU et inventaire des modèles — 2026-10-03
Cartes réellement présentes
- AMD :
Card series: Navi 31 [Radeon RX 7900 XT/7900 XTX/7900M](vérifiérocm-smi) - NVIDIA :
NVIDIA GeForce RTX 3070(vérifiénvidia-smi)
Modèles recently installes (store partage, 2,8 To)
Installés depuis l'état Qwen3.8 du 2026-08-19 :
ornith-1.5:35b— 22 Goclef-flash:9b-q8_0— 10 Gotev1:4b-bf16— 8,4 Goqwen3.8-q4-256k:latest— 17 Go (précisément Q4_K_M)ornith-1.5:9b— 6,6 GoMaternion/mimo-v2.6:9b-thinking-q8_0etMaternion/mimo-v2.6:9b-instruct-q8_0— 10 Go chacun
Compatibilité chat et tool calling
Testé via l'API OpenAI-compatible le 2026-10-03 :
| Modèle | Chat | Tool calling | Remarque |
|---|---|---|---|
qwen3.8-q4-256k:latest |
oui | oui | reasoning model, réponse lente |
qwen3.8:27b-q4_K_M |
oui | oui | |
ornith-1.5:9b |
oui | oui | 4x plus réactif que qwen3.8-q4 |
clef-flash:9b-q8_0 |
non | — | Exclu : Ollama répond does not support chat
|
Ces modèles sont des reasoning models : la réflexion occupe d'abord le champ
reasoning, la réponse arrive ensuite dans content. Un budget
max_tokens trop serré est consommé par la réflexion et content reste vide — le
modèle paraît alors muet alors qu'il a raisonné. Tester avec max_tokens >= 600.
Le tool calling n'est pas affecté par ce phénomène et fonctionne même avec un budget court.
Consommation par Hermes
Hermes est branché sur l'instance AMD/ROCm via deux alias :
tas-rocm→qwen3.8-q4-256k:latesttas-rocm-fast→ornith-1.5:9b(≈16 s contre ≈1 min 13 s)
Configuration : ~/.hermes/config.yaml, section model:, clés aliases et
ollama_num_ctx (65536, volontairement inférieur aux 262144 du Quadlet pour tenir
en VRAM). Utilisation : /model tas-rocm-fast ou /model tas-rocm.
Précaution : ces alias pointent sur 11434. Ne pas lancer en parallèle une génération Hermes sur AMD et une autre sur 11435 (voir Remarques).
Maintenance documentaire
Lors d'un changement de port, de proxy public, de stockage des modèles, de pilote GPU, de toolkit NVIDIA, d'alias shell ou d'architecture AMD/NVIDIA, mettre à jour cette page et la page centrale Trace install tas.
Trace documentaire
Cette page fait partie de Trace install tas.\n\n== État Quadlet confirmé — 2026-07-25 ==
Les deux instances Ollama sont définies par Quadlet :
- ROCm :
ollama-rocm.service, conteneurollama_roc, port11434, imagedocker.io/ollama/ollama:rocm, API vérifiée en version0.35.1le 3 octobre 2026 - NVIDIA :
ollama-nvidia.service, conteneurollama_nv, port11435, imagedocker.io/ollama/ollama:latest - Fichiers :
/home/loic/.config/containers/systemd/ollama-rocm.containeretollama-nvidia.container - Modèles partagés :
/media/loic/nem/ollama
Au 3 octobre 2026, les deux instances répondaient en 0.35.1. Au contrôle du 17 octobre, seule l’API ROCm sur 11434 a pu être vérifiée, en 0.40.5 ; le port local 11435 refusait la connexion, donc la version NVIDIA actuelle reste inconnue. Le tag :rocm est flottant ; pour figer une version, comparer son digest à un tag versionné tel que :0.32.3-rocm puis modifier le Quadlet.
L'instance NVIDIA reste dépendante de la cohérence entre le pilote noyau, les bibliothèques NVIDIA, le toolkit et le CDI.
Qwen3.8 (2026-08-19)
Modèles installés dans l’instance AMD/ROCm :
- `qwen3.8-q4-256k` : modèle officiel Qwen3.8 27B, Q4_K_M, environ 17 Go.
- `qwen3.8-q8-256k` : modèle officiel Qwen3.8 27B, Q8_0, environ 29 Go.
- `qwen3.8-abliterated-q4-256k` : `huihui_ai/Qwen3.8-abliterated:27b`, variante communautaire Q4, environ 17 Go.
Les trois modèles configurés utilisent `num_ctx=262144` et `temperature=0.2`. La variante abliterated n’est pas une publication officielle Alibaba/Ollama et peut avoir un comportement de sûreté différent.
Le Quadlet ROCm définit également `OLLAMA_CONTEXT_LENGTH=262144`, `OLLAMA_FLASH_ATTENTION=1`, `OLLAMA_KV_CACHE_TYPE=q8_0`, `OLLAMA_NUM_PARALLEL=1`, `OLLAMA_MAX_LOADED_MODELS=1` et `OLLAMA_LOAD_TIMEOUT=15m`. Le stockage partagé reste `/media/loic/nem/ollama`.
Les Modelfiles sont archivés dans `minidev/ollama-qwen38/` sur Nextcloud.
[À vérifier — 2026-10-03] Ce chemin n'a pas pu être résolu sur tas (ni minidev ni /home/loic/minidev n'existent) : le share Nextcloud correspondant n'est pas monté. Emplacement réel des Modelfiles non vérifié — corriger quand le share sera disponible. Le Q4 a été testé via l’API et a répondu correctement ; le test de génération a utilisé 4096 tokens uniquement pour limiter le coût du test, la configuration persistante restant à 256K.