ietm64/LoreMind
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Mise à jour de la conf pour être sur que le cache angular est bien refresh
Some checks failed
E2E Tests / e2e (push) Failing after 20s
Details

Browse Source 
Mise à jour des installeurs
Mise en place de secure-host pour ne pas exposer Ollama à l'exterieur
This commit is contained in:
IETM_FIXE\ietm6
2026-04-26 00:18:49 +02:00
parent 8d5c2e2b7f
commit 5e04e84ee4
7 changed files with 557 additions and 78 deletions
Download Patch File Download Diff File Expand all files Collapse all files

112
installers/README.md
View File

@@ -5,18 +5,26 @@ et lancent la stack. Aucune configuration manuelle requise.
## Windows 10 / 11
Ouvrir **PowerShell** (clic droit → *Exécuter en tant qu'administrateur*) :
**Procédure recommandée :**
```powershell
iwr https://git.igmlcreation.fr/ietm64/loremind/raw/branch/main/installers/install.ps1 -OutFile $env:TEMP\loremind-install.ps1
powershell -ExecutionPolicy Bypass -File $env:TEMP\loremind-install.ps1
```
1. Téléchargez les trois fichiers suivants dans un même dossier
(par ex. `Téléchargements\LoreMind\`) :
- [`install.bat`](install.bat) — lanceur
- [`install.ps1`](install.ps1) — script principal
- [`secure-host-ollama.ps1`](secure-host-ollama.ps1) — *uniquement si vous avez déjà Ollama sur votre PC*
2. **Clic-droit** sur `install.bat` → **Exécuter en tant qu'administrateur**.
3. Acceptez le prompt UAC.
Le script :
1. Vérifie / installe **WSL2** (un reboot peut être nécessaire — relancer le script après).
2. Vérifie / installe **Docker Desktop** via `winget`.
3. Génère `%LOCALAPPDATA%\LoreMind\.env` avec mots de passe aléatoires.
4. Lance la stack et ouvre `http://localhost:8081`.
3. Vous demande quelques choix (admin, fournisseur LLM, mode Ollama, mises à jour auto).
4. Génère `%LOCALAPPDATA%\LoreMind\.env` avec mots de passe aléatoires.
5. Lance la stack et ouvre `http://localhost:8081`.
Le `install.bat` sert juste à lancer `install.ps1` proprement (avec UAC + ExecutionPolicy
adaptée à la session, sans modifier les paramètres système). Il est purement
déclaratif et auditable en quelques lignes.
## Linux (Debian / Ubuntu / Fedora / Arch)
@@ -30,6 +38,96 @@ Le script :
3. Installe dans `~/.local/share/loremind`.
4. Lance la stack et ouvre `http://localhost:8081`.
## Mode Ollama (moteur LLM local)
Pendant l'installation, l'installeur pose deux questions successives pour
déterminer comment LoreMind utilisera Ollama :
### 1. *« Avez-vous déjà Ollama installé sur cette machine ? »*
#### Réponse : **Oui** → mode **hôte sécurisé**
L'installeur appelle automatiquement le helper `secure-host-ollama.{sh,ps1}`
qui configure votre Ollama existant pour qu'il soit joignable par le conteneur
Docker LoreMind **sans être exposé sur le réseau local ni Internet**.
- **Linux** : Ollama écoute sur l'IP de la passerelle Docker (`172.17.0.1`
par défaut). Cette IP n'est jamais routée hors de la machine. Override
systemd écrit dans `/etc/systemd/system/ollama.service.d/loremind-host.conf`.
- **Windows** : Ollama écoute sur `0.0.0.0` (techniquement nécessaire avec
Docker Desktop) mais le pare-feu Windows est configuré pour ne **laisser
passer que** le loopback et les sous-réseaux Docker Desktop. Règles
ajoutées préfixées `LoreMind-Ollama-*`.
L'URL configurée dans `.env` est `OLLAMA_BASE_URL=http://host.docker.internal:11434`.
#### Réponse : **Non** → l'installeur pose la question 2.
### 2. *« Voulez-vous installer Ollama via Docker maintenant ? »*
#### Réponse : **Oui (défaut)** → mode **embarqué**
Un service `ollama` est ajouté à la stack via le profile Docker `local-ollama`.
Ollama tourne dans un conteneur dédié, sur le réseau interne Docker, **jamais
exposé au LAN ni à Internet**. Les modèles sont stockés dans le volume
Docker `ollama-data` (persistants entre redémarrages et mises à jour).
- URL : `OLLAMA_BASE_URL=http://ollama:11434` (DNS interne Docker).
- Aucune configuration réseau ou pare-feu requise.
- Support GPU NVIDIA automatique si disponible.
Pour télécharger un modèle :
```bash
docker exec -it loremind-ollama ollama pull gemma3:27b
docker exec -it loremind-ollama ollama list
```
#### Réponse : **Non** → mode **différé**
Aucune configuration Ollama n'est appliquée. L'installeur termine sans
Ollama. Vous configurez Ollama plus tard via la page **Paramètres** de LoreMind
en y indiquant l'URL de votre serveur Ollama.
### Lancer le helper de sécurisation manuellement
Si vous avez choisi le mode différé puis installé Ollama plus tard sur votre
poste, ou si vous voulez basculer du mode embarqué vers le mode hôte :
**Linux :**
```bash
bash secure-host-ollama.sh
# Puis dans .env du dossier d'installation :
# OLLAMA_BASE_URL=http://host.docker.internal:11434
# Et : docker compose up -d
```
**Windows (PowerShell admin) :**
```powershell
.\secure-host-ollama.ps1
# Puis editez .env (dans %LOCALAPPDATA%\LoreMind\) :
# OLLAMA_BASE_URL=http://host.docker.internal:11434
# Et : docker compose up -d
```
Les helpers sont **réexécutables sans risque** : ils suppriment leurs
anciennes règles avant de les recréer. Utile par exemple si vous avez
réinitialisé Docker Desktop et que les sous-réseaux ont changé.
### Annuler la configuration de sécurisation
**Linux :**
```bash
sudo rm /etc/systemd/system/ollama.service.d/loremind-host.conf
sudo systemctl daemon-reload && sudo systemctl restart ollama
```
**Windows (PowerShell admin) :**
```powershell
Get-NetFirewallRule -DisplayName "LoreMind-Ollama-*" | Remove-NetFirewallRule
[Environment]::SetEnvironmentVariable("OLLAMA_HOST", $null, "User")
```
## Variables disponibles
| Variable | Défaut | Effet |

97
installers/install.ps1
View File

@@ -213,37 +213,60 @@ if ($llmProvider -eq 'onemin' -and -not $NonInteractive) {
$onemKey = Read-Host " Cle API 1min.ai"
}
# --- Mode Ollama : embarque (defaut) vs hote -------------------------------
# Embarque : service 'ollama' du compose (profile local-ollama). Zero config reseau.
# Hote : Ollama deja installe sur la machine. Necessite OLLAMA_HOST=0.0.0.0
# pour que Docker Desktop puisse l'atteindre via host.docker.internal.
$useEmbeddedOllama = $true
# --- Mode Ollama : 3 options possibles -------------------------------------
# 1. Hote : Ollama est deja installe sur cette machine -> on configure le
# pare-feu pour que Docker puisse l'atteindre sans exposer le port.
# 2. Embarque : Ollama tourne dans un conteneur Docker dedie (profile local-ollama).
# 3. Aucun : on n'installe rien tout de suite. L'utilisateur configurera
# Ollama plus tard via la page Parametres de LoreMind.
$ollamaMode = 'embedded' # valeurs : 'host' | 'embedded' | 'none'
$ollamaBaseUrl = 'http://ollama:11434'
if ($llmProvider -eq 'ollama') {
$useEmbeddedOllama = if ($NonInteractive) { $true } else {
$hasHostOllama = if ($NonInteractive) { $false } else {
$r = Read-Host " Avez-vous deja Ollama installe sur cette machine ? [o/N]"
-not ($r -match '^(o|O|y|Y|oui|yes)$')
($r -match '^(o|O|y|Y|oui|yes)$')
}
if (-not $useEmbeddedOllama) {
$ollamaBaseUrl = 'http://host.docker.internal:11434'
Write-Step "Configuration d'Ollama hote..."
# Pour que le conteneur Docker puisse atteindre Ollama via host.docker.internal,
# Ollama doit ecouter sur 0.0.0.0 (et non 127.0.0.1 par defaut). On positionne
# la variable d'environnement utilisateur OLLAMA_HOST en consequence.
try {
[Environment]::SetEnvironmentVariable('OLLAMA_HOST','0.0.0.0:11434','User')
Write-Ok "Variable d'environnement utilisateur OLLAMA_HOST=0.0.0.0:11434 definie"
Write-Host ""
Write-Host " Pour que ce changement prenne effet, vous devez :" -ForegroundColor Yellow
Write-Host " 1. Quitter completement Ollama (icone systray > Quit Ollama)"
Write-Host " 2. Relancer Ollama"
Write-Host ""
Read-Host " Appuyez sur Entree une fois Ollama redemarre"
} catch {
Write-Warn2 "Impossible de definir OLLAMA_HOST automatiquement. Definissez-la manuellement (Parametres systeme > Variables d'environnement) puis redemarrez Ollama."
}
if ($hasHostOllama) {
$ollamaMode = 'host'
} else {
# Pas d'Ollama present : proposer l'installation Docker, sinon laisser
# l'utilisateur le configurer plus tard via la page Parametres.
$installViaDocker = if ($NonInteractive) { $true } else {
$r = Read-Host " Voulez-vous installer Ollama via Docker maintenant ? [O/n]"
-not ($r -match '^(n|N|no|non)$')
}
$ollamaMode = if ($installViaDocker) { 'embedded' } else { 'none' }
}
if ($ollamaMode -eq 'host') {
$ollamaBaseUrl = 'http://host.docker.internal:11434'
# Delegue au helper dedie : configure OLLAMA_HOST=0.0.0.0 ET ajoute des
# regles Windows Firewall qui n'autorisent l'acces qu'aux conteneurs
# Docker (loopback + sous-reseaux Docker Desktop). Resultat : Ollama
# n'est pas expose au LAN ni a Internet.
$secureHelper = Join-Path $PSScriptRoot 'secure-host-ollama.ps1'
if (Test-Path $secureHelper) {
Write-Step "Configuration securisee d'Ollama hote (helper dedie)..."
try {
& $secureHelper
} catch {
Write-Warn2 "Le helper secure-host-ollama.ps1 a echoue : $($_.Exception.Message)"
Write-Warn2 "Configurez Ollama manuellement avant de continuer."
}
Write-Host ""
Read-Host "Appuyez sur Entree une fois Ollama redemarre pour continuer l'installation"
} else {
Write-Warn2 "secure-host-ollama.ps1 introuvable a cote de install.ps1."
Write-Warn2 "Telechargez-le depuis le depot et relancez-le manuellement."
}
} elseif ($ollamaMode -eq 'embedded') {
Write-Ok "Ollama sera lance dans Docker (modeles dans un volume Docker dedie)"
} else {
# Mode 'none' : on cible host.docker.internal en supposant qu'Ollama
# sera installe plus tard sur l'hote. L'utilisateur peut aussi changer
# l'URL via la page Parametres pour pointer vers un Ollama distant.
$ollamaBaseUrl = 'http://host.docker.internal:11434'
Write-Warn2 "Aucun Ollama ne sera installe pour le moment. Configurez-le plus tard via la page Parametres de LoreMind."
}
}
@@ -255,8 +278,8 @@ $autoUpdate = if ($NonInteractive) { $true } else {
}
# Combinaison de profiles : autoupdate et/ou local-ollama (separes par virgule).
$profilesList = @()
if ($autoUpdate) { $profilesList += 'autoupdate' }
if ($useEmbeddedOllama -and $llmProvider -eq 'ollama') { $profilesList += 'local-ollama' }
if ($autoUpdate) { $profilesList += 'autoupdate' }
if ($ollamaMode -eq 'embedded' -and $llmProvider -eq 'ollama'){ $profilesList += 'local-ollama' }
$composeProfiles = $profilesList -join ','
$envContent = @"
@@ -323,13 +346,19 @@ if ($autoUpdate) {
Write-Host " Auto-update : desactive (mise a jour manuelle uniquement)"
}
if ($llmProvider -eq 'ollama') {
if ($useEmbeddedOllama) {
Write-Host " Ollama : embarque (service Docker 'ollama')" -ForegroundColor Green
Write-Host ""
Write-Host " IMPORTANT : telechargez un modele avant utilisation :"
Write-Host " docker exec -it loremind-ollama ollama pull $llmModel"
} else {
Write-Host " Ollama : hote (http://host.docker.internal:11434)"
switch ($ollamaMode) {
'embedded' {
Write-Host " Ollama : embarque (service Docker 'ollama')" -ForegroundColor Green
Write-Host ""
Write-Host " IMPORTANT : telechargez un modele avant utilisation :"
Write-Host " docker exec -it loremind-ollama ollama pull $llmModel"
}
'host' {
Write-Host " Ollama : hote (configure via secure-host-ollama.ps1)"
}
'none' {
Write-Host " Ollama : non configure - a faire via Parametres dans l'app" -ForegroundColor Yellow
}
}
}
Write-Host ""

83
installers/install.sh
View File

@@ -123,37 +123,54 @@ if [ "$LLM_PROVIDER" = "onemin" ] && [ "$NON_INTERACTIVE" != "1" ]; then
ONEMIN_API_KEY="$(ask "Cle API 1min.ai" "")"
fi
# --- Mode Ollama : embarque (defaut) vs hote -------------------------------
# Embarque : service 'ollama' du compose (profile local-ollama). Zero config reseau.
# Hote : Ollama deja installe sur la machine. Necessite OLLAMA_HOST=0.0.0.0
# via override systemd pour que le conteneur Brain l'atteigne.
USE_EMBEDDED_OLLAMA=1
# --- Mode Ollama : 3 options possibles -------------------------------------
# 1. host : Ollama deja installe sur la machine -> helper de securisation
# 2. embedded : service 'ollama' du compose (profile local-ollama)
# 3. none : aucune installation, configuration ulterieure via l'app
OLLAMA_MODE="embedded"
OLLAMA_BASE_URL_VAL="http://ollama:11434"
LLM_MODEL_VAL="gemma4:26b"
if [ "$LLM_PROVIDER" = "ollama" ]; then
HOST_OLLAMA_REPLY="$(ask "Avez-vous deja Ollama installe sur cette machine ? [o/N]" "N")"
case "$HOST_OLLAMA_REPLY" in
o|O|y|Y|oui|yes|Oui|Yes)
USE_EMBEDDED_OLLAMA=0
OLLAMA_BASE_URL_VAL="http://host.docker.internal:11434"
step "Configuration d'Ollama hote (OLLAMA_HOST=0.0.0.0:11434)..."
if systemctl list-unit-files 2>/dev/null | grep -q '^ollama\.service'; then
sudo mkdir -p /etc/systemd/system/ollama.service.d
sudo tee /etc/systemd/system/ollama.service.d/loremind-host.conf >/dev/null <<EOF
[Service]
Environment="OLLAMA_HOST=0.0.0.0:11434"
EOF
sudo systemctl daemon-reload
sudo systemctl restart ollama
ok "Service systemd ollama redemarre avec OLLAMA_HOST=0.0.0.0:11434"
else
warn "Service systemd 'ollama' introuvable. Definissez OLLAMA_HOST=0.0.0.0:11434 manuellement avant de relancer Ollama."
fi
OLLAMA_MODE="host"
;;
*)
USE_EMBEDDED_OLLAMA=1
# Pas d'Ollama present : proposer l'installation Docker.
INSTALL_DOCKER_REPLY="$(ask "Voulez-vous installer Ollama via Docker maintenant ? [O/n]" "O")"
case "$INSTALL_DOCKER_REPLY" in
n|N|no|non|No|Non) OLLAMA_MODE="none" ;;
*) OLLAMA_MODE="embedded" ;;
esac
;;
esac
case "$OLLAMA_MODE" in
host)
OLLAMA_BASE_URL_VAL="http://host.docker.internal:11434"
# Delegue la configuration securisee au helper dedie : il fait
# ecouter Ollama uniquement sur l'IP du bridge Docker (jamais
# exposee au LAN ni a Internet) plutot que sur 0.0.0.0.
SECURE_HELPER="$(dirname -- "$0")/secure-host-ollama.sh"
if [ -f "$SECURE_HELPER" ]; then
step "Configuration securisee d'Ollama hote..."
bash "$SECURE_HELPER" || warn "Le helper secure-host-ollama.sh a echoue. Configurez Ollama manuellement."
else
warn "secure-host-ollama.sh introuvable a cote de install.sh."
warn "Telechargez-le depuis le depot et relancez : bash secure-host-ollama.sh"
fi
;;
embedded)
ok "Ollama sera lance dans Docker (modeles dans un volume Docker)"
;;
none)
# On cible host.docker.internal par defaut en supposant qu'Ollama
# sera installe plus tard sur l'hote. L'utilisateur peut aussi
# changer l'URL via la page Parametres pour un Ollama distant.
OLLAMA_BASE_URL_VAL="http://host.docker.internal:11434"
warn "Aucun Ollama ne sera installe pour le moment. Configurez-le plus tard via la page Parametres de LoreMind."
;;
esac
fi
@@ -166,7 +183,7 @@ esac
# Combinaison de profiles : autoupdate et/ou local-ollama (separes par virgule).
PROFILES_ARR=()
[ "$AUTO_UPDATE" = "1" ] && PROFILES_ARR+=("autoupdate")
if [ "$LLM_PROVIDER" = "ollama" ] && [ "$USE_EMBEDDED_OLLAMA" = "1" ]; then
if [ "$LLM_PROVIDER" = "ollama" ] && [ "$OLLAMA_MODE" = "embedded" ]; then
PROFILES_ARR+=("local-ollama")
fi
COMPOSE_PROFILES="$(IFS=,; echo "${PROFILES_ARR[*]}")"
@@ -227,14 +244,20 @@ else
echo " Auto-update : desactive (mise a jour manuelle uniquement)"
fi
if [ "$LLM_PROVIDER" = "ollama" ]; then
if [ "$USE_EMBEDDED_OLLAMA" = "1" ]; then
echo -e " Ollama : ${c_green}embarque${c_off} (service Docker 'ollama')"
echo
echo " IMPORTANT : telechargez un modele avant utilisation :"
echo " docker exec -it loremind-ollama ollama pull ${LLM_MODEL_VAL}"
else
echo " Ollama : hote (http://host.docker.internal:11434)"
fi
case "$OLLAMA_MODE" in
embedded)
echo -e " Ollama : ${c_green}embarque${c_off} (service Docker 'ollama')"
echo
echo " IMPORTANT : telechargez un modele avant utilisation :"
echo " docker exec -it loremind-ollama ollama pull ${LLM_MODEL_VAL}"
;;
host)
echo " Ollama : hote (configure via secure-host-ollama.sh)"
;;
none)
echo -e " Ollama : ${c_yellow}non configure${c_off} - a faire via Parametres dans l'app"
;;
esac
fi
echo
echo " Commandes utiles (depuis $INSTALL_DIR) :"

183
installers/secure-host-ollama.ps1 Normal file
View File

@@ -0,0 +1,183 @@
#Requires -Version 5.1
<#
.SYNOPSIS
Configuration securisee d'Ollama hote pour LoreMindMJ (Windows).
.DESCRIPTION
But : permettre au conteneur Docker LoreMind d'atteindre l'Ollama installe
sur l'hote, SANS exposer Ollama sur le LAN ni Internet.
Strategie (specifique a Docker Desktop / WSL2 sur Windows) :
1. Ollama doit ecouter sur 0.0.0.0 (techniquement necessaire car Docker
Desktop sur Windows utilise un reseau Hyper-V / WSL2 separe).
2. On compense en ajoutant des regles Windows Firewall qui :
- BLOQUENT le port 11434 entrant par defaut sur tout profil
- AUTORISENT 11434 uniquement depuis les sous-reseaux Docker Desktop
(detectes dynamiquement) et depuis le loopback.
Resultat : Ollama est joignable par les conteneurs Docker mais
inaccessible depuis le reseau local ou Internet.
.NOTES
Ce script doit etre execute en tant qu'administrateur.
Les regles ajoutees sont prefixees par "LoreMind-Ollama-" pour
faciliter leur identification et suppression ulterieure.
.LINK
https://git.igmlcreation.fr/ietm64/loremind
#>
[CmdletBinding()]
param()
$ErrorActionPreference = 'Stop'
function Write-Step($msg) { Write-Host "==> $msg" -ForegroundColor Cyan }
function Write-Ok($msg) { Write-Host " OK $msg" -ForegroundColor Green }
function Write-Warn2($msg) { Write-Host " !! $msg" -ForegroundColor Yellow }
function Write-Err($msg) { Write-Host " XX $msg" -ForegroundColor Red }
# --- 1. Verification admin -------------------------------------------------
$current = [Security.Principal.WindowsIdentity]::GetCurrent()
$isAdmin = ([Security.Principal.WindowsPrincipal]$current).IsInRole(
[Security.Principal.WindowsBuiltInRole]::Administrator)
if (-not $isAdmin) {
Write-Err "Ce script doit etre execute en tant qu'administrateur."
Write-Host ""
Write-Host "Procedure : clic-droit sur PowerShell > 'Executer en tant qu'administrateur',"
Write-Host "puis relancez ce script."
Read-Host "Appuyez sur Entree pour quitter"
exit 1
}
# --- 2. Detection des sous-reseaux Docker Desktop --------------------------
Write-Step "Detection des sous-reseaux utilises par Docker Desktop..."
$dockerSubnets = @()
# Methode 1 : interroger Docker pour les bridges actifs.
try {
$networks = docker network ls --filter driver=bridge --format "{{.Name}}" 2>$null
foreach ($net in $networks) {
if ([string]::IsNullOrWhiteSpace($net)) { continue }
$subnet = docker network inspect $net -f "{{range .IPAM.Config}}{{.Subnet}}{{end}}" 2>$null
if (-not [string]::IsNullOrWhiteSpace($subnet)) {
$dockerSubnets += $subnet.Trim()
}
}
} catch {
Write-Warn2 "Impossible d'interroger Docker pour les sous-reseaux. Utilisation des plages par defaut."
}
# Methode 2 : interfaces vEthernet (WSL/DockerNAT) detectees par Windows.
try {
$wslInterfaces = Get-NetIPConfiguration -ErrorAction SilentlyContinue |
Where-Object { $_.InterfaceAlias -match 'vEthernet \(WSL|vEthernet \(Default Switch|vEthernet \(Docker' }
foreach ($iface in $wslInterfaces) {
$ipv4 = $iface.IPv4Address
if ($ipv4 -and $ipv4.IPAddress) {
# On deduit un /24 a partir de l'adresse de l'interface (approximation safe).
$octets = $ipv4.IPAddress.Split('.')
$subnet = "{0}.{1}.{2}.0/24" -f $octets[0], $octets[1], $octets[2]
$dockerSubnets += $subnet
}
}
} catch { }
# Methode 3 : fallback sur les plages connues de Docker Desktop si rien detecte.
if ($dockerSubnets.Count -eq 0) {
Write-Warn2 "Aucun sous-reseau Docker detecte. Utilisation des plages par defaut Docker Desktop."
$dockerSubnets = @(
"172.16.0.0/12", # Plage standard des reseaux bridge Docker
"192.168.65.0/24" # Plage WSL2 / Docker Desktop frequente
)
}
# Deduplication et nettoyage.
$dockerSubnets = $dockerSubnets | Where-Object { $_ -match '^\d+\.\d+\.\d+\.\d+/\d+$' } | Select-Object -Unique
Write-Ok "Sous-reseaux autorises : $($dockerSubnets -join ', ')"
# --- 3. Variable d'environnement OLLAMA_HOST -------------------------------
Write-Step "Configuration de la variable OLLAMA_HOST..."
[Environment]::SetEnvironmentVariable('OLLAMA_HOST','0.0.0.0:11434','User')
Write-Ok "OLLAMA_HOST=0.0.0.0:11434 definie au niveau utilisateur"
# --- 4. Suppression des anciennes regles LoreMind --------------------------
Write-Step "Nettoyage des anciennes regles Windows Firewall LoreMind..."
$oldRules = Get-NetFirewallRule -DisplayName "LoreMind-Ollama-*" -ErrorAction SilentlyContinue
if ($oldRules) {
$oldRules | Remove-NetFirewallRule
Write-Ok "$($oldRules.Count) ancienne(s) regle(s) supprimee(s)"
} else {
Write-Ok "Aucune ancienne regle a supprimer"
}
# --- 5. Creation des regles --------------------------------------------------
Write-Step "Creation des regles Windows Firewall..."
# 5a. Regle de blocage par defaut (priorite la plus basse en cas de conflit :
# les regles Allow ont priorite sur les Block dans Windows Firewall, donc
# ce Block sert de filet final pour tout ce qui n'est pas explicitement
# autorise par les regles ci-dessous).
New-NetFirewallRule `
-DisplayName "LoreMind-Ollama-Block-All" `
-Description "LoreMind: bloque toute connexion entrante Ollama par defaut" `
-Direction Inbound `
-Action Block `
-Protocol TCP `
-LocalPort 11434 `
-Profile Any `
-RemoteAddress Any | Out-Null
Write-Ok "Regle Block-All (port 11434) creee"
# 5b. Regle d'autorisation : loopback uniquement.
New-NetFirewallRule `
-DisplayName "LoreMind-Ollama-Allow-Loopback" `
-Description "LoreMind: autorise Ollama depuis 127.0.0.1" `
-Direction Inbound `
-Action Allow `
-Protocol TCP `
-LocalPort 11434 `
-Profile Any `
-RemoteAddress "127.0.0.1" | Out-Null
Write-Ok "Regle Allow-Loopback creee"
# 5c. Regles d'autorisation : sous-reseaux Docker Desktop.
foreach ($subnet in $dockerSubnets) {
$safeName = "LoreMind-Ollama-Allow-Docker-$($subnet -replace '[\./]','_')"
New-NetFirewallRule `
-DisplayName $safeName `
-Description "LoreMind: autorise Ollama depuis le sous-reseau Docker $subnet" `
-Direction Inbound `
-Action Allow `
-Protocol TCP `
-LocalPort 11434 `
-Profile Any `
-RemoteAddress $subnet | Out-Null
Write-Ok "Regle Allow-Docker creee pour $subnet"
}
# --- 6. Redemarrage Ollama -------------------------------------------------
Write-Step "Redemarrage d'Ollama pour appliquer OLLAMA_HOST..."
Write-Host ""
Write-Host " Pour que la variable d'environnement prenne effet, vous devez :" -ForegroundColor Yellow
Write-Host " 1. Quitter completement Ollama (icone systray > Quit Ollama)"
Write-Host " 2. Le relancer depuis le menu Demarrer"
Write-Host ""
# --- 7. Recap --------------------------------------------------------------
Write-Host ""
Write-Host "============================================================" -ForegroundColor Green
Write-Host " Ollama hote configure de maniere securisee" -ForegroundColor Green
Write-Host "============================================================" -ForegroundColor Green
Write-Host " Adresse d'ecoute : 0.0.0.0:11434 (toutes interfaces)"
Write-Host " Pare-feu Windows : bloque par defaut, autorise loopback + Docker"
Write-Host " Inaccessible depuis : LAN, WiFi public, Internet"
Write-Host ""
Write-Host " Pour LoreMind, definissez dans le fichier .env :"
Write-Host " OLLAMA_BASE_URL=http://host.docker.internal:11434"
Write-Host ""
Write-Host " Pour annuler cette configuration :"
Write-Host ' Get-NetFirewallRule -DisplayName "LoreMind-Ollama-*" | Remove-NetFirewallRule'
Write-Host ' [Environment]::SetEnvironmentVariable("OLLAMA_HOST",$null,"User")'
Write-Host ""

128
installers/secure-host-ollama.sh Normal file
View File

@@ -0,0 +1,128 @@
#!/usr/bin/env bash
# ============================================================================
# LoreMindMJ - Configuration securisee d'Ollama hote (Linux)
# ----------------------------------------------------------------------------
# But : permettre au conteneur Docker de LoreMind d'atteindre l'Ollama
# installe sur l'hote, SANS l'exposer sur le LAN ni Internet.
#
# Strategie : faire ecouter Ollama uniquement sur l'IP de la passerelle du
# bridge Docker (typiquement 172.17.0.1). Cette IP n'est jamais
# routee en dehors de la machine — seuls les conteneurs Docker
# peuvent l'atteindre.
#
# Ce script peut etre lance independamment de install.sh, par ex. si vous
# avez initialement choisi le mode "Ollama embarque" et changez d'avis.
#
# Usage : bash secure-host-ollama.sh
# ============================================================================
set -euo pipefail
c_cyan='\033[1;36m'; c_green='\033[1;32m'; c_yellow='\033[1;33m'; c_red='\033[1;31m'; c_off='\033[0m'
step() { echo -e "${c_cyan}==> $*${c_off}"; }
ok() { echo -e " ${c_green}OK${c_off} $*"; }
warn() { echo -e " ${c_yellow}!!${c_off} $*"; }
err() { echo -e " ${c_red}XX${c_off} $*" >&2; }
# --- 1. Verifications prealables -------------------------------------------
if ! command -v docker >/dev/null 2>&1; then
err "Docker introuvable. Installez Docker avant de lancer ce script."
exit 1
fi
if ! command -v systemctl >/dev/null 2>&1; then
err "systemctl introuvable. Ce script suppose un systeme avec systemd."
err "Configurez OLLAMA_HOST manuellement selon votre init system."
exit 1
fi
if ! systemctl list-unit-files 2>/dev/null | grep -q '^ollama\.service'; then
err "Service systemd 'ollama' introuvable."
err "Installez Ollama via le script officiel : curl -fsSL https://ollama.com/install.sh | sh"
exit 1
fi
# --- 2. Detection de l'IP de la passerelle Docker --------------------------
step "Detection de l'IP du bridge Docker..."
BRIDGE_IP=""
# Methode 1 : docker network inspect (la plus fiable)
if BRIDGE_IP="$(docker network inspect bridge -f '{{range .IPAM.Config}}{{.Gateway}}{{end}}' 2>/dev/null)"; then
if [ -n "$BRIDGE_IP" ]; then
ok "IP du bridge Docker detectee via docker network inspect : $BRIDGE_IP"
fi
fi
# Methode 2 : interface docker0 (si docker network inspect echoue)
if [ -z "$BRIDGE_IP" ] && command -v ip >/dev/null 2>&1; then
BRIDGE_IP="$(ip -4 addr show docker0 2>/dev/null | awk '/inet / {print $2}' | cut -d/ -f1 | head -1)"
if [ -n "$BRIDGE_IP" ]; then
ok "IP du bridge Docker detectee via interface docker0 : $BRIDGE_IP"
fi
fi
# Methode 3 : valeur par defaut (compatible avec 99% des installations)
if [ -z "$BRIDGE_IP" ]; then
BRIDGE_IP="172.17.0.1"
warn "Detection automatique echouee, utilisation de la valeur par defaut : $BRIDGE_IP"
warn "Si Docker n'a jamais ete demarre sur cette machine, lancez 'docker info' une fois pour creer le bridge."
fi
# --- 3. Ecriture de l'override systemd -------------------------------------
step "Configuration du service systemd Ollama..."
OVERRIDE_DIR="/etc/systemd/system/ollama.service.d"
OVERRIDE_FILE="$OVERRIDE_DIR/loremind-host.conf"
sudo mkdir -p "$OVERRIDE_DIR"
sudo tee "$OVERRIDE_FILE" >/dev/null <<EOF
# Genere par LoreMind secure-host-ollama.sh
# Lie Ollama exclusivement a l'IP de la passerelle Docker.
# Consequence : Ollama est joignable depuis les conteneurs Docker
# (via host.docker.internal) mais PAS depuis le LAN ni Internet.
# Pour revenir a la configuration par defaut : sudo rm $OVERRIDE_FILE && sudo systemctl daemon-reload && sudo systemctl restart ollama
[Service]
Environment="OLLAMA_HOST=$BRIDGE_IP:11434"
EOF
ok "Override ecrit : $OVERRIDE_FILE"
# --- 4. Rechargement et redemarrage ----------------------------------------
step "Rechargement de la configuration systemd..."
sudo systemctl daemon-reload
ok "daemon-reload effectue"
step "Redemarrage du service Ollama..."
sudo systemctl restart ollama
sleep 2
if sudo systemctl is-active --quiet ollama; then
ok "Ollama redemarre et actif"
else
err "Ollama n'a pas redemarre correctement. Verifiez : sudo journalctl -u ollama -n 50"
exit 1
fi
# --- 5. Verification du binding --------------------------------------------
step "Verification : Ollama doit ecouter sur $BRIDGE_IP:11434..."
sleep 1
if command -v ss >/dev/null 2>&1; then
if ss -tln 2>/dev/null | grep -q "$BRIDGE_IP:11434"; then
ok "Ollama ecoute bien sur $BRIDGE_IP:11434"
else
warn "Verification impossible (ss n'a pas trouve le binding). Cela peut etre normal si le service vient juste de demarrer."
fi
fi
# --- 6. Recap --------------------------------------------------------------
echo
echo -e "${c_green}============================================================${c_off}"
echo -e "${c_green} Ollama hote configure de maniere securisee${c_off}"
echo -e "${c_green}============================================================${c_off}"
echo " Adresse d'ecoute : $BRIDGE_IP:11434"
echo " Accessible depuis : conteneurs Docker uniquement (via host.docker.internal)"
echo " Inaccessible depuis : LAN, WiFi public, Internet"
echo
echo " Pour LoreMind, definissez dans le fichier .env :"
echo " OLLAMA_BASE_URL=http://host.docker.internal:11434"
echo
echo " Pour annuler cette configuration :"
echo " sudo rm $OVERRIDE_FILE"
echo " sudo systemctl daemon-reload && sudo systemctl restart ollama"
echo

18
web/nginx.conf
View File

@@ -20,6 +20,24 @@ server {
proxy_send_timeout 300s;
}
# index.html : toujours revalide. Empeche un navigateur qui a precedemment
# visite une autre instance LoreMind (demo en ligne, dev local, etc.) de
# servir une vieille version cachee a la place de l'app reelle.
location = /index.html {
add_header Cache-Control "no-cache, no-store, must-revalidate" always;
add_header Pragma "no-cache" always;
expires 0;
try_files $uri =404;
}
# Assets Angular avec hash dans le nom (main.<hash>.js, etc.) :
# immuables, peuvent etre caches longtemps.
location ~* \.(?:js|css|woff2?|ttf|svg|png|jpg|jpeg|webp|ico)$ {
expires 1y;
add_header Cache-Control "public, immutable" always;
try_files $uri =404;
}
location / {
try_files $uri $uri/ /index.html;
}

14
web/src/app/settings/settings.component.html
View File

@@ -141,13 +141,6 @@
</div>
</section>
<div class="actions" *ngIf="settings">
<button class="btn-primary" (click)="save()" [disabled]="saving">
<lucide-icon [img]="Save" [size]="16"></lucide-icon>
<span>{{ saving ? 'Sauvegarde...' : 'Sauvegarder' }}</span>
</button>
</div>
<!-- Bloc Mises a jour -->
<section class="card" *ngIf="config.updateCheckEnabled">
<h2>Mises a jour</h2>
@@ -198,4 +191,11 @@
</div>
</section>
<div class="actions" *ngIf="settings">
<button class="btn-primary" (click)="save()" [disabled]="saving">
<lucide-icon [img]="Save" [size]="16"></lucide-icon>
<span>{{ saving ? 'Sauvegarde...' : 'Sauvegarder' }}</span>
</button>
</div>
</div>