"""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 ».""" 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()