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>
237 lines
10 KiB
Python
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()
|