Fusion de embeddings-token dans main (le jeton devant Ollama, avec le pompage des conversations)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
maximeandClaude Opus 5.5 committed 2026-11-18 15:31:12 +01:00
commit e3c4a29e90
13 files changed
+315 -57

No files matched your search

+127 -17
View File
@@ -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 <jeton> »."""
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()