Files
aimsight-libredesk/tests/test_ollama.py
T
maximeandClaude Opus 5.5 0fa7c4936b Image embeddings-bge-m3 : jeton exigé devant Ollama
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 <EMBEDDINGS_JETON> » (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 <noreply@anthropic.com>
2026-11-18 15:28:41 +01:00

237 lines
10 KiB
Python

"""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
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 lire_jeton, verifier # noqa: E402
class FauxOllama:
"""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 <jeton> »."""
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, code: int = 200):
texte = json.dumps(data).encode()
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):
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)
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
self._serveur = ThreadingHTTPServer(("127.0.0.1", 0), Gestion)
self.url = f"http://127.0.0.1:{self._serveur.server_address[1]}/v1"
threading.Thread(target=self._serveur.serve_forever, daemon=True).start()
def arreter(self):
self._serveur.shutdown()
self._serveur.server_close()
class TestVerifier(unittest.TestCase):
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, 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, JETON)
def test_mauvaise_dimension(self):
f = self.faux(["bge-m3:567m"], 768)
with self.assertRaisesRegex(RuntimeError, "768"):
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", 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):
def test_verifier_lisible_par_un_vieux_python(self): # le Python du serveur est inconnu (3.8, 3.9…)
texte = (OLLAMA / "verifier_ollama.py").read_text()
arbre = ast.parse(texte)
futur = any(isinstance(n, ast.ImportFrom) and n.module == "__future__"
and any(a.name == "annotations" for a in n.names) for n in arbre.body)
unions = [n for n in ast.walk(arbre) if isinstance(n, (ast.FunctionDef, ast.arg))
for a in [n.returns if isinstance(n, ast.FunctionDef) else n.annotation]
if a is not None and any(isinstance(b, ast.BinOp) for b in ast.walk(a))]
self.assertTrue(futur or not unions, "annotations « X | None » évaluées à la définition : Python ≥ 3.10")
class TestLancement(unittest.TestCase):
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())
def test_bibliotheques_gpu_non_livrees(self): # 4,4 Go de CUDA inutiles : bge-m3 tourne sur processeur
texte = DOCKERFILE.read_text()
self.assertIn("COPY --from=", texte)
for d in ("cuda_v12", "cuda_v13", "mlx_cuda_v13"):
self.assertIn(f"/usr/lib/ollama/{d}", texte)
def test_pas_de_cle_privee_livree(self): # id_ed25519, créée au pull, serait la même dans toutes les copies
copies = [l.split()[2] for l in DOCKERFILE.read_text().splitlines() if l.startswith("COPY --from=")]
self.assertIn("/root/.ollama/models", copies)
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()