diff --git a/ollama/Dockerfile b/ollama/Dockerfile new file mode 100644 index 0000000..a797ebd --- /dev/null +++ b/ollama/Dockerfile @@ -0,0 +1,29 @@ +# 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.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. +FROM ollama/ollama:0.40.16 AS source +RUN ollama serve >/tmp/serve.log 2>&1 & \ + for i in $(seq 30); do ollama list >/dev/null 2>&1 && break; sleep 1; done && \ + ollama pull bge-m3:567m && \ + ollama list | grep -q 'bge-m3:567m' && \ + 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. +FROM ubuntu:noble-20261024.1 +COPY --from=source /usr/bin/ollama /usr/bin/ollama +COPY --from=source /usr/lib/ollama /usr/lib/ollama +COPY --from=source /root/.ollama /root/.ollama + +# Écoute sur toutes les interfaces du conteneur ; c'est le compose qui choisit où le 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 \ + 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"] diff --git a/ollama/compose.reseau.yml b/ollama/compose.reseau.yml new file mode 100644 index 0000000..2dc1878 --- /dev/null +++ b/ollama/compose.reseau.yml @@ -0,0 +1,13 @@ +# 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. +# RESEAU_LIBREDESK= docker compose -f ollama/compose.yml -f ollama/compose.reseau.yml up -d +services: + ollama: + networks: + libredesk: + aliases: [ollama] + +networks: + libredesk: + name: ${RESEAU_LIBREDESK:?donner le réseau Docker de LibreDesk dans RESEAU_LIBREDESK} + external: true diff --git a/ollama/compose.yml b/ollama/compose.yml new file mode 100644 index 0000000..dd501fe --- /dev/null +++ b/ollama/compose.yml @@ -0,0 +1,14 @@ +# 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. +# 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 + restart: unless-stopped + ports: + - "${OLLAMA_BIND:-127.0.0.1}:${OLLAMA_PORT:-11434}:11434" diff --git a/ollama/verifier.py b/ollama/verifier.py new file mode 100644 index 0000000..c23bf13 --- /dev/null +++ b/ollama/verifier.py @@ -0,0 +1,47 @@ +"""Vérifie qu'une adresse Ollama (format OpenAI) sert bge-m3:567m en dimension 1024, comme LibreDesk l'attend. +Bibliothèque standard seulement : tourne sur le poste, sur le serveur, ou dans un conteneur python. + +python3 ollama/verifier.py http://127.0.0.1:11434/v1 +""" +import json +import sys +import urllib.error +import urllib.request + +MODELE = "bge-m3:567m" +DIMENSION = 1024 + + +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"}) + try: + with urllib.request.urlopen(r, timeout=120) as rep: + return json.loads(rep.read()) + except urllib.error.HTTPError as e: + with 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 + + +def verifier(base_url: str) -> str: + """Rend « OK bge-m3:567m, 1024 dimensions » ; 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 []] + 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 ?"} + )["data"][0]["embedding"] + if len(vecteur) != DIMENSION: + raise RuntimeError(f"vecteur de {len(vecteur)} dimensions, {DIMENSION} attendues") + return f"OK {MODELE}, {DIMENSION} dimensions" + + +if __name__ == "__main__": + if len(sys.argv) != 2: + sys.exit(__doc__) + try: + print(verifier(sys.argv[1])) + except RuntimeError as e: + sys.exit(f"ÉCHEC : {e}") diff --git a/tests/test_ollama.py b/tests/test_ollama.py new file mode 100644 index 0000000..5d76c86 --- /dev/null +++ b/tests/test_ollama.py @@ -0,0 +1,108 @@ +"""L'image Ollama : le script de vérification (contre un faux serveur) et les garde-fous du lancement (design §2, §5).""" +import json +import socket +import sys +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" +sys.path.insert(0, str(OLLAMA)) +from verifier import verifier # noqa: E402 + + +class FauxOllama: + """Rend `modeles` sur GET /v1/models et un vecteur de `dimension` nombres sur POST /v1/embeddings.""" + + def __init__(self, modeles: list[str], dimension: int): + faux = self + self.corps_recus: list[dict] = [] + + class Gestion(BaseHTTPRequestHandler): + def _json(self, data: dict): + texte = json.dumps(data).encode() + self.send_response(200) + self.send_header("Content-Type", "application/json") + self.send_header("Content-Length", str(len(texte))) + self.end_headers() + self.wfile.write(texte) + + def do_GET(self): + 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}]}) + + 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) -> FauxOllama: + f = FauxOllama(modeles, dimension) + 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.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) + + def test_mauvaise_dimension(self): + f = self.faux(["bge-m3:567m"], 768) + with self.assertRaisesRegex(RuntimeError, "768"): + verifier(f.url) + + 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") + + +class TestLancement(unittest.TestCase): + def test_port_lie_a_localhost_par_defaut(self): # Ollama n'a pas d'authentification + 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_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.assertNotIn("latest", texte) + self.assertIn("bge-m3:567m", 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) + + +if __name__ == "__main__": + unittest.main()