From 0fa7c4936b3c68c95a9c70a99645e622934ec5b2 Mon Sep 17 00:00:00 2001 From: maxime Date: Wed, 18 Nov 2026 15:28:41 +0100 Subject: [PATCH] =?UTF-8?q?Image=20embeddings-bge-m3=20:=20jeton=20exig?= =?UTF-8?q?=C3=A9=20devant=20Ollama?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit L'image ollama-bge-m3 devient embeddings-bge-m3 (image et conteneur), avec une description OCI pour la page du paquet dans Gitea. Caddy 2.10.2, devant Ollama, ne laisse passer que les requêtes qui portent « Authorization: Bearer » (la « API key » des embeddings dans LibreDesk) ; Ollama n'écoute plus que dans le conteneur (127.0.0.1:11435). Le jeton est donné au lancement (ollama/.env, hors de git), jamais rangé dans l'image publique ; sans jeton valable, le conteneur refuse de démarrer. verifier_ollama.py lit le jeton à côté de lui et vérifie aussi qu'une requête sans jeton est refusée ; 3_brancher_ia.py le donne à l'instance de test. Essais réels hors ligne et gestes de production (points 1 ter, 6 bis) dans docs/. Co-Authored-By: Claude Opus 5.5 --- .claude/settings.json | 3 +- .gitignore | 1 + README.md | 10 ++- docs/production.md | 25 ++++-- docs/verifications.md | 11 +++ instance-de-test/3_brancher_ia.py | 10 ++- ollama/Caddyfile | 27 ++++++ ollama/Dockerfile | 26 ++++-- ollama/compose.reseau.yml | 4 +- ollama/compose.yml | 18 ++-- ollama/demarrer.sh | 32 +++++++ ollama/verifier_ollama.py | 61 ++++++++++--- tests/test_ollama.py | 144 ++++++++++++++++++++++++++---- 13 files changed, 315 insertions(+), 57 deletions(-) create mode 100644 ollama/Caddyfile create mode 100644 ollama/demarrer.sh diff --git a/.claude/settings.json b/.claude/settings.json index 0a20351..9b30fb2 100644 --- a/.claude/settings.json +++ b/.claude/settings.json @@ -6,7 +6,8 @@ "Read(./.env)", "Read(./.env.*)", "Read(./instance-de-test/.env)", - "Read(./acces/.env)" + "Read(./acces/.env)", + "Read(./ollama/.env)" ] }, "hooks": {} diff --git a/.gitignore b/.gitignore index 86bd1a5..cc58b58 100644 --- a/.gitignore +++ b/.gitignore @@ -1,6 +1,7 @@ .env instance-de-test/.env acces/.env +ollama/.env acces/database.db acces/utilisateurs.json instance-de-test/config.toml diff --git a/README.md b/README.md index ffc40f6..03b95cd 100644 --- a/README.md +++ b/README.md @@ -4,7 +4,7 @@ Les demandes des clients AIMsight arrivent par mail dans LibreDesk (`helpdesk.se Ce dépôt porte tout ce qu'il faut pour cela : - `snippets/` : les textes des snippets, relus (`textes/`, un fichier par snippet), les consignes de rédaction (`consignes_redaction.md`, à coller dans Admin → IA → Providers → Custom instructions) et l'import vers LibreDesk ; -- `ollama/` : l'image Ollama avec le modèle d'embeddings `bge-m3:567m` embarqué, qui sert la recherche dans la base depuis le serveur de LibreDesk ; +- `ollama/` : l'image `embeddings-bge-m3`, Ollama avec le modèle d'embeddings `bge-m3:567m` embarqué (API OpenAI, 1024 dimensions, hors ligne), qui sert la recherche dans la base depuis le serveur de LibreDesk. Caddy, devant Ollama, exige `Authorization: Bearer ` : le jeton est dans `ollama/.env` (hors de git), et c'est la « API key » des embeddings dans LibreDesk ; - `acces/` : le service d'accès, appelé par l'outil `get_customer_access` de LibreDesk au clic sur « Generate reply » : les stations que le client de la conversation peut voir sur le dashboard (export d'Auth0 `acces/utilisateurs.json` + ses UserGroup, en lecture seule) ; lancement dans `acces/compose.yml` ; - `instance-de-test/` : un LibreDesk v2.9.0 local avec Mailpit (un piège SMTP : rien ne sort), pour tout essayer avant la production ; - `.vscode/tasks.json` : les opérations courantes en un clic (Terminal → Run Task). @@ -27,7 +27,11 @@ Sous WSL (Ubuntu), depuis `~/aimsight-libredesk` (ex-Support-LibreDesk, renommé python3 -m unittest discover -s tests -v ``` -Les secrets restent hors de git : `.env` (la clé Anthropic de l'instance de test, `export ANTHROPIC_API_KEY=…`, et les clés admin temporaires d'un import en production) et `instance-de-test/.env` (écrit par `2_creer_boite_et_cle.py`). +Les secrets restent hors de git : `.env` (la clé Anthropic de l'instance de test, `export ANTHROPIC_API_KEY=…`, et les clés admin temporaires d'un import en production) , `instance-de-test/.env` (écrit par `2_creer_boite_et_cle.py`) et `ollama/.env` (`EMBEDDINGS_JETON=…`, le jeton d'embeddings-bge-m3 ; 32 caractères au moins, lettres, chiffres, `_` et `-`) : + +```bash +echo "EMBEDDINGS_JETON=$(python3 -c 'import secrets; print(secrets.token_urlsafe(32))')" >> ollama/.env && chmod 600 ollama/.env +``` ### L'instance de test @@ -41,7 +45,7 @@ bash instance-de-test/1_demarrer.sh 'TestAdmin-2026!' python3 instance-de-test/2_creer_boite_et_cle.py 'TestAdmin-2026!' ``` -Puis Ollama sur son réseau (sur ce poste, un Ollama Windows occupe déjà le port 11434 : on publie sur 11435) : +Puis embeddings-bge-m3 sur son réseau (sur ce poste, un Ollama Windows occupe déjà le port 11434 : on publie sur 11435 ; le jeton vient de `ollama/.env`, et `3_brancher_ia.py` le donne à LibreDesk comme clé) : ```bash docker compose -f ollama/compose.yml build diff --git a/docs/production.md b/docs/production.md index b1d4570..9643734 100644 --- a/docs/production.md +++ b/docs/production.md @@ -15,6 +15,12 @@ Rien de ce qui suit n'envoie de message : « Generate reply » pose un brouillon - [x] **0 ter. Rien d'automatique** (vérifié le 2026-11-11). Admin → Automations : aucune règle ; Admin → IA → Tools : aucun outil ; aucun webhook ; Admin → IA → Suggestions : « Learn from resolved conversations » désactivé. - [x] **1 provisoire. LM Studio sur le PC de Maxime** (2026-11-11). `text-embedding-bge-m3` (bge-m3 Q8_0) sur `http://10.0.2.140:1234/v1` (adresse Wi-Fi attribuée par DHCP). Le PC doit rester allumé, LM Studio lancé avec son serveur actif. **Remplacé par Ollama ci-dessous.** - [x] **1 bis provisoire. L'image Ollama sur le PC de Maxime** (2026-11-12), à la place de LM Studio, pour essayer le paquet comme le fera le serveur : dossier `~/essai-production/ollama` avec seulement les deux fichiers compose et `verifier_ollama.py`, `.env` = `OLLAMA_BIND=10.0.2.140` + `OLLAMA_PORT=11435`, `docker compose up -d --no-build` (image tirée de Gitea **sans login** : le paquet est public). Pare-feu de WSL (Hyper-V, bloque tout en entrée par défaut, sans interface graphique) ouvert par Maxime : règle `Ollama-LibreDesk`, TCP 11435, d'abord depuis `10.0.0.0/8`, puis resserrée au seul serveur LibreDesk `10.0.1.184` ; à retirer après l'essai (`Remove-NetFirewallHyperVRule -Name "Ollama-LibreDesk"`). Embeddings dans LibreDesk : `http://10.0.2.140:11435/v1`, `bge-m3:567m`, clé `ollama`, dimensions vides (0). Test réussi ; 118 appels `/v1/embeddings` depuis LibreDesk (`10.0.1.184`), tous en 200. Mêmes limites que LM Studio : PC allumé, adresse Wi-Fi qui peut changer. +- [ ] **1 ter. Le jeton sur le PC de Maxime** (image `embeddings-bge-m3`, branche `embeddings-token`). L'image renommée exige `Authorization: Bearer ` ; Ollama n'écoute plus que dans le conteneur, Caddy devant lui. Elle est déjà construite sur le PC : pas besoin de l'avoir poussée sur Gitea pour cet essai. L'ancienne image accepte n'importe quelle clé : on change donc d'abord la clé dans LibreDesk, puis le conteneur, sans coupure. + 1. Tirer un jeton (Maxime, jamais montré à Claude) : `python3 -c 'import secrets; print(secrets.token_urlsafe(32))'`, et l'ajouter à `~/essai-production/ollama/.env` : `EMBEDDINGS_JETON=`. + 2. LibreDesk, Admin → IA → Providers, Embedding : **API key** = le jeton ; URL, modèle et *dimensions* inchangés (*dimensions* vide ou 0 : bge-m3 rend 1024 nombres, pas 1536). *Test connection*, puis *Save*. La clé n'entre pas dans l'empreinte des extraits : pas de recalcul. + 3. Copier les nouveaux `compose.yml` et `verifier_ollama.py` dans `~/essai-production/ollama`, puis `cd ~/essai-production/ollama && docker compose up -d --no-build` (remplace `ollama-bge-m3` par `embeddings-bge-m3`, quelques secondes sans base). + 4. Vérification : `python3 ~/essai-production/ollama/verifier_ollama.py http://10.0.2.140:11435/v1` → `OK bge-m3:567m, 1024 dimensions, jeton exigé` (le jeton est lu dans le `.env` voisin) ; dans LibreDesk, *Test connection* réussit ; un « Generate reply » s'appuie sur la base. + Retour en arrière : dans le `compose.yml` de `~/essai-production/ollama`, remettre l'image `ollama-bge-m3:0.40.16-567m` et `container_name: ollama-bge-m3`, `docker compose up -d --no-build` ; la clé de LibreDesk peut rester (l'ancienne image l'ignore). - [x] **2. Embeddings** (2026-11-11). Fournisseur OpenAI, URL `http://10.0.2.140:1234/v1`, modèle `text-embedding-bge-m3`, clé `lm-studio`, *embedding max tokens* 2048. - [x] **3. Complétion** (2026-11-11). *Max tokens* 4096 ; *Custom instructions* = `snippets/consignes_redaction.md` ; Claude Sonnet 5.5, `https://api.anthropic.com/v1`, effort `medium`. - [x] **4. Import de la base** (2026-11-11). 118 extraits actifs. Agent « Import base » (id 127) : clé révoquée, agent désactivé. Pour un réimport : regénérer une clé, réactiver l'agent, mettre la clé dans `.env` (`export LIBREDESK_ADMIN_KEY=…`, `export LIBREDESK_ADMIN_SECRET=…`), tâche « Snippets : envoyer en simulation (PRODUCTION) » puis « Snippets : ENVOYER (PRODUCTION) », puis tout révoquer. @@ -27,6 +33,7 @@ But : remplacer LM Studio par Ollama (`bge-m3:567m`) sur le serveur de LibreDesk - [x] **6. L'image.** Sur le poste, tâche « Ollama : construire » (ou `docker compose -f ollama/compose.yml build`), puis vérification hors ligne (`verifications.md`). Puis, avec l'accord de Maxime, la pousser au registre Gitea : jeton Gitea à portée `write:package`, `docker login exchange.sensima.ch`, `docker push exchange.sensima.ch/maxime.pasquier/ollama-bge-m3:0.40.16-567m`, puis `docker logout exchange.sensima.ch` (le login garde le jeton en clair dans `~/.docker/config.json`). Vérification : l'image apparaît dans Packages du compte. Si le registre la refuse (taille), on la transportera par SSH au point 8. Construite et vérifiée hors ligne le 2026-11-12 (2,43 Go, sans clé privée : chaque conteneur crée la sienne au démarrage). Poussée le 2026-11-12, digest `sha256:332fbdec63583c8b2ac59a168cbd8c3e39624047662b912e58d9f3f7fff99530`. Pour le serveur (point 8) : un autre jeton, `package` en **lecture seule**. +- [ ] **6 bis. L'image renommée, avec jeton.** `exchange.sensima.ch/maxime.pasquier/embeddings-bge-m3:0.40.16-567m`, construite et vérifiée hors ligne le 2026-11-18 (2,49 Go ; `verifications.md`). À pousser comme au point 6, avec l'accord de Maxime. Puis, dans Gitea, la rattacher au dépôt (paramètres du paquet → lier au dépôt `aimsight-libredesk`). L'ancien paquet `ollama-bge-m3` ne sera supprimé qu'une fois plus rien ne l'utilise (point 1 ter fait), avec l'accord de Maxime. - [ ] **7. État des lieux du serveur, sans rien changer** (Maxime, en SSH). ```bash @@ -44,8 +51,8 @@ But : remplacer LM Studio par Ollama (`bge-m3:567m`) sur le serveur de LibreDesk ```bash ssh mkdir -p ollama && scp ollama/compose.yml ollama/compose.reseau.yml ollama/verifier_ollama.py :ollama/ ``` - Récupérer l'image : `docker login exchange.sensima.ch && docker pull exchange.sensima.ch/maxime.pasquier/ollama-bge-m3:0.40.16-567m && docker logout exchange.sensima.ch` ; ou, si le registre l'a refusée, depuis le poste : `docker save exchange.sensima.ch/maxime.pasquier/ollama-bge-m3:0.40.16-567m | gzip | ssh 'gunzip | docker load'`. Vérifier : `docker image ls exchange.sensima.ch/maxime.pasquier/ollama-bge-m3` montre le tag `0.40.16-567m`. - Puis écrire `~/ollama/.env` sur le serveur. Docker Compose le lit à chaque commande lancée depuis `~/ollama` : les réglages ne dépendent d'aucune option à retenir, et un simple `docker compose …` garde toujours Ollama au bon endroit. Selon l'état des lieux : + Récupérer l'image : `docker pull exchange.sensima.ch/maxime.pasquier/embeddings-bge-m3:0.40.16-567m` (paquet public : sans login) ; ou, si le registre l'a refusée, depuis le poste : `docker save exchange.sensima.ch/maxime.pasquier/embeddings-bge-m3:0.40.16-567m | gzip | ssh 'gunzip | docker load'`. Vérifier : `docker image ls exchange.sensima.ch/maxime.pasquier/embeddings-bge-m3` montre le tag `0.40.16-567m`. + Puis écrire `~/ollama/.env` sur le serveur (`chmod 600`), avec, dans tous les cas, un jeton **propre au serveur** (pas celui du PC) : `EMBEDDINGS_JETON=`, tiré par `python3 -c 'import secrets; print(secrets.token_urlsafe(32))'`. Sans lui, le conteneur refuse de démarrer. Docker Compose le lit à chaque commande lancée depuis `~/ollama` : les réglages ne dépendent d'aucune option à retenir, et un simple `docker compose …` garde toujours Ollama au bon endroit. Selon l'état des lieux : - **LibreDesk dans Docker** (cas attendu) : ``` COMPOSE_FILE=compose.yml:compose.reseau.yml @@ -61,16 +68,16 @@ But : remplacer LM Studio par Ollama (`bge-m3:567m`) sur le serveur de LibreDesk ```bash cd ~/ollama && docker compose up -d --no-build ``` - Vérification : `docker ps --filter name=ollama-bge-m3` montre `Up … (healthy)` ; `docker inspect ollama-bge-m3 --format '{{.HostConfig.RestartPolicy.Name}}'` rend `unless-stopped` ; dans le cas Docker, `docker network inspect --format '{{range .Containers}}{{.Name}} {{end}}'` liste `ollama-bge-m3`. + Vérification : `docker ps --filter name=embeddings-bge-m3` montre `Up … (healthy)` ; `docker inspect embeddings-bge-m3 --format '{{.HostConfig.RestartPolicy.Name}}'` rend `unless-stopped` ; dans le cas Docker, `docker network inspect --format '{{range .Containers}}{{.Name}} {{end}}'` liste `embeddings-bge-m3`. - [ ] **9. Vérifier Ollama.** - - Depuis le serveur : `python3 ~/ollama/verifier_ollama.py http://127.0.0.1:11434/v1` (ou l'adresse interne) → `OK bge-m3:567m, 1024 dimensions`. - - Depuis le réseau de LibreDesk (cas Docker) : `docker run --rm --network -v ~/ollama:/o:ro python:3.12-alpine python /o/verifier_ollama.py http://ollama:11434/v1` → même résultat (il faut que le serveur puisse tirer `python:3.12-alpine` ; sinon le test du point 10 depuis LibreDesk fait foi). - - **De l'extérieur** : depuis un téléphone en 4G (Wi-Fi coupé), ouvrir `http://46.14.212.91:11434` : la page **ne doit pas répondre**. Si elle répond (« Ollama is running »), arrêter Ollama (`cd ~/ollama && docker compose down`) et revoir le point 7 avec la personne qui gère le serveur. - - Si `python3` manque ou est trop ancien sur le serveur : `curl -s http://127.0.0.1:11434/v1/models` doit lister `bge-m3:567m`. + - Depuis le serveur : `python3 ~/ollama/verifier_ollama.py http://127.0.0.1:11434/v1` (ou l'adresse interne) → `OK bge-m3:567m, 1024 dimensions, jeton exigé`. Le jeton est lu dans `~/ollama/.env`, à côté du script ; le script vérifie aussi qu'une requête **sans** jeton est refusée. + - Depuis le réseau de LibreDesk (cas Docker) : `docker run --rm --network -v ~/ollama:/o:ro python:3.12-alpine python /o/verifier_ollama.py http://ollama:11434/v1` → même résultat (le `.env` monté avec `/o` donne le jeton ; il faut que le serveur puisse tirer `python:3.12-alpine` ; sinon le test du point 10 depuis LibreDesk fait foi). + - **De l'extérieur** : depuis un téléphone en 4G (Wi-Fi coupé), ouvrir `http://46.14.212.91:11434` : la page **ne doit pas répondre**. Si elle répond (« jeton manquant ou invalide »), le jeton protège encore, mais le port est exposé : arrêter le service (`cd ~/ollama && docker compose down`) et revoir le point 7 avec la personne qui gère le serveur. + - Si `python3` manque ou est trop ancien sur le serveur : `curl -s http://127.0.0.1:11434/v1/models` doit rendre `jeton manquant ou invalide` ; avec le jeton (`set -a && . ~/ollama/.env && set +a && curl -s -H "Authorization: Bearer $EMBEDDINGS_JETON" http://127.0.0.1:11434/v1/models`), la liste avec `bge-m3:567m`. - **Ne pas redémarrer le service Docker pour essayer** : cela redémarrerait aussi LibreDesk. `systemctl is-enabled docker` (point 7) et la politique `unless-stopped` suffisent ; le prochain redémarrage planifié du serveur le confirmera (vérifier alors `docker ps`). -- [ ] **10. Brancher LibreDesk sur Ollama.** Admin → IA → Providers, Embeddings : fournisseur OpenAI, URL de l'étape 8, modèle `bge-m3:567m`, clé `ollama`, *dimensions* 0, *embedding max tokens* 2048. Bouton de test, puis enregistrer seulement s'il réussit. +- [ ] **10. Brancher LibreDesk sur Ollama.** Admin → IA → Providers, Embeddings : fournisseur OpenAI, URL de l'étape 8, modèle `bge-m3:567m`, clé = le jeton du serveur (`EMBEDDINGS_JETON` de `~/ollama/.env`), *dimensions* 0, *embedding max tokens* 2048. Bouton de test, puis enregistrer seulement s'il réussit. Vérification : le test réussit ; la complétion n'a pas changé. - [ ] **11. Le recalcul.** LibreDesk recalcule seul les 118 extraits (environ une minute). Dans ses journaux (`docker logs --since 10m 2>&1 | grep -E "embedding provider changed|reconciled embeddings|error generating embeddings"`) : @@ -102,7 +109,7 @@ Au clic sur « Generate reply », le LLM peut appeler l'outil `get_customer_acce ## Au quotidien -- **Si Ollama est arrêté**, « Generate reply » rend quand même un brouillon, mais **sans la base de connaissances**, et rien ne le signale à l'agent (journaux de LibreDesk : `AI provider unavailable`, `search_articles` en erreur). Si les brouillons deviennent vagues : `docker ps --filter name=ollama-bge-m3` et `python3 ~/ollama/verifier_ollama.py …` sur le serveur. Pour le relancer (un arrêt manuel n'est pas relancé seul), toujours `cd ~/ollama && docker compose up -d --no-build` plutôt que `docker start` : si LibreDesk a recréé son réseau entre-temps, seul Compose y rattache Ollama. +- **Si Ollama est arrêté**, « Generate reply » rend quand même un brouillon, mais **sans la base de connaissances**, et rien ne le signale à l'agent (journaux de LibreDesk : `AI provider unavailable`, `search_articles` en erreur). Si les brouillons deviennent vagues : `docker ps --filter name=embeddings-bge-m3` et `python3 ~/ollama/verifier_ollama.py …` sur le serveur. Pour le relancer (un arrêt manuel n'est pas relancé seul), toujours `cd ~/ollama && docker compose up -d --no-build` plutôt que `docker start` : si LibreDesk a recréé son réseau entre-temps, seul Compose y rattache Ollama. - **Ollama est rattaché au réseau de LibreDesk** (cas Docker) : tant qu'il y est, un `docker compose down` de LibreDesk ne peut pas supprimer ce réseau (avertissement « Resource is still in use », ou erreur avec l'ancien `docker-compose`). Arrêter Ollama d'abord (`cd ~/ollama && docker compose down`), puis le relancer après LibreDesk. - **Retoucher la base** : modifier le fichier dans `snippets/textes/`, puis réimporter (point 4). Un extrait renommé ou retiré du corpus est signalé (« dans LibreDesk mais pas dans le corpus ») et **n'est pas supprimé** : le désactiver ou le supprimer à la main dans Admin → IA → Snippets. - **Changer de version d'Ollama** : modifier `ollama/Dockerfile`, reconstruire, revérifier hors ligne (`docker run --network none …`, puis `ollama/verifier_ollama.py`), puis refaire les points 6, 8 et 9. Même modèle, même adresse : pas de recalcul. diff --git a/docs/verifications.md b/docs/verifications.md index 26ad07b..ec28c9e 100644 --- a/docs/verifications.md +++ b/docs/verifications.md @@ -24,6 +24,17 @@ Repris de Support-AI (vérifications des 2026-11-09 et 2026-11-11), limité à c **Le réseau du poste** : WSL est en mode `networkingMode=mirrored` ; WSL et Docker ne joignent Windows que par `127.0.0.1`. Pour qu'un conteneur joigne LM Studio sur Windows, il fallait un relais `socat` (voir l'historique de Support-AI) ; avec Ollama dans Docker, le réseau Docker de l'instance suffit. +## L'image renommée embeddings-bge-m3, avec jeton (2026-11-18) [code, test] + +Image `exchange.sensima.ch/maxime.pasquier/embeddings-bge-m3:0.40.16-567m` (2,49 Go) : la précédente, plus Caddy 2.10.2 devant Ollama. Ollama n'écoute que sur `127.0.0.1:11435` dans le conteneur ; Caddy, sur 11434, ne transmet que les requêtes qui portent `Authorization: Bearer `. +- LibreDesk v2.9.0 envoie la clé des embeddings en `Authorization: Bearer ` (`internal/ai/openai.go`, `post`), et lit un 401 comme « clé API invalide » (`ErrInvalidAPIKey`, sans nouvel essai). La clé n'entre pas dans l'empreinte des extraits (`itemFingerprint`) : la changer ne déclenche pas de recalcul. +- Sans jeton, ou avec un jeton de moins de 32 caractères : le conteneur s'arrête aussitôt (code 1, message `EMBEDDINGS_JETON manquant ou invalide`). +- Hors ligne (réseau Docker `--internal`, alias `ollama` comme sur le réseau de LibreDesk) : `healthy` ; `verifier_ollama.py` → `OK bge-m3:567m, 1024 dimensions, jeton exigé` ; sans en-tête, mauvais jeton, ancienne clé `ollama` : 401 ; bon jeton : 200 ; Ollama lui-même (11435) injoignable depuis un autre conteneur. +- Ollama, lié à 127.0.0.1, refuse (403) un Host non local comme `ollama:11434` : Caddy réécrit `Host` (`header_up Host 127.0.0.1:11435`), et ne transmet pas le jeton à Ollama. +- Le jeton n'apparaît pas dans `docker logs` ; il est dans l'environnement de Caddy seulement, pas dans celui d'Ollama. Il reste lisible par `docker inspect` (comme `ACCES_JETON`) : réservé à qui administre Docker. +- `docker stop` : arrêt immédiat (les signaux sont transmis). Ollama tué dans le conteneur : le conteneur s'arrête, Docker le relance (`RestartCount` 1), de nouveau `healthy`. +- Port publié sur `127.0.0.1:11436`, depuis WSL : même résultat que hors ligne. + ## La simulation du passage à Ollama (2026-11-12) [test] Instance de test neuve (LibreDesk v2.9.0, Mailpit), base importée (118 extraits), image `exchange.sensima.ch/maxime.pasquier/ollama-bge-m3:0.40.16-567m` (Ollama 0.40.16, `bge-m3:567m`, **2,43 Go**) sur le réseau Docker de l'instance (`ollama/compose.reseau.yml`). diff --git a/instance-de-test/3_brancher_ia.py b/instance-de-test/3_brancher_ia.py index 46066f5..cb71a10 100644 --- a/instance-de-test/3_brancher_ia.py +++ b/instance-de-test/3_brancher_ia.py @@ -4,6 +4,8 @@ d'embeddings à un autre (LibreDesk recalcule alors seul les vecteurs). Ne crée ANTHROPIC_API_KEY=… python3 instance-de-test/3_brancher_ia.py [clé] ex. : … 'TestAdmin-2026!' http://ollama:11434/v1 bge-m3:567m +Sans [clé] : le jeton d'embeddings-bge-m3 (EMBEDDINGS_JETON, dans l'environnement ou dans ollama/.env), pour ne pas +le taper dans la commande. """ import os import sys @@ -11,7 +13,10 @@ from pathlib import Path from connexion_admin import connexion, req -CONSIGNES = Path(__file__).resolve().parents[1] / "snippets" / "consignes_redaction.md" +DEPOT = Path(__file__).resolve().parents[1] +CONSIGNES = DEPOT / "snippets" / "consignes_redaction.md" +sys.path.insert(0, str(DEPOT / "ollama")) +from verifier_ollama import lire_jeton # noqa: E402 def configurer(type_: str, config: dict) -> None: @@ -20,8 +25,9 @@ def configurer(type_: str, config: dict) -> None: print(f"{type_} : test réussi, configuration enregistrée") -def main(mot_de_passe: str, url_embeddings: str, modele: str, cle: str = "ollama") -> None: +def main(mot_de_passe: str, url_embeddings: str, modele: str, cle: str | None = None) -> None: cle_claude = os.environ.get("ANTHROPIC_API_KEY") or sys.exit("ANTHROPIC_API_KEY manque dans l'environnement") + cle = cle or lire_jeton() or sys.exit("pas de clé d'embeddings : EMBEDDINGS_JETON manque (environnement ou ollama/.env)") connexion(mot_de_passe) configurer("completion", {"provider": "openai", "base_url": "https://api.anthropic.com/v1", "api_key": cle_claude, "model": "claude-sonnet-5-5", "max_tokens": 4096, "reasoning_effort": "medium", diff --git a/ollama/Caddyfile b/ollama/Caddyfile new file mode 100644 index 0000000..cdbe1e2 --- /dev/null +++ b/ollama/Caddyfile @@ -0,0 +1,27 @@ +# Le portier de l'image embeddings-bge-m3 : seul port publié (11434), il ne laisse passer vers Ollama +# (127.0.0.1:11435, joignable seulement dans le conteneur) que les requêtes qui portent +# « Authorization: Bearer ». Le jeton est donné au lancement, jamais rangé dans l'image. +# demarrer.sh vérifie le jeton avant de lancer Caddy : 32 caractères au moins, lettres, chiffres, « _ » et « - » +# seulement (« * » serait un joker pour le filtre header, « } » casserait la substitution). +{ + admin off + auto_https off + persist_config off +} + +:11434 { + @autorise header Authorization "Bearer {$EMBEDDINGS_JETON}" + + handle @autorise { + reverse_proxy 127.0.0.1:11435 { + # Ollama, lié à 127.0.0.1, refuse (403) un Host qui n'est pas local, comme « ollama:11434 ». + header_up Host 127.0.0.1:11435 + header_up -Authorization + } + } + + handle { + header WWW-Authenticate "Bearer" + respond "jeton manquant ou invalide" 401 + } +} diff --git a/ollama/Dockerfile b/ollama/Dockerfile index ec40dc3..6760c4b 100644 --- a/ollama/Dockerfile +++ b/ollama/Dockerfile @@ -1,5 +1,8 @@ +# embeddings-bge-m3 : un service d'embeddings (bge-m3, 1024 dimensions, format OpenAI) protégé par un jeton. # Ollama avec bge-m3 embarqué : l'image démarre sans rien télécharger, et c'est le même modèle partout. -# Versions figées (2026-11-12) ; les changer = reconstruire et revérifier (ollama/verifier_ollama.py). +# Devant Ollama, Caddy exige « Authorization: Bearer » (Caddyfile, demarrer.sh). +# Versions figées (Ollama 2026-11-12, Caddy 2026-11-18) ; les changer = reconstruire et revérifier +# (ollama/verifier_ollama.py). # 1. Le modèle, téléchargé à la construction par l'image officielle (un serveur lancé le temps du pull) ; # puis les bibliothèques GPU retirées (4,4 Go de CUDA) : bge-m3 tourne sur processeur. @@ -11,21 +14,32 @@ RUN ollama serve >/tmp/serve.log 2>&1 & \ rm -rf /usr/lib/ollama/cuda_v12 /usr/lib/ollama/cuda_v13 /usr/lib/ollama/mlx_cuda_v13 \ /usr/lib/ollama/vulkan /usr/lib/ollama/include -# 2. L'image livrée : la même Ubuntu 24.04 que l'image officielle, Ollama, ses bibliothèques processeur, le modèle. +# 2. Le portier : Caddy, un seul binaire statique, pris dans l'image officielle. +FROM caddy:2.10.2-alpine AS portier + +# 3. L'image livrée : la même Ubuntu 24.04 que l'image officielle d'Ollama, Ollama, ses bibliothèques processeur, +# le modèle, et Caddy. FROM ubuntu:noble-20261024.1 +LABEL org.opencontainers.image.title="embeddings-bge-m3" \ + org.opencontainers.image.description="Service d'embeddings bge-m3:567m (1024 dimensions), API OpenAI /v1/embeddings, sur processeur, hors ligne, protégé par un jeton (EMBEDDINGS_JETON). Pour la recherche dans la base de connaissances de LibreDesk." \ + org.opencontainers.image.source="https://exchange.sensima.ch/maxime.pasquier/aimsight-libredesk" \ + org.opencontainers.image.version="0.40.16-567m" COPY --from=source /usr/bin/ollama /usr/bin/ollama COPY --from=source /usr/lib/ollama /usr/lib/ollama # Seulement les modèles : la clé d'identité (id_ed25519) créée par le serveur du pull reste dans l'étape 1 ; # chaque conteneur génère la sienne au premier démarrage. COPY --from=source /root/.ollama/models /root/.ollama/models +COPY --from=portier /usr/bin/caddy /usr/bin/caddy +COPY Caddyfile /etc/caddy/Caddyfile +COPY demarrer.sh /usr/local/bin/demarrer.sh -# Écoute sur toutes les interfaces du conteneur ; c'est le compose qui choisit où le port est publié. +# Ollama n'écoute que dans le conteneur (127.0.0.1:11435) ; seul Caddy (11434) est joignable de l'extérieur, et +# c'est le compose qui choisit où ce port est publié. # KEEP_ALIVE=-1 : le modèle reste chargé, le premier brouillon de la journée ne paie pas le chargement. # NO_CLOUD=1 : aucun appel à ollama.com (recommandations, modèles en ligne) ; tout est local. -ENV OLLAMA_HOST=0.0.0.0:11434 \ +ENV OLLAMA_HOST=127.0.0.1:11435 \ OLLAMA_KEEP_ALIVE=-1 \ OLLAMA_NO_CLOUD=1 EXPOSE 11434 HEALTHCHECK --interval=30s --timeout=10s --start-period=20s --retries=3 CMD ["ollama", "list"] -ENTRYPOINT ["/usr/bin/ollama"] -CMD ["serve"] +ENTRYPOINT ["/bin/bash", "/usr/local/bin/demarrer.sh"] diff --git a/ollama/compose.reseau.yml b/ollama/compose.reseau.yml index 2dc1878..579dbd1 100644 --- a/ollama/compose.reseau.yml +++ b/ollama/compose.reseau.yml @@ -1,5 +1,5 @@ -# Surcharge : rattache Ollama au réseau Docker de LibreDesk, où il est joignable sous le nom « ollama » -# (http://ollama:11434/v1). Localement RESEAU_LIBREDESK=ldtest_libredesk ; sur le serveur, le réseau de LibreDesk. +# Surcharge : rattache embeddings-bge-m3 au réseau Docker de LibreDesk, où il est joignable sous le nom « ollama » +# (http://ollama:11434/v1, avec le jeton comme pour une adresse publiée). Localement RESEAU_LIBREDESK=ldtest_libredesk ; sur le serveur, le réseau de LibreDesk. # RESEAU_LIBREDESK= docker compose -f ollama/compose.yml -f ollama/compose.reseau.yml up -d services: ollama: diff --git a/ollama/compose.yml b/ollama/compose.yml index dd501fe..5a57df2 100644 --- a/ollama/compose.yml +++ b/ollama/compose.yml @@ -1,14 +1,20 @@ -# Ollama + bge-m3, pour LibreDesk. Ollama n'a pas d'authentification : son port n'est publié que sur 127.0.0.1, -# sauf si OLLAMA_BIND donne une autre adresse (l'adresse INTERNE du serveur, jamais une adresse publique). -# OLLAMA_PORT change seulement le port publié (11434 par défaut, celui du serveur) : utile sur un poste où un autre -# Ollama occupe déjà 11434. +# embeddings-bge-m3 (Ollama + bge-m3 derrière Caddy), pour LibreDesk. Chaque requête doit porter +# « Authorization: Bearer » (dans LibreDesk : le champ « API key » des embeddings). +# - ollama/.env (hors de git, jamais lu par Claude) : EMBEDDINGS_JETON (32 caractères au moins, lettres, chiffres, +# « _ » et « - ») ; sans lui, le conteneur refuse de démarrer. Et, s'il le faut, OLLAMA_BIND, OLLAMA_PORT. +# - Le jeton ne dispense pas de garder le port à l'intérieur : il n'est publié que sur 127.0.0.1, sauf si OLLAMA_BIND +# donne une autre adresse (l'adresse INTERNE du serveur, jamais une adresse publique ; HTTP en clair). +# - OLLAMA_PORT change seulement le port publié (11434 par défaut, celui du serveur) : utile sur un poste où un autre +# Ollama occupe déjà 11434. # docker compose -f ollama/compose.yml build # OLLAMA_BIND= docker compose -f ollama/compose.yml up -d services: ollama: build: . - image: exchange.sensima.ch/maxime.pasquier/ollama-bge-m3:0.40.16-567m - container_name: ollama-bge-m3 + image: exchange.sensima.ch/maxime.pasquier/embeddings-bge-m3:0.40.16-567m + container_name: embeddings-bge-m3 restart: unless-stopped + environment: + EMBEDDINGS_JETON: ${EMBEDDINGS_JETON:-} ports: - "${OLLAMA_BIND:-127.0.0.1}:${OLLAMA_PORT:-11434}:11434" diff --git a/ollama/demarrer.sh b/ollama/demarrer.sh new file mode 100644 index 0000000..77fc732 --- /dev/null +++ b/ollama/demarrer.sh @@ -0,0 +1,32 @@ +#!/bin/bash +# Démarrage de l'image embeddings-bge-m3 : Ollama sur 127.0.0.1:11435 (seulement dans le conteneur), et devant lui +# Caddy sur 11434, qui exige le jeton (Caddyfile). Sans jeton valable, rien ne démarre : on ne peut pas lancer le +# service ouvert par oubli. Si l'un des deux s'arrête, le conteneur s'arrête, et Docker le relance (unless-stopped). +set -uo pipefail + +jeton="${EMBEDDINGS_JETON:-}" +if [[ ! "$jeton" =~ ^[A-Za-z0-9_-]{32,}$ ]]; then + echo "EMBEDDINGS_JETON manquant ou invalide : 32 caractères au moins, lettres, chiffres, « _ » et « - » seulement." >&2 + echo "Par exemple : python3 -c 'import secrets; print(secrets.token_urlsafe(32))'" >&2 + exit 1 +fi + +# Ollama n'a pas besoin du jeton : il ne le reçoit pas. +env -u EMBEDDINGS_JETON /usr/bin/ollama serve & +ollama=$! +/usr/bin/caddy run --config /etc/caddy/Caddyfile --adapter caddyfile & +caddy=$! + +arreter() { + kill -TERM "$ollama" "$caddy" 2>/dev/null + wait + exit 0 +} +trap arreter TERM INT + +wait -n +code=$? +echo "Ollama ou Caddy s'est arrêté (code $code) : arrêt du conteneur." >&2 +kill -TERM "$ollama" "$caddy" 2>/dev/null +wait +exit 1 diff --git a/ollama/verifier_ollama.py b/ollama/verifier_ollama.py index 55fb90b..1dc2c07 100644 --- a/ollama/verifier_ollama.py +++ b/ollama/verifier_ollama.py @@ -1,49 +1,88 @@ -"""Vérifie qu'une adresse Ollama (format OpenAI) sert bge-m3:567m en dimension 1024, comme LibreDesk l'attend. +"""Vérifie qu'une adresse embeddings-bge-m3 (format OpenAI) sert bge-m3:567m en dimension 1024, comme LibreDesk +l'attend, avec le jeton, et qu'elle refuse une requête sans jeton. Bibliothèque standard seulement : tourne sur le poste, sur le serveur, ou dans un conteneur python. python3 ollama/verifier_ollama.py http://127.0.0.1:11434/v1 + +Le jeton vient de la variable EMBEDDINGS_JETON, sinon du fichier .env posé à côté de ce script (ollama/.env, ou +~/ollama/.env sur le serveur) : il n'apparaît ni dans la commande ni dans l'historique, et n'est jamais affiché. """ from __future__ import annotations # lisible par le Python du serveur, même ancien (3.8, 3.9) import json +import os import sys import urllib.error import urllib.request +from pathlib import Path MODELE = "bge-m3:567m" DIMENSION = 1024 +VARIABLE = "EMBEDDINGS_JETON" -def _appel(url: str, corps: dict | None = None) -> dict: - r = urllib.request.Request(url, data=json.dumps(corps).encode() if corps is not None else None, - headers={"Content-Type": "application/json", "Authorization": "Bearer ollama"}) +class JetonRefuse(RuntimeError): + pass + + +def lire_jeton(env: dict | None = None, fichier: Path | None = None) -> str | None: + """Le jeton de `env` (os.environ par défaut), sinon celui du .env à côté de ce script ; None s'il n'y en a pas.""" + env = os.environ if env is None else env + fichier = Path(__file__).with_name(".env") if fichier is None else fichier + if env.get(VARIABLE): + return env[VARIABLE] + if not fichier.is_file(): + return None + for ligne in fichier.read_text(encoding="utf-8").splitlines(): + cle, egal, valeur = ligne.strip().partition("=") + if egal and cle.strip() == VARIABLE: + return valeur.strip().strip("'\"") or None + return None + + +def _appel(url: str, jeton: str | None, corps: dict | None = None) -> dict: + entetes = {"Content-Type": "application/json"} + if jeton is not None: + entetes["Authorization"] = f"Bearer {jeton}" + r = urllib.request.Request(url, data=json.dumps(corps).encode() if corps is not None else None, headers=entetes) try: with urllib.request.urlopen(r, timeout=120) as rep: return json.loads(rep.read()) except urllib.error.HTTPError as e: with e: + if e.code == 401: + raise JetonRefuse(f"{url} : 401, jeton refusé") from e raise RuntimeError(f"{url} : {e.code} {e.read().decode(errors='replace')[:200]}") from e except (urllib.error.URLError, TimeoutError) as e: - raise RuntimeError(f"Ollama injoignable à {url} : {getattr(e, 'reason', e)}") from e + raise RuntimeError(f"service d'embeddings injoignable à {url} : {getattr(e, 'reason', e)}") from e -def verifier(base_url: str) -> str: - """Rend « OK bge-m3:567m, 1024 dimensions » ; lève RuntimeError avec ce qui manque.""" +def verifier(base_url: str, jeton: str) -> str: + """Rend « OK bge-m3:567m, 1024 dimensions, jeton exigé » ; lève RuntimeError avec ce qui manque.""" base = base_url.rstrip("/") - modeles = [m.get("id") for m in _appel(f"{base}/models").get("data") or []] + try: + _appel(f"{base}/models", None) + except JetonRefuse: + pass + else: + raise RuntimeError(f"{base} répond sans jeton : la protection n'est pas active (ancienne image, ou Ollama nu ?)") + modeles = [m.get("id") for m in _appel(f"{base}/models", jeton).get("data") or []] if MODELE not in modeles: raise RuntimeError(f"{MODELE} absent de {base}/models (servis : {modeles})") - vecteur = _appel(f"{base}/embeddings", {"model": MODELE, "input": "Quelle est l'autonomie de la batterie ?"} + vecteur = _appel(f"{base}/embeddings", jeton, {"model": MODELE, "input": "Quelle est l'autonomie de la batterie ?"} )["data"][0]["embedding"] if len(vecteur) != DIMENSION: raise RuntimeError(f"vecteur de {len(vecteur)} dimensions, {DIMENSION} attendues") - return f"OK {MODELE}, {DIMENSION} dimensions" + return f"OK {MODELE}, {DIMENSION} dimensions, jeton exigé" if __name__ == "__main__": if len(sys.argv) != 2: sys.exit(__doc__) + jeton = lire_jeton() + if not jeton: + sys.exit(f"ÉCHEC : pas de jeton ({VARIABLE} dans l'environnement ou dans {Path(__file__).with_name('.env')})") try: - print(verifier(sys.argv[1])) + print(verifier(sys.argv[1], jeton)) except RuntimeError as e: sys.exit(f"ÉCHEC : {e}") diff --git a/tests/test_ollama.py b/tests/test_ollama.py index 20b53eb..a906bea 100644 --- a/tests/test_ollama.py +++ b/tests/test_ollama.py @@ -1,8 +1,12 @@ -"""L'image Ollama : le script de vérification (contre un faux serveur) et les garde-fous du lancement (design §2, §5).""" +"""L'image embeddings-bge-m3 : le script de vérification (contre un faux serveur) et les garde-fous du lancement +(design §2, §5) ; le jeton exigé par Caddy devant Ollama.""" import ast import json +import os import socket +import subprocess import sys +import tempfile import threading import unittest from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer @@ -11,34 +15,48 @@ from pathlib import Path OLLAMA = Path(__file__).resolve().parents[1] / "ollama" COMPOSE = OLLAMA / "compose.yml" DOCKERFILE = OLLAMA / "Dockerfile" +CADDYFILE = OLLAMA / "Caddyfile" +DEMARRER = OLLAMA / "demarrer.sh" +IMAGE = "exchange.sensima.ch/maxime.pasquier/embeddings-bge-m3:0.40.16-567m" +JETON = "j" * 40 sys.path.insert(0, str(OLLAMA)) -from verifier_ollama import verifier # noqa: E402 +from verifier_ollama import lire_jeton, verifier # noqa: E402 class FauxOllama: - """Rend `modeles` sur GET /v1/models et un vecteur de `dimension` nombres sur POST /v1/embeddings.""" + """Rend `modeles` sur GET /v1/models et un vecteur de `dimension` nombres sur POST /v1/embeddings. + Avec `jeton`, comme Caddy : 401 si l'en-tête n'est pas « Authorization: Bearer ».""" - def __init__(self, modeles: list[str], dimension: int): + def __init__(self, modeles: list[str], dimension: int, jeton: str | None = JETON): faux = self self.corps_recus: list[dict] = [] class Gestion(BaseHTTPRequestHandler): - def _json(self, data: dict): + def _json(self, data: dict, code: int = 200): texte = json.dumps(data).encode() - self.send_response(200) + self.send_response(code) self.send_header("Content-Type", "application/json") self.send_header("Content-Length", str(len(texte))) self.end_headers() self.wfile.write(texte) + def _autorise(self) -> bool: + if jeton is None or self.headers.get("Authorization") == f"Bearer {jeton}": + return True + self._json({"erreur": "jeton manquant ou invalide"}, 401) + return False + def do_GET(self): - self._json({"object": "list", "data": [{"id": m, "object": "model"} for m in modeles]}) + if self._autorise(): + self._json({"object": "list", "data": [{"id": m, "object": "model"} for m in modeles]}) def do_POST(self): n = int(self.headers.get("Content-Length") or 0) - faux.corps_recus.append(json.loads(self.rfile.read(n))) - self._json({"object": "list", "data": [{"object": "embedding", "index": 0, - "embedding": [0.01] * dimension}]}) + corps = json.loads(self.rfile.read(n)) + if self._autorise(): + faux.corps_recus.append(corps) + self._json({"object": "list", "data": [{"object": "embedding", "index": 0, + "embedding": [0.01] * dimension}]}) def log_message(self, *_): pass @@ -53,32 +71,64 @@ class FauxOllama: class TestVerifier(unittest.TestCase): - def faux(self, modeles: list[str], dimension: int) -> FauxOllama: - f = FauxOllama(modeles, dimension) + def faux(self, modeles: list[str], dimension: int, jeton: str | None = JETON) -> FauxOllama: + f = FauxOllama(modeles, dimension, jeton) self.addCleanup(f.arreter) return f def test_modele_et_dimension_ok(self): f = self.faux(["bge-m3:567m"], 1024) - self.assertIn("1024", verifier(f.url)) + self.assertIn("1024", verifier(f.url, JETON)) self.assertEqual(f.corps_recus[0]["model"], "bge-m3:567m") def test_modele_absent(self): f = self.faux(["nomic-embed-text:latest"], 1024) with self.assertRaisesRegex(RuntimeError, "bge-m3:567m"): - verifier(f.url) + verifier(f.url, JETON) def test_mauvaise_dimension(self): f = self.faux(["bge-m3:567m"], 768) with self.assertRaisesRegex(RuntimeError, "768"): - verifier(f.url) + verifier(f.url, JETON) def test_adresse_injoignable(self): with socket.socket() as s: # un port libre, que personne n'écoute une fois fermé (refus immédiat) s.bind(("127.0.0.1", 0)) port = s.getsockname()[1] with self.assertRaisesRegex(RuntimeError, "injoignable"): - verifier(f"http://127.0.0.1:{port}/v1") + verifier(f"http://127.0.0.1:{port}/v1", JETON) + + def test_mauvais_jeton(self): + f = self.faux(["bge-m3:567m"], 1024) + with self.assertRaisesRegex(RuntimeError, "jeton refusé"): + verifier(f.url, "x" * 40) + self.assertEqual(f.corps_recus, []) + + def test_service_ouvert_sans_jeton_refuse(self): # l'ancienne image, ou un Ollama nu : à ne pas brancher + f = self.faux(["bge-m3:567m"], 1024, jeton=None) + with self.assertRaisesRegex(RuntimeError, "sans jeton"): + verifier(f.url, JETON) + + +class TestLireJeton(unittest.TestCase): + def fichier(self, texte: str) -> Path: + d = tempfile.TemporaryDirectory() + self.addCleanup(d.cleanup) + p = Path(d.name) / ".env" + p.write_text(texte, encoding="utf-8") + return p + + def test_variable_d_environnement_d_abord(self): + p = self.fichier("EMBEDDINGS_JETON=du-fichier\n") + self.assertEqual(lire_jeton({"EMBEDDINGS_JETON": "de-l-env"}, p), "de-l-env") + + def test_sinon_le_env_a_cote_du_script(self): + p = self.fichier("OLLAMA_BIND=10.0.0.1\n# commentaire\nEMBEDDINGS_JETON='abc_DEF-123'\n") + self.assertEqual(lire_jeton({}, p), "abc_DEF-123") + + def test_absent(self): + self.assertIsNone(lire_jeton({}, self.fichier("OLLAMA_BIND=10.0.0.1\n"))) + self.assertIsNone(lire_jeton({}, Path(tempfile.gettempdir()) / "pas-de-fichier-ici" / ".env")) class TestCompatibilite(unittest.TestCase): @@ -94,19 +144,36 @@ class TestCompatibilite(unittest.TestCase): class TestLancement(unittest.TestCase): - def test_port_lie_a_localhost_par_defaut(self): # Ollama n'a pas d'authentification + def test_nom_de_l_image_et_du_conteneur(self): + texte = COMPOSE.read_text() + self.assertIn(f"image: {IMAGE}", texte) + self.assertIn("container_name: embeddings-bge-m3", texte) + self.assertNotIn("ollama-bge-m3", texte) + + def test_port_lie_a_localhost_par_defaut(self): # le jeton ne dispense pas de garder le port à l'intérieur self.assertIn('"${OLLAMA_BIND:-127.0.0.1}:${OLLAMA_PORT:-11434}:11434"', COMPOSE.read_text()) self.assertNotIn("0.0.0.0:11434:", COMPOSE.read_text()) + def test_jeton_passe_au_lancement(self): # jamais dans l'image : le paquet est public + self.assertIn("EMBEDDINGS_JETON: ${EMBEDDINGS_JETON:-}", COMPOSE.read_text()) + self.assertNotIn("EMBEDDINGS_JETON=", DOCKERFILE.read_text()) + def test_redemarrage_automatique(self): self.assertIn("restart: unless-stopped", COMPOSE.read_text()) def test_version_figee(self): texte = DOCKERFILE.read_text() self.assertRegex(texte, r"FROM ollama/ollama:\d+\.\d+\.\d+\s") + self.assertRegex(texte, r"FROM caddy:\d+\.\d+\.\d+-alpine\s") self.assertNotIn("latest", texte) self.assertIn("bge-m3:567m", texte) + def test_description_dans_l_image(self): # Gitea l'affiche sur la page du paquet + texte = DOCKERFILE.read_text() + for label in ("title", "description", "source"): + self.assertIn(f"org.opencontainers.image.{label}=", texte) + self.assertIn('org.opencontainers.image.title="embeddings-bge-m3"', texte) + def test_pas_d_appel_au_nuage(self): # sans ce réglage, Ollama interroge ollama.com au démarrage self.assertIn("OLLAMA_NO_CLOUD=1", DOCKERFILE.read_text()) @@ -122,5 +189,48 @@ class TestLancement(unittest.TestCase): self.assertFalse([c for c in copies if c.rstrip("/") in ("/root", "/root/.ollama")], copies) +class TestPortier(unittest.TestCase): + """Ollama n'écoute que dans le conteneur ; seul Caddy est publié, et il exige le jeton.""" + + def test_ollama_n_ecoute_que_dans_le_conteneur(self): + texte = DOCKERFILE.read_text() + self.assertIn("OLLAMA_HOST=127.0.0.1:11435", texte) + self.assertNotIn("OLLAMA_HOST=0.0.0.0", texte) + + def test_caddy_exige_le_jeton(self): + texte = CADDYFILE.read_text() + self.assertIn('header Authorization "Bearer {$EMBEDDINGS_JETON}"', texte) + self.assertIn("reverse_proxy 127.0.0.1:11435", texte) + self.assertIn("respond", texte) + self.assertIn("401", texte) + + def test_caddy_sans_administration_ni_https_automatique(self): + texte = CADDYFILE.read_text() + self.assertIn("admin off", texte) + self.assertIn("auto_https off", texte) + + def test_hote_reecrit_pour_ollama(self): # Ollama, lié à 127.0.0.1, refuse (403) un Host comme « ollama:11434 » + self.assertIn("header_up Host 127.0.0.1:11435", CADDYFILE.read_text()) + + def lancer(self, jeton: str | None) -> subprocess.CompletedProcess: + env = {k: v for k, v in os.environ.items() if k != "EMBEDDINGS_JETON"} + if jeton is not None: + env["EMBEDDINGS_JETON"] = jeton + # Les jetons refusés arrêtent le script avant tout lancement : rien d'Ollama ni de Caddy n'est appelé ici. + return subprocess.run(["bash", str(DEMARRER)], env=env, capture_output=True, text=True, timeout=10) + + def test_refuse_de_demarrer_sans_jeton(self): + r = self.lancer(None) + self.assertNotEqual(r.returncode, 0) + self.assertIn("EMBEDDINGS_JETON", r.stderr) + + def test_refuse_un_jeton_court(self): + self.assertNotEqual(self.lancer("a" * 31).returncode, 0) + + def test_refuse_les_caracteres_speciaux(self): # « * » serait un joker pour Caddy, « } » casserait le Caddyfile + for jeton in ("a" * 32 + "*", "a" * 32 + "}", "a" * 32 + " b", "a" * 32 + '"'): + self.assertNotEqual(self.lancer(jeton).returncode, 0, jeton) + + if __name__ == "__main__": unittest.main()