Run the containers with the systemd configuration, 1:1

The containers now read the unchanged .env of the matching systemd instance
(/home/llmadmin/mindnet_dev/.env, /home/llmadmin/mindnet/.env) and use the
same Qdrant, Ollama, vault and collection prefix, so both can be compared
side by side. Only container-specific values are overridden: host service
addresses (host.docker.internal instead of 127.0.0.1) and the read-only vault.

- deploy/appenv.py derives the vault mount and prefix from that .env and
  rejects application keys in the container-only file.
- Remove the separate dev Qdrant, the synthetic test vault and the import step.
- UI binds 0.0.0.0 like systemd; API stays loopback by default.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
LarsandClaude Opus 5.5 committed 2026-10-28 17:22:08 +01:00
1 parent eae30775e3
commit 6cdad8b046
20 files changed
+373 -415

No files matched your search

+13 -25
View File
@@ -1,6 +1,6 @@
# Mindnet DEV als Container: jeder Push auf develop baut und startet den Dev-Stack
# auf dem Runner-Host (Muster wie Kansho). Läuft parallel zu systemd; Prod-Qdrant,
# Prod-Vault und die systemd-Dienste werden nicht angefasst.
# auf dem Runner-Host (Muster wie Kansho). Gleiche Konfiguration wie die systemd-
# Dev-Instanz (8002/8502), parallel auf 8012/8512. systemd und Prod bleiben unberührt.
# Ablauf und Abbruchbedingungen: deploy/deploy.sh. Prod-Gegenstück (noch inaktiv):
# deploy/gitea-workflows/deploy-prod.yml.
@@ -18,11 +18,13 @@ concurrency:
jobs:
deploy:
# Runner auf dem Zielhost (heute llm-node). Bei einem Umzug auf einen anderen
# Mini-PC nur das Label und den Pfad der env-Datei anpassen.
# Mini-PC nur das Label und die beiden Pfade anpassen.
runs-on: linux_host
env:
# Liegt auf dem Host, außerhalb von Git (Vorlage: deploy/env/dev.env.example).
MINDNET_ENV_FILE: /home/llmadmin/docker/mindnet-dev/dev.env
# Unveränderte Konfiguration der systemd-Dev-Instanz.
MINDNET_APP_ENV_FILE: /home/llmadmin/mindnet_dev/.env
# Nur Container-Angaben (Vorlage: deploy/env/dev.env.example).
MINDNET_ENV_FILE: /home/llmadmin/docker/mindnet-dev/container.env
steps:
# Ohne actions/checkout: kein Abruf von github.com (DNS/Internet auf dem Host
# nicht nötig). Holt genau den Commit des Pushes vom eigenen Gitea, mit Job-Token.
@@ -30,36 +32,22 @@ jobs:
run: |
set -euo pipefail
git init -q .
git -c http.extraHeader="Authorization: token ${{ github.token }}" fetch -q --depth 1 "${{ github.server_url }}/${{ github.repository }}.git" "${{ github.sha }}"
git -c http.extraHeader="Authorization: token ${{ github.token }}" \
fetch -q --depth 1 "${{ github.server_url }}/${{ github.repository }}.git" "${{ github.sha }}"
git checkout -q --force FETCH_HEAD
git clean -q -ffdx
git log -1 --format='Checkout %H %s'
- name: Host vorbereiten (synthetischer Test-Vault, dev.env beim ersten Lauf)
- name: Container-Datei beim ersten Lauf anlegen
run: |
set -euo pipefail
HOST_DIR="$(dirname "$MINDNET_ENV_FILE")"
install -d -m 0750 "$HOST_DIR"
install -d -m 0755 "$HOST_DIR/testvault"
# Nur synthetische Daten aus dem Repo; für UID 10001 im Container lesbar.
rsync -a --delete --chmod=D755,F644 deploy/testvault/ "$HOST_DIR/testvault/"
install -d -m 0750 "$(dirname "$MINDNET_ENV_FILE")"
if [ ! -f "$MINDNET_ENV_FILE" ]; then
sed "s#^MINDNET_VAULT_HOST_PATH=.*#MINDNET_VAULT_HOST_PATH=$HOST_DIR/testvault#" \
deploy/env/dev.env.example > "$MINDNET_ENV_FILE"
chmod 600 "$MINDNET_ENV_FILE"
echo "dev.env aus Vorlage angelegt: $MINDNET_ENV_FILE"
install -m 0600 deploy/env/dev.env.example "$MINDNET_ENV_FILE"
echo "Container-Datei aus Vorlage angelegt: $MINDNET_ENV_FILE"
fi
docker version --format 'Docker {{.Server.Version}}'
docker compose version
- name: Test, Build, Preflight, Start, Smoke
run: bash deploy/deploy.sh dev
- name: Test-Vault importieren (nur Dev, synthetisch, hash-idempotent) und Smoke mit Daten
run: |
set -euo pipefail
export MINDNET_IMAGE_TAG="dev-$(git rev-parse --short=12 HEAD)"
dc() { docker compose -f deploy/compose.dev.yml --env-file "$MINDNET_ENV_FILE" "$@"; }
dc run --rm --entrypoint python api -m scripts.import_markdown --vault /vault --prefix mindnet_dev --apply
python3 deploy/smoke.py --api "http://$(dc port api 8000)" --ui "http://$(dc port ui 8501 | head -n 1)" \
--prefix mindnet_dev --require-data
+2 -1
View File
@@ -62,4 +62,5 @@ COPY .gitea/workflows/ .gitea/workflows/
USER mindnet:mindnet
ENTRYPOINT []
CMD ["python", "-m", "pytest", "-q", "-p", "no:cacheprovider", \
"tests/test_container_preflight.py", "tests/test_container_connectivity.py"]
"tests/test_container_preflight.py", "tests/test_container_connectivity.py", \
"tests/test_container_appenv.py"]
+96
View File
@@ -0,0 +1,96 @@
"""
FILE: deploy/appenv.py
DESCRIPTION: Liest die unveränderte .env der systemd-Instanz und leitet daraus ab, was
Compose für denselben Betrieb im Container braucht:
- Vault: Host-Pfad und Einhängepunkt so, dass MINDNET_VAULT_ROOT der .env im
Container auf dasselbe Verzeichnis zeigt (relativ -> unter /app, wie unter
dem WorkingDirectory der systemd-Unit)
- erwartetes Collection-Präfix für den Smoke-Test
Prüft außerdem, dass die Container-Datei nur Container-Angaben enthält und
damit keine Anwendungskonfiguration überschreibt.
Nur Standardbibliothek (läuft direkt auf dem Runner).
VERSION: 1.0.0
STATUS: Active
USAGE: appenv.py <systemd.env> <container.env> -> Shell-Zuweisungen auf stdout
"""
from __future__ import annotations
import posixpath
import shlex
import sys
from pathlib import Path
# Einzige Schlüssel, die die Container-Datei setzen darf.
CONTAINER_KEYS = {
"MINDNET_API_PORT", "MINDNET_API_BIND", "MINDNET_UI_PORT", "MINDNET_UI_BIND",
"MINDNET_API_MEM_LIMIT", "MINDNET_UI_MEM_LIMIT", "MINDNET_ALLOW_CLOUD_EGRESS",
"MINDNET_VAULT_SENTINEL",
}
APP_WORKDIR = "/app"
DEFAULT_VAULT_ROOT = "./vault_master" # Default aus app/config.py
DEFAULT_PREFIX = "mindnet" # Default aus app/config.py
class AppEnvError(RuntimeError):
pass
def parse(path: str) -> dict[str, str]:
"""Einfacher dotenv-Parser (KEY=VALUE, optional 'export', Quotes, Kommentare)."""
values = {}
for raw in Path(path).read_text(encoding="utf-8").splitlines():
line = raw.strip()
if not line or line.startswith("#") or "=" not in line:
continue
if line.startswith("export "):
line = line[len("export "):].lstrip()
key, value = (part.strip() for part in line.split("=", 1))
if len(value) >= 2 and value[0] in "\"'" and value[-1] == value[0]:
value = value[1:-1]
elif " #" in value:
value = value.split(" #", 1)[0].rstrip()
values[key] = value
return values
def vault_mount(app_env_path: str, values: dict[str, str]) -> tuple[str, str]:
root = values.get("MINDNET_VAULT_ROOT") or DEFAULT_VAULT_ROOT
if posixpath.isabs(root):
return posixpath.normpath(root), posixpath.normpath(root)
# systemd startet im Ordner der .env (WorkingDirectory), der Container in /app.
host_dir = posixpath.dirname(Path(app_env_path).as_posix())
return posixpath.normpath(posixpath.join(host_dir, root)), posixpath.normpath(posixpath.join(APP_WORKDIR, root))
def derive(app_env_path: str, container_env_path: str) -> dict[str, str]:
extra = sorted(set(parse(container_env_path)) - CONTAINER_KEYS)
if extra:
raise AppEnvError(
f"{container_env_path} darf nur Container-Angaben enthalten; "
f"Anwendungswerte gehören in {app_env_path}: {', '.join(extra)}"
)
values = parse(app_env_path)
host, target = vault_mount(app_env_path, values)
return {
"MINDNET_VAULT_HOST_PATH": host,
"MINDNET_VAULT_TARGET": target,
"MINDNET_EXPECTED_PREFIX": values.get("COLLECTION_PREFIX") or DEFAULT_PREFIX,
}
def main(argv: list[str]) -> int:
if len(argv) != 3:
print("Aufruf: appenv.py <systemd.env> <container.env>", file=sys.stderr)
return 2
try:
derived = derive(argv[1], argv[2])
except (OSError, AppEnvError) as e:
print(f"appenv: {e}", file=sys.stderr)
return 1
for key, value in derived.items():
print(f"{key}={shlex.quote(value)}")
return 0
if __name__ == "__main__":
sys.exit(main(sys.argv))
+23 -39
View File
@@ -1,11 +1,11 @@
# Mindnet ENTWICKLUNG als Container: isoliert von Produktion.
# Mindnet ENTWICKLUNG als Container: dieselbe Anwendung mit derselben Konfiguration
# wie die systemd-Dev-Instanz (8002/8502), parallel auf 8012/8512 zum Vergleich.
#
# docker compose -f deploy/compose.dev.yml --env-file deploy/env/dev.env up -d --wait
#
# - Eigene Qdrant-Instanz mit eigenem Volume (Prod-Qdrant wird nie angesprochen).
# - Vault: nur Testdaten, nur lesend.
# - Ollama ist ein gemeinsamer Host-Dienst (Embeddings).
# - Andere Ports und anderer Compose-Projektname als Prod.
# Gestartet über deploy/deploy.sh dev. Zwei Dateien, beide nur auf dem Host:
# - MINDNET_APP_ENV_FILE: die unveränderte .env der systemd-Dev-Instanz
# - MINDNET_ENV_FILE: nur Container-Angaben (Ports, Bind-Adressen, Freigaben)
# Fest überschrieben wird nur, was im Container anders lauten muss: die Adressen
# der Host-Dienste (statt 127.0.0.1). Vault-Pfad und Präfix kommen aus der .env.
name: mindnet-dev
@@ -15,7 +15,9 @@ x-hardening: &hardening
context: ..
dockerfile: deploy/Dockerfile
target: runtime
env_file: ["${MINDNET_ENV_FILE:-env/dev.env}"]
env_file:
- ${MINDNET_APP_ENV_FILE:?MINDNET_APP_ENV_FILE auf die .env der systemd-Dev-Instanz setzen}
- ${MINDNET_ENV_FILE:-env/dev.env}
read_only: true
tmpfs: ["/tmp:size=64m,mode=1777"]
cap_drop: [ALL]
@@ -29,54 +31,36 @@ x-hardening: &hardening
options: {max-size: "10m", max-file: "3"}
networks: [mindnet-dev]
x-fixed-env: &fixed-env
# Container-bedingte Werte; haben Vorrang vor beiden env-Dateien.
x-container-env: &container-env
MINDNET_ENV: dev
COLLECTION_PREFIX: mindnet_dev
QDRANT_URL: http://qdrant:6333
QDRANT_URL: http://host.docker.internal:6333
MINDNET_OLLAMA_URL: http://host.docker.internal:11434
VECTOR_DIM: "768"
MINDNET_EXPECTED_VECTOR_DIM: "768"
MINDNET_EXPECTED_EMBEDDING_MODEL: nomic-embed-text
MINDNET_VAULT_ROOT: /vault
MINDNET_VAULT_READONLY: "true"
MINDNET_VOCAB_PATH: /vault/_system/dictionary/edge_vocabulary.md
MINDNET_SCHEMA_PATH: /vault/_system/dictionary/graph_schema.md
services:
qdrant:
image: qdrant/qdrant:v1.16.2@sha256:dab6de32f7b2cc599985a7c764db3e8b062f70508fb85ca074aa856f829bf335
restart: unless-stopped
environment:
QDRANT__TELEMETRY_DISABLED: "true"
volumes:
- qdrant:/qdrant/storage
# Standardmäßig nicht veröffentlicht; zum Debuggen optional lokal am Host.
ports: ["127.0.0.1:${MINDNET_DEV_QDRANT_PORT:-6343}:6333"]
healthcheck:
test: ["CMD", "bash", "-c", "exec 3<>/dev/tcp/127.0.0.1/6333"]
interval: 10s
timeout: 5s
retries: 10
networks: [mindnet-dev]
api:
<<: *hardening
command: ["api"]
environment:
<<: *fixed-env
<<: *container-env
volumes:
# Derselbe Vault wie systemd-Dev, eingehängt dort, wo MINDNET_VAULT_ROOT hinzeigt.
# Nur lesend, solange beide Instanzen parallel laufen.
- type: bind
source: ${MINDNET_VAULT_HOST_PATH:?MINDNET_VAULT_HOST_PATH auf ein Testdaten-Verzeichnis setzen}
target: /vault
source: ${MINDNET_VAULT_HOST_PATH:?wird von deploy/deploy.sh aus der .env abgeleitet}
target: ${MINDNET_VAULT_TARGET:?wird von deploy/deploy.sh aus der .env abgeleitet}
read_only: true
bind:
create_host_path: false
propagation: rslave
- logs:/app/logs
- data:/app/data
ports: ["127.0.0.1:${MINDNET_API_PORT:-8012}:8000"]
ports: ["${MINDNET_API_BIND:-127.0.0.1}:${MINDNET_API_PORT:-8012}:8000"]
mem_limit: ${MINDNET_API_MEM_LIMIT:-2g}
depends_on:
qdrant: {condition: service_healthy}
healthcheck:
test: ["CMD", "python", "/opt/mindnet/healthcheck.py", "api"]
interval: 30s
@@ -88,12 +72,13 @@ services:
<<: *hardening
command: ["ui"]
environment:
<<: *fixed-env
<<: *container-env
MINDNET_VAULT_REQUIRED: "false"
MINDNET_API_URL: http://api:8000
volumes:
- data:/app/data:ro
ports: ["${MINDNET_UI_BIND:-127.0.0.1}:${MINDNET_UI_PORT:-8512}:8501"]
# Wie systemd (STREAMLIT_SERVER_ADDRESS=0.0.0.0): im LAN erreichbar.
ports: ["${MINDNET_UI_BIND:-0.0.0.0}:${MINDNET_UI_PORT:-8512}:8501"]
mem_limit: ${MINDNET_UI_MEM_LIMIT:-1g}
depends_on:
api: {condition: service_healthy}
@@ -105,7 +90,6 @@ services:
start_period: 30s
volumes:
qdrant:
logs:
data:
+26 -23
View File
@@ -1,23 +1,25 @@
# Mindnet PRODUKTION als Container (Vorbereitung, noch NICHT aktiv).
# Mindnet PRODUKTION als Container (Vorlage, noch NICHT aktiv): dieselbe Anwendung
# mit derselben Konfiguration wie die systemd-Prod-Instanz (8001/8501), parallel auf
# 8011/8511 zum Vergleich. Umschaltung erst mit Freigabe (Gate G5).
#
# docker compose -f deploy/compose.prod.yml --env-file deploy/env/prod.env up -d --wait
#
# Grenzen dieses Stands (siehe docs/04_Operations/04_docker_deployment.md):
# - Nutzt die bestehende produktive Qdrant-Instanz auf dem Host, startet KEINE eigene.
# - Vault ist zwingend schreibgeschützt, bis R2 (Pfad-Traversal in /ingest/save) behoben ist.
# - Ollama ist ein gemeinsamer Host-Dienst (Embeddings), kein Teil dieses Stacks.
# - Ports weichen bewusst von den systemd-Diensten (8001/8501) ab, damit nichts kollidiert.
# - Start auf llm-node erfordert eine gesonderte Freigabe.
# Gestartet über deploy/deploy.sh prod. Zwei Dateien, beide nur auf dem Host:
# - MINDNET_APP_ENV_FILE: die unveränderte .env der systemd-Prod-Instanz
# - MINDNET_ENV_FILE: nur Container-Angaben (Ports, Bind-Adressen, Freigaben)
# Fest überschrieben wird nur, was im Container anders lauten muss: die Adressen
# der Host-Dienste (statt 127.0.0.1). Vault-Pfad und Präfix kommen aus der .env.
# Vault nur lesend, bis R2 (Pfadsicherheit beim Speichern) behoben ist.
name: mindnet-prod
x-hardening: &hardening
image: mindnet:${MINDNET_IMAGE_TAG:?MINDNET_IMAGE_TAG setzen (z. B. Git-SHA)}
image: mindnet:${MINDNET_IMAGE_TAG:?MINDNET_IMAGE_TAG setzen (z. B. prod-<commit>)}
build:
context: ..
dockerfile: deploy/Dockerfile
target: runtime
env_file: ["${MINDNET_ENV_FILE:-env/prod.env}"]
env_file:
- ${MINDNET_APP_ENV_FILE:?MINDNET_APP_ENV_FILE auf die .env der systemd-Prod-Instanz setzen}
- ${MINDNET_ENV_FILE:-env/prod.env}
read_only: true
tmpfs: ["/tmp:size=64m,mode=1777"]
cap_drop: [ALL]
@@ -31,35 +33,35 @@ x-hardening: &hardening
options: {max-size: "10m", max-file: "3"}
networks: [mindnet-prod]
# Werte, die nicht per env-Datei überschrieben werden dürfen.
x-fixed-env: &fixed-env
# Container-bedingte Werte; haben Vorrang vor beiden env-Dateien.
x-container-env: &container-env
MINDNET_ENV: prod
QDRANT_URL: http://host.docker.internal:6333
MINDNET_OLLAMA_URL: http://host.docker.internal:11434
VECTOR_DIM: "768"
MINDNET_EXPECTED_VECTOR_DIM: "768"
MINDNET_EXPECTED_EMBEDDING_MODEL: nomic-embed-text
MINDNET_VAULT_ROOT: /vault
MINDNET_VAULT_READONLY: "true"
MINDNET_VOCAB_PATH: /vault/_system/dictionary/edge_vocabulary.md
MINDNET_SCHEMA_PATH: /vault/_system/dictionary/graph_schema.md
services:
api:
<<: *hardening
command: ["api"]
environment:
<<: *fixed-env
<<: *container-env
volumes:
# Derselbe Vault wie systemd-Prod, eingehängt dort, wo MINDNET_VAULT_ROOT hinzeigt.
# Nur lesend, solange beide Instanzen parallel laufen.
- type: bind
source: ${MINDNET_VAULT_HOST_PATH:?MINDNET_VAULT_HOST_PATH setzen (NAS-Mount auf dem Host)}
target: /vault
source: ${MINDNET_VAULT_HOST_PATH:?wird von deploy/deploy.sh aus der .env abgeleitet}
target: ${MINDNET_VAULT_TARGET:?wird von deploy/deploy.sh aus der .env abgeleitet}
read_only: true
bind:
create_host_path: false
propagation: rslave
- logs:/app/logs
- data:/app/data
# API ohne Authentisierung: nur lokal am Host veröffentlichen.
ports: ["127.0.0.1:${MINDNET_API_PORT:-8011}:8000"]
ports: ["${MINDNET_API_BIND:-127.0.0.1}:${MINDNET_API_PORT:-8011}:8000"]
mem_limit: ${MINDNET_API_MEM_LIMIT:-2g}
healthcheck:
test: ["CMD", "python", "/opt/mindnet/healthcheck.py", "api"]
@@ -72,12 +74,13 @@ services:
<<: *hardening
command: ["ui"]
environment:
<<: *fixed-env
<<: *container-env
MINDNET_VAULT_REQUIRED: "false"
MINDNET_API_URL: http://api:8000
volumes:
- data:/app/data:ro
ports: ["${MINDNET_UI_BIND:-127.0.0.1}:${MINDNET_UI_PORT:-8511}:8501"]
# Wie systemd (STREAMLIT_SERVER_ADDRESS=0.0.0.0): im LAN erreichbar.
ports: ["${MINDNET_UI_BIND:-0.0.0.0}:${MINDNET_UI_PORT:-8511}:8501"]
mem_limit: ${MINDNET_UI_MEM_LIMIT:-1g}
depends_on:
api: {condition: service_healthy}
+22 -19
View File
@@ -2,7 +2,10 @@
# Baut, prüft und startet einen Mindnet-Container-Stack. Genutzt von den
# Gitea-Workflows (develop -> dev, main -> prod) und für manuelle Deploys.
#
# MINDNET_ENV_FILE=/home/llmadmin/docker/mindnet-dev/dev.env deploy/deploy.sh dev
# MINDNET_APP_ENV_FILE=/home/llmadmin/mindnet_dev/.env # MINDNET_ENV_FILE=/home/llmadmin/docker/mindnet-dev/container.env deploy/deploy.sh dev
#
# MINDNET_APP_ENV_FILE ist die unveränderte .env der systemd-Instanz (gleiche Konfiguration),
# MINDNET_ENV_FILE enthält nur Container-Angaben (deploy/env/<env>.env.example).
#
# Ablauf (jeder Schritt bricht ab, bevor der laufende Stack angefasst wird):
# 1. Container-Tests im Test-Image, ohne Netzwerk (blockierend)
@@ -12,7 +15,7 @@
# 5. up --wait (Healthchecks), danach smoke.py über die veröffentlichten Ports
# 6. Prod: bei Fehler Rückkehr zum letzten erfolgreichen Tag
#
# Die env-Datei liegt auf dem Host außerhalb von Git; in ihrem Verzeichnis
# Beide Dateien liegen auf dem Host außerhalb von Git; im Verzeichnis der Container-Datei
# merkt sich das Skript den letzten erfolgreichen Image-Tag (last_good_tag).
set -euo pipefail
cd "$(dirname "$0")/.."
@@ -22,24 +25,24 @@ case "$ENV" in
dev|prod) ;;
*) echo "Aufruf: deploy/deploy.sh dev|prod" >&2; exit 2 ;;
esac
: "${MINDNET_ENV_FILE:?MINDNET_ENV_FILE auf die env-Datei des Hosts setzen}"
[ -f "$MINDNET_ENV_FILE" ] || { echo "env-Datei fehlt: $MINDNET_ENV_FILE" >&2; exit 1; }
export MINDNET_ENV_FILE
: "${MINDNET_APP_ENV_FILE:?MINDNET_APP_ENV_FILE auf die .env der systemd-Instanz setzen}"
: "${MINDNET_ENV_FILE:?MINDNET_ENV_FILE auf die Container-Datei des Hosts setzen}"
for f in "$MINDNET_APP_ENV_FILE" "$MINDNET_ENV_FILE"; do
[ -f "$f" ] || { echo "env-Datei fehlt: $f" >&2; exit 1; }
done
export MINDNET_APP_ENV_FILE MINDNET_ENV_FILE
# Vault-Mount und Präfix aus der systemd-.env ableiten (gleiches Verzeichnis wie heute).
DERIVED="$(python3 deploy/appenv.py "$MINDNET_APP_ENV_FILE" "$MINDNET_ENV_FILE")"
eval "$DERIVED"
export MINDNET_VAULT_HOST_PATH MINDNET_VAULT_TARGET
PREFIX="$MINDNET_EXPECTED_PREFIX"
echo "$DERIVED"
SHA="$(git rev-parse --short=12 HEAD)"
export MINDNET_IMAGE_TAG="$ENV-$SHA"
LAST_GOOD="$(dirname "$MINDNET_ENV_FILE")/last_good_tag"
if [ "$ENV" = dev ]; then
PREFIX=mindnet_dev
RUN_DEPS=() # startet die eigene Dev-Qdrant für den Preflight mit
SMOKE_ARGS=()
else
PREFIX="$(sed -n 's/^COLLECTION_PREFIX=//p' "$MINDNET_ENV_FILE" | tail -n 1)"
RUN_DEPS=(--no-deps) # Prod hat keine eigene Qdrant
SMOKE_ARGS=(--require-data)
fi
dc() { docker compose -f "deploy/compose.$ENV.yml" --env-file "$MINDNET_ENV_FILE" "$@"; }
step() { printf '\n=== %s\n' "$*"; }
show_logs() { dc ps || true; dc logs --tail 150 api ui || true; }
@@ -47,7 +50,7 @@ published() { dc port "$1" "$2" | head -n 1 | sed 's/^0\.0\.0\.0:/127.0.0.1:/';
smoke() {
python3 deploy/smoke.py --api "http://$(published api 8000)" --ui "http://$(published ui 8501)" \
--prefix "$PREFIX" "${SMOKE_ARGS[@]}"
--prefix "$PREFIX" --require-data
}
step "1/5 Container-Tests (ohne Netzwerk)"
@@ -65,10 +68,10 @@ step "3/5 Image bauen ($MINDNET_IMAGE_TAG)"
dc build api ui
step "4/5 Preflight mit Erreichbarkeit (nur lesend)"
dc run --rm "${RUN_DEPS[@]}" api preflight --live
dc run --rm --no-deps api preflight --live
step "5/5 Start ($MINDNET_IMAGE_TAG) und Smoke"
if dc up -d --wait --no-build && smoke; then
if dc up -d --wait --no-build --remove-orphans && smoke; then
echo "$MINDNET_IMAGE_TAG" > "$LAST_GOOD"
echo "=== mindnet-$ENV läuft mit $MINDNET_IMAGE_TAG"
exit 0
@@ -79,7 +82,7 @@ PREV="$(cat "$LAST_GOOD" 2>/dev/null || true)"
if [ "$ENV" = prod ] && [ -n "$PREV" ] && [ "$PREV" != "$MINDNET_IMAGE_TAG" ]; then
step "Rollback auf $PREV"
export MINDNET_IMAGE_TAG="$PREV"
if dc up -d --wait --no-build && smoke; then
if dc up -d --wait --no-build --remove-orphans && smoke; then
echo "Rollback erfolgreich; Deploy von $ENV-$SHA ist trotzdem fehlgeschlagen."
else
show_logs
+10 -34
View File
@@ -1,39 +1,15 @@
# Mindnet DEV (Container) – Vorlage. Kopieren nach deploy/env/dev.env (nie committen).
# Qdrant-URL und Collection-Präfix sind in compose.dev.yml fest auf die Dev-Instanz gesetzt.
# Mindnet DEV (Container): NUR Container-Angaben. Liegt auf dem Host außerhalb von Git.
# Die Anwendungskonfiguration kommt unverändert aus der .env der systemd-Instanz
# (MINDNET_APP_ENV_FILE im Workflow). deploy/appenv.py lehnt hier andere Schlüssel ab,
# damit diese Datei die Anwendungskonfiguration nicht überschreibt.
# --- Compose / Host ------------------------------------------------------------
MINDNET_IMAGE_TAG=dev
# Host-Pfad eines Verzeichnisses mit TESTDATEN (kein persönlicher Vault); nur lesend.
# Muss _system/dictionary/edge_vocabulary.md enthalten (Sentinel), siehe Doku.
MINDNET_VAULT_HOST_PATH=
MINDNET_API_PORT=8012
# API ohne Authentisierung; die UI erreicht sie intern. Für Zugriff von außen auf 0.0.0.0 setzen.
MINDNET_API_BIND=127.0.0.1
MINDNET_UI_PORT=8512
MINDNET_UI_BIND=127.0.0.1
MINDNET_DEV_QDRANT_PORT=6343
MINDNET_UI_BIND=0.0.0.0
# --- Lokale Modelle (gemeinsamer Host-Dienst) -------------------------------------
MINDNET_OLLAMA_URL=http://host.docker.internal:11434
MINDNET_EMBEDDING_MODEL=nomic-embed-text
MINDNET_LLM_MODEL=phi3:mini
MINDNET_LLM_TIMEOUT=300.0
MINDNET_LLM_BACKGROUND_LIMIT=2
# --- Cloud-LLM -------------------------------------------------------------------
# Nur mit synthetischen Testdaten zulässig. Dann Keys setzen und
# MINDNET_ALLOW_CLOUD_EGRESS=true. Nie mit echten Vault-Inhalten.
MINDNET_LLM_PROVIDER=openrouter
OPENROUTER_API_KEY=
GOOGLE_API_KEY=
# Enthält die systemd-.env Cloud-Keys (OpenRouter/Gemini), startet der Container nur mit
# ausdrücklicher Bestätigung. true = gleiches Verhalten wie heute: Vault-Inhalte gehen
# ohne Privacy Gateway an den Cloud-Provider.
MINDNET_ALLOW_CLOUD_EGRESS=false
MINDNET_LLM_FALLBACK=true
MINDNET_LLM_RATE_LIMIT_WAIT=60.0
MINDNET_LLM_RATE_LIMIT_RETRIES=3
# --- Verarbeitung ----------------------------------------------------------------
MINDNET_TYPES_FILE=./config/types.yaml
MINDNET_CHANGE_DETECTION_MODE=full
MINDNET_LLM_VALIDATION_HEADERS=Unzugeordnete Kanten,Edge Pool,Candidates
MINDNET_LLM_VALIDATION_HEADER_LEVEL=3
MINDNET_NOTE_SCOPE_ZONE_HEADERS=Smart Edges,Relationen,Global Links,Note-Level Relations,Globale Verbindungen
MINDNET_NOTE_SCOPE_HEADER_LEVEL=2
DEBUG=true
+10 -42
View File
@@ -1,47 +1,15 @@
# Mindnet PROD (Container) – Vorlage. Kopieren nach deploy/env/prod.env (nie committen).
# Dient zugleich als --env-file für Compose (Interpolation) und als env_file des Containers.
# Fest verdrahtete Sicherheitswerte (MINDNET_ENV, VECTOR_DIM, Vault-Pfade, Read-only)
# stehen in compose.prod.yml und lassen sich hier NICHT überschreiben.
# Mindnet PROD (Container): NUR Container-Angaben. Liegt auf dem Host außerhalb von Git.
# Die Anwendungskonfiguration kommt unverändert aus der .env der systemd-Instanz
# (MINDNET_APP_ENV_FILE im Workflow). deploy/appenv.py lehnt hier andere Schlüssel ab,
# damit diese Datei die Anwendungskonfiguration nicht überschreibt.
# --- Compose / Host ------------------------------------------------------------
MINDNET_IMAGE_TAG=
# Host-Pfad des NAS-Vaults (muss vor dem Start gemountet sein; wird nur lesend eingebunden)
MINDNET_VAULT_HOST_PATH=
MINDNET_API_PORT=8011
# API ohne Authentisierung; die UI erreicht sie intern. Für Zugriff von außen auf 0.0.0.0 setzen.
MINDNET_API_BIND=127.0.0.1
MINDNET_UI_PORT=8511
# UI nur lokal veröffentlichen; für LAN-Zugriff explizit die LAN-IP des Hosts setzen
MINDNET_UI_BIND=127.0.0.1
MINDNET_UI_BIND=0.0.0.0
# --- Daten ---------------------------------------------------------------------
# Bestehende produktive Qdrant-Instanz auf dem Host (wird nicht verändert)
QDRANT_URL=http://host.docker.internal:6333
QDRANT_API_KEY=
COLLECTION_PREFIX=mindnet
# --- Lokale Modelle (gemeinsamer Host-Dienst) -------------------------------------
MINDNET_OLLAMA_URL=http://host.docker.internal:11434
MINDNET_EMBEDDING_MODEL=nomic-embed-text
MINDNET_LLM_MODEL=phi3:mini
MINDNET_LLM_TIMEOUT=300.0
MINDNET_LLM_BACKGROUND_LIMIT=2
# --- Cloud-LLM -------------------------------------------------------------------
# Ohne Privacy Gateway gehen Vault-Inhalte unmaskiert an den Provider.
# Daher in PROD leer lassen. Sind Keys gesetzt, startet der Container nur mit
# MINDNET_ALLOW_CLOUD_EGRESS=true – das ist in PROD derzeit NICHT freigegeben.
MINDNET_LLM_PROVIDER=openrouter
OPENROUTER_API_KEY=
GOOGLE_API_KEY=
# Enthält die systemd-.env Cloud-Keys (OpenRouter/Gemini), startet der Container nur mit
# ausdrücklicher Bestätigung. true = gleiches Verhalten wie heute: Vault-Inhalte gehen
# ohne Privacy Gateway an den Cloud-Provider.
MINDNET_ALLOW_CLOUD_EGRESS=false
MINDNET_LLM_FALLBACK=true
MINDNET_LLM_RATE_LIMIT_WAIT=60.0
MINDNET_LLM_RATE_LIMIT_RETRIES=3
# --- Verarbeitung (aus config/prod.env übernommen) ---------------------------------
MINDNET_TYPES_FILE=./config/types.yaml
MINDNET_CHANGE_DETECTION_MODE=full
MINDNET_LLM_VALIDATION_HEADERS=Unzugeordnete Kanten,Edge Pool,Candidates
MINDNET_LLM_VALIDATION_HEADER_LEVEL=3
MINDNET_NOTE_SCOPE_ZONE_HEADERS=Smart Edges,Relationen,Global Links,Note-Level Relations,Globale Verbindungen
MINDNET_NOTE_SCOPE_HEADER_LEVEL=2
DEBUG=false
+19 -2
View File
@@ -22,9 +22,14 @@ concurrency:
jobs:
deploy:
# Runner auf dem Zielhost (heute llm-node). Bei einem Umzug auf einen anderen
# Mini-PC nur das Label und die beiden Pfade anpassen.
runs-on: linux_host
env:
MINDNET_ENV_FILE: /home/llmadmin/docker/mindnet/prod.env
# Unveränderte Konfiguration der systemd-Prod-Instanz.
MINDNET_APP_ENV_FILE: /home/llmadmin/mindnet/.env
# Nur Container-Angaben (Vorlage: deploy/env/prod.env.example).
MINDNET_ENV_FILE: /home/llmadmin/docker/mindnet/container.env
steps:
# Ohne actions/checkout: kein Abruf von github.com (DNS/Internet auf dem Host
# nicht nötig). Holt genau den Commit des Pushes vom eigenen Gitea, mit Job-Token.
@@ -32,10 +37,22 @@ jobs:
run: |
set -euo pipefail
git init -q .
git -c http.extraHeader="Authorization: token ${{ github.token }}" fetch -q --depth 1 "${{ github.server_url }}/${{ github.repository }}.git" "${{ github.sha }}"
git -c http.extraHeader="Authorization: token ${{ github.token }}" \
fetch -q --depth 1 "${{ github.server_url }}/${{ github.repository }}.git" "${{ github.sha }}"
git checkout -q --force FETCH_HEAD
git clean -q -ffdx
git log -1 --format='Checkout %H %s'
- name: Container-Datei beim ersten Lauf anlegen
run: |
set -euo pipefail
install -d -m 0750 "$(dirname "$MINDNET_ENV_FILE")"
if [ ! -f "$MINDNET_ENV_FILE" ]; then
install -m 0600 deploy/env/prod.env.example "$MINDNET_ENV_FILE"
echo "Container-Datei aus Vorlage angelegt: $MINDNET_ENV_FILE"
fi
docker version --format 'Docker {{.Server.Version}}'
docker compose version
- name: Test, Build, Preflight, Start, Smoke (Rollback bei Fehler)
run: bash deploy/deploy.sh prod
@@ -1,23 +0,0 @@
---
title: "Experience One"
id: "exp-one"
type: "experience"
status: "active"
created: "2026-10-28T16:35:23+01:00"
updated: "2026-10-28T16:35:23+01:00"
tags: ["area/mindnet","type/experience","topic/test"]
---
## Kontext
Diese Notiz verlinkt auf ein existierendes Konzept und auf eine noch **fehlende** Note.
## Beobachtung
- Bezug zu [[concept-alpha]]
- Offener Verweis auf [[missing-note]]
## Interpretation
Wenn später eine Datei für 'missing-note' angelegt wird, sollte der Importer die Kanten nachziehen.
## Mögliche Verbindungen
- [[concept-alpha]]
- [[missing-note]]
@@ -1,20 +0,0 @@
---
title: "Experience Two"
id: "exp-two"
type: "experience"
status: "active"
created: "2026-10-28T16:35:23+01:00"
updated: "2026-10-28T16:35:23+01:00"
tags: ["area/mindnet","type/experience","topic/test"]
---
## Kontext
Zweite Experience, die auf dasselbe Konzept verweist, ergänzt um **externe Links**.
## Beobachtung
Verweis auf [[concept-alpha]]. Zusätzliche Ressourcen:
- Link: [Beispielseite](https://example.com "Referenz")
- Kontakt: [E-Mail](mailto:info@example.com)
## Mögliche Verbindungen
- [[concept-alpha]]
@@ -1,20 +0,0 @@
---
title: "Project Demo"
id: "project-demo"
type: "project"
status: "active"
created: "2026-10-28T16:35:23+01:00"
updated: "2026-10-28T16:35:23+01:00"
tags: ["area/mindnet","type/project","topic/test"]
---
## Scope
Ein kleines Demo-Projekt, das andere Notizen referenziert.
## Arbeitspakete
- AP-1: Zusammenhang erklären (siehe [[concept-alpha]])
- AP-2: Ereignis berücksichtigen (siehe [[exp-one]])
## Mögliche Verbindungen
- [[concept-alpha]]
- [[exp-one]]
@@ -1,16 +0,0 @@
---
title: "Concept Alpha"
id: "concept-alpha"
type: "concept"
status: "active"
created: "2026-10-28T16:35:23+01:00"
updated: "2026-10-28T16:35:23+01:00"
tags: ["area/mindnet","type/concept","topic/test"]
---
## Beschreibung
Dies ist ein einfaches Konzept für Testzwecke. Es wird von anderen Notizen referenziert.
## Mögliche Verbindungen
- [[exp-one]]
- [[project-demo]]
@@ -1,15 +0,0 @@
---
title: "Missing Note (jetzt angelegt)"
id: "missing-note"
type: "concept"
status: "active"
created: "2026-10-28T16:35:23+01:00"
updated: "2026-10-28T16:35:23+01:00"
tags: ["area/mindnet","type/concept","topic/test"]
---
## Kontext
Diese Notiz wurde **nachträglich** erstellt, um einen zuvor offenen Link zu schließen.
## Mögliche Verbindungen
- [[exp-one]]
@@ -1,28 +0,0 @@
---
id: edge_vocabulary
title: Edge Vocabulary (Test-Vault)
type: reference
status: system
system_role: config
---
# Edge Vocabulary (synthetisch, nur für den Dev-Container)
Dient zugleich als Sentinel des Container-Preflights.
| System-Typ | Inverse | Aliasse | Beschreibung |
| :--- | :--- | :--- | :--- |
| **`caused_by`** | `causes` | ausgelöst_durch, wegen | Kausalität |
| **`derived_from`** | `source_of` | abgeleitet_von, quelle | Herkunft |
| **`based_on`** | `foundation_for` | basiert_auf, grundlage | Fundament |
| **`solves`** | `solved_by` | löst, beantwortet | Lösung |
| **`part_of`** | `has_part` | teil_von, gehört_zu | Hierarchie |
| **`depends_on`** | `required_by` | hängt_ab_von, braucht, enforced_by | Abhängigkeit |
| **`blocks`** | `blocked_by` | blockiert, verhindert | Blocker |
| **`uses`** | `used_by` | nutzt, verwendet | Werkzeug |
| **`guides`** | `guided_by` | steuert, leitet | Richtung |
| **`next`** | `prev` | danach, folgt | Prozess |
| **`prev`** | `next` | davor, vorgänger | Prozess |
| **`related_to`** | `related_to` | siehe_auch, kontext | Lose Assoziation |
| **`similar_to`** | `similar_to` | ähnlich_wie | Ähnlichkeit |
| **`references`** | `referenced_by` | Kein Alias | Standard-Verweis |
@@ -1,30 +0,0 @@
---
id: graph_schema
title: Graph Schema (Test-Vault)
type: reference
status: system
system_role: config
---
# Graph Schema (synthetisch, nur für den Dev-Container)
## Source: `experience`
| Target | Typical | Prohibited |
|---|---|---|
| `concept` | based_on, related_to | - |
| `project` | part_of, related_to | - |
## Source: `project`
| Target | Typical | Prohibited |
|---|---|---|
| `concept` | uses, based_on | - |
| `experience` | derived_from, related_to | - |
## Source: `concept`
| Target | Typical | Prohibited |
|---|---|---|
| `concept` | related_to, similar_to | - |
| `experience` | related_to | - |
+40 -43
View File
@@ -3,7 +3,7 @@ doc_type: operations_manual
audience: devops, deployment_engineer
scope: docker, compose, container_security, nas_mount
status: draft
version: 0.2.0
version: 0.3.0
context: "Container-Betrieb von Mindnet (Dev/Prod) auf llm-node. Vorbereitung, noch keine produktive Umschaltung."
---
@@ -11,20 +11,29 @@ context: "Container-Betrieb von Mindnet (Dev/Prod) auf llm-node. Vorbereitung, n
Stand: 28.10.2026. **Status: Dev aktiv (Push auf `develop`), Prod vorbereitet, nicht aktiv.** Produktion läuft unverändert über systemd und `.gitea/workflows/deploy.yml` (siehe [Deployment Guide](04_deployment_guide.md)). Der Containerstand basiert auf dem stabilen `main`-Verhalten **ohne** Privacy Gateway.
**Grundsatz: 1:1-Migration.** Der Container betreibt dieselbe Anwendung mit derselben Konfiguration wie die jeweilige systemd-Instanz, damit beide parallel verglichen werden können. Er liest deren `.env` unverändert. Konfigurationsänderungen sind nachgelagerte Schritte.
## 1. Überblick
| | Dev | Prod |
| --- | --- | --- |
| Compose-Datei | `deploy/compose.dev.yml` | `deploy/compose.prod.yml` |
| Projektname | `mindnet-dev` | `mindnet-prod` |
| API (nur `127.0.0.1`) | 8012 | 8011 |
| UI (Bind-Adresse konfigurierbar) | 8512 | 8511 |
| Qdrant | eigener Container `qdrant`, Volume `mindnet-dev_qdrant` | bestehende Host-Instanz, unverändert |
| Collection-Präfix | `mindnet_dev` (fest) | `mindnet` (env-Datei, von Preflight geprüft) |
| Vault | Testdaten, nur lesend | NAS-Vault, nur lesend |
| Ollama | gemeinsamer Host-Dienst | gemeinsamer Host-Dienst |
| Vergleichsinstanz (systemd) | 8002/8502, `/home/llmadmin/mindnet_dev` | 8001/8501, `/home/llmadmin/mindnet` |
| Anwendungskonfiguration | `/home/llmadmin/mindnet_dev/.env`, unverändert | `/home/llmadmin/mindnet/.env`, unverändert |
| Container-Angaben | `/home/llmadmin/docker/mindnet-dev/container.env` | `/home/llmadmin/docker/mindnet/container.env` |
| Compose-Datei / Projekt | `deploy/compose.dev.yml` / `mindnet-dev` | `deploy/compose.prod.yml` / `mindnet-prod` |
| API (Standard nur `127.0.0.1`) | 8012 | 8011 |
| UI (Standard `0.0.0.0`, wie systemd) | 8512 | 8511 |
| Qdrant, Ollama | gemeinsame Host-Dienste, wie systemd | gemeinsame Host-Dienste, wie systemd |
| Präfix, Vault | aus der `.env` der systemd-Instanz | aus der `.env` der systemd-Instanz |
Die Ports kollidieren weder untereinander noch mit systemd (8001/8002/8501/8502). Dev und Prod können später parallel zu den systemd-Diensten laufen, was einen Vergleich vor der Umschaltung erlaubt.
Die Ports kollidieren weder untereinander noch mit systemd (8001/8002/8501/8502), damit Container und systemd parallel laufen und verglichen werden können.
**Abweichungen vom heutigen Verhalten, bewusst und nur diese:**
- **Adressen der Host-Dienste:** `QDRANT_URL` und `MINDNET_OLLAMA_URL` zeigen auf `host.docker.internal`. `127.0.0.1` wäre im Container der Container selbst. Ziel sind dieselben Dienste.
- **Vault nur lesend:** Zwei Instanzen sollen nicht parallel in denselben Vault schreiben. Außerdem ist R2 offen. Speichern aus der Container-UI schlägt deshalb fehl, lesen und suchen funktionieren.
- **Cloud-Keys:** Enthält die `.env` Cloud-Keys, startet der Container nur, wenn in der Container-Datei `MINDNET_ALLOW_CLOUD_EGRESS=true` steht. Mit `true` verhält er sich wie heute; die Entscheidung trifft der Betreiber.
- **Bind-Adresse der API:** Standard ist `127.0.0.1`; über `MINDNET_API_BIND` lässt sie sich wie bei systemd auf `0.0.0.0` setzen.
Alle Dateien liegen unter `deploy/`. Dieser Ordner gehört nicht zu `DEPLOY_DIRS` des bestehenden Workflows und wird daher nicht automatisch auf den Server synchronisiert. Der alte Ordner `docker/` (MiniLM-Embed-Dienst, Port 8990) bleibt unverändert, siehe Abschnitt 9.
@@ -69,7 +78,7 @@ Der aktuelle Lock wurde mit `--exclude-newer 2026-01-22` erzeugt, also dem Stand
| Vault fehlt, Sentinel nicht lesbar, Mount nicht `ro` (`statvfs` `ST_RDONLY`) | Arbeiten auf leerem NAS-Mountpunkt; Schreiben in den Vault (R2) |
| `MINDNET_OLLAMA_URL`/`QDRANT_URL` fehlen oder zeigen auf `localhost`/`127.0.0.1` | App fiele still auf `127.0.0.1` zurück, im Container also auf sich selbst |
Die Werte für Umgebung, Dimension und Vault stehen in den Compose-Dateien unter `environment` und lassen sich nicht über die env-Datei überschreiben.
Umgebung, Dimension, Schreibschutz und die Adressen der Host-Dienste stehen in den Compose-Dateien unter `environment` und haben Vorrang vor beiden env-Dateien. Präfix und Vault-Pfad kommen aus der `.env` der systemd-Instanz. Die Präfix-Regel gilt trotzdem: Dev nur `*_dev`, Prod nie.
`preflight --live` prüft zusätzlich **nur lesend** aus dem Container heraus, also über dasselbe Netz wie die API:
@@ -84,13 +93,14 @@ Die Werte für Umgebung, Dimension und Vault stehen in den Compose-Dateien unter
Netzwerkfehler enden als klarer Abbruch mit Exit-Code 1, nicht als Traceback.
```bash
docker compose -f deploy/compose.dev.yml --env-file deploy/env/dev.env run --rm --no-deps api preflight --live
docker compose -f deploy/compose.dev.yml --env-file "$MINDNET_ENV_FILE" run --rm --no-deps api preflight --live # Variablen wie in Abschnitt 7
```
## 4. Vault auf dem NAS
- **Gleicher Vault wie systemd:** `deploy/appenv.py` liest `MINDNET_VAULT_ROOT` aus der `.env`. Ein relativer Pfad wird wie bei systemd gegen das `WorkingDirectory` (Ordner der `.env`) aufgelöst und im Container unter `/app/<pfad>` eingehängt, ein absoluter Pfad 1:1. Dadurch zeigt derselbe Wert im Container auf dasselbe Verzeichnis. Fehlt der Wert, gilt der App-Default `./vault_master`.
- Der Bind-Mount ist `read_only: true`, mit `create_host_path: false` (kein stilles Anlegen) und `propagation: rslave`. Ein später wieder eingehängtes NAS wird dadurch im Container sichtbar, sofern der Host-Mountpunkt `shared` ist.
- **Sentinel:** Standard ist `_system/dictionary/edge_vocabulary.md` relativ zum Vault, einstellbar über `MINDNET_VAULT_SENTINEL`. Die Datei existiert im echten Vault bereits; am NAS muss also nichts angelegt werden. Ein Testdaten-Vault für Dev braucht sie ebenfalls.
- **Sentinel:** Standard ist `_system/dictionary/edge_vocabulary.md` relativ zum Vault, einstellbar über `MINDNET_VAULT_SENTINEL`. Liegt sie im Vault der systemd-Instanz woanders, wird `MINDNET_VAULT_SENTINEL` in der Container-Datei gesetzt.
- **NAS beim Start nicht verfügbar:** Die API startet nicht. `restart: unless-stopped` versucht es mit Backoff weiter. Die UI hängt an der gesunden API.
- **NAS fällt im Betrieb aus:** Der Healthcheck meldet die API als `unhealthy`. Lesende Abfragen gegen Qdrant laufen weiter. Speichern ist wegen des schreibgeschützten Mounts ohnehin ausgeschlossen. `/ingest/save` würde ohne `ro` den fehlenden Vault-Ordner per `os.makedirs` neu anlegen; genau das verhindert der Mount.
- **Berechtigungen:** Der Container läuft als UID 10001. Der Vault muss für diese UID **lesbar** sein, z. B. über `others: r-x` oder eine passende Gruppe auf dem NAS-Export. Bei CIFS-Mounts gelten `uid`/`gid`/`file_mode` aus den Mount-Optionen des Hosts. Prüfen, ohne am NAS etwas zu ändern:
@@ -111,7 +121,9 @@ docker inspect qdrant --format '{{json .HostConfig.PortBindings}}'
Sind Qdrant oder Ollama nur an `127.0.0.1` gebunden, ist der Host-Gateway nicht erreichbar. Lösungsmöglichkeiten, jede nur mit Freigabe: Ollama an die Bridge-Adresse binden (`OLLAMA_HOST`), den Prod-Container an das bestehende Docker-Netz von `qdrant` anhängen (externes Netz), oder `network_mode: host` für die API. Keine davon ist umgesetzt.
Die API hat keine Authentisierung und wird daher nur an `127.0.0.1` veröffentlicht. Die UI erreicht sie intern über `http://api:8000`. Für LAN-Zugriff auf die UI wird `MINDNET_UI_BIND` auf die LAN-IP des Hosts gesetzt.
Ollama ist seit dem 28.10.2026 für die Docker-Netze freigegeben: `OLLAMA_HOST=0.0.0.0:11434` und `ufw allow from 172.16.0.0/12 to any port 11434`, das LAN bleibt gesperrt. Die Prod-Qdrant ist über ihren veröffentlichten Port 6333 erreichbar.
Die API hat keine Authentisierung und wird standardmäßig nur an `127.0.0.1` veröffentlicht. Die UI erreicht sie intern über `http://api:8000`. Die UI ist wie bei systemd im LAN erreichbar (`MINDNET_UI_BIND=0.0.0.0`).
## 6. Härtung
@@ -122,27 +134,20 @@ Für `api` und `ui`: `read_only`-Rootfs, `tmpfs /tmp`, `cap_drop: ALL`, `no-new-
Normalerweise über das Deploy-Skript (Abschnitt 8), auch manuell:
```bash
MINDNET_ENV_FILE=/home/llmadmin/docker/mindnet-dev/dev.env deploy/deploy.sh dev
export MINDNET_APP_ENV_FILE=/home/llmadmin/mindnet_dev/.env # systemd-Dev, unverändert
export MINDNET_ENV_FILE=/home/llmadmin/docker/mindnet-dev/container.env # aus deploy/env/dev.env.example
deploy/deploy.sh dev
```
Einzelschritte von Hand:
Für Einzelschritte von Hand braucht Compose zusätzlich die abgeleiteten Vault-Werte:
```bash
cp deploy/env/dev.env.example deploy/env/dev.env # ausfüllen; *.env ist git-ignoriert
docker compose -f deploy/compose.dev.yml --env-file deploy/env/dev.env build
docker compose -f deploy/compose.dev.yml --env-file deploy/env/dev.env run --rm --no-deps api preflight
docker compose -f deploy/compose.dev.yml --env-file deploy/env/dev.env up -d --wait
eval "$(python3 deploy/appenv.py "$MINDNET_APP_ENV_FILE" "$MINDNET_ENV_FILE")"
export MINDNET_VAULT_HOST_PATH MINDNET_VAULT_TARGET MINDNET_IMAGE_TAG=dev-manual
docker compose -f deploy/compose.dev.yml --env-file "$MINDNET_ENV_FILE" up -d --wait
```
**Dev-Daten aufbauen** (nur Dev-Qdrant, Präfix fest `mindnet_dev`): Der Vault-Mount ist nur lesend; der Import liest die Dateien und schreibt ausschließlich in Qdrant.
```bash
DEV="docker compose -f deploy/compose.dev.yml --env-file deploy/env/dev.env"
$DEV run --rm --no-deps api preflight && \
$DEV run --rm --entrypoint python api -m scripts.import_markdown --vault /vault --prefix mindnet_dev --apply
```
Hinweis: Ein Befehl hinter `run` ersetzt nur `CMD`; `entrypoint.py` lehnt unbekannte Modi ab. Für Skripte wird der Entrypoint deshalb mit `--entrypoint python` ersetzt. Der Preflight muss dann vorher separat laufen, wie oben gezeigt. Die übrigen Prüfungen bleiben wirksam: fester Präfix `mindnet_dev`, Dev-Qdrant und schreibgeschützter Vault.
Einen Import startet der Container-Workflow nicht; die Daten sind dieselben wie bei systemd.
**Ohne Cloud-Keys** (Prod-Standard) ruft der stabile Code für Cloud-Profile Ollama mit der Cloud-Modell-ID auf. Das scheitert zunächst und endet über `fallback_profile` bei `identity_safe` (phi3:mini). Chat funktioniert damit lokal, aber mit Verzögerung durch Fehlversuche (Review R4).
@@ -155,15 +160,7 @@ Gleiches Muster wie Kansho, aber auf dem eigenen Runner des Zielhosts (heute llm
| `.gitea/workflows/deploy-dev.yml` | Push `develop`, manuell | **aktiv** (G3) |
| `deploy/gitea-workflows/deploy-prod.yml` | Push `main`, manuell | Vorlage. Aktivierung bei G5, im **selben Commit** `git rm .gitea/workflows/deploy.yml` (systemd), sonst deployen beide |
**Dev-Testdaten:** Der Dev-Workflow spiegelt vor jedem Deploy den synthetischen Test-Vault `deploy/testvault/` nach `/home/llmadmin/docker/mindnet-dev/testvault` (erzeugt mit `scripts/make_test_vault.py`, dazu synthetisches `edge_vocabulary.md`/`graph_schema.md`). Fehlt `dev.env`, legt er sie beim ersten Lauf aus `deploy/env/dev.env.example` an, ohne Cloud-Keys und mit dem Test-Vault als `MINDNET_VAULT_HOST_PATH`. Eine vorhandene `dev.env` wird nie überschrieben. Die Ordner `vault/` und `vault_master/` im Repo enthalten persönlich wirkende Inhalte und werden **nicht** verwendet.
Test-Vault in die Dev-Qdrant importieren (manuell, nach dem ersten grünen Deploy; Embeddings über Ollama):
```bash
cd <checkout> && export MINDNET_ENV_FILE=/home/llmadmin/docker/mindnet-dev/dev.env
docker compose -f deploy/compose.dev.yml --env-file "$MINDNET_ENV_FILE" run --rm --entrypoint python api \
-m scripts.import_markdown --vault /vault --prefix mindnet_dev --apply
```
Fehlt die Container-Datei, legt der Workflow sie beim ersten Lauf aus `deploy/env/<env>.env.example` an. Sie enthält nur Ports, Bind-Adressen und Freigaben. Eine vorhandene Datei wird nie überschrieben. `deploy/appenv.py` bricht ab, wenn darin Anwendungswerte stehen, damit sie die `.env` der systemd-Instanz nicht überschreiben kann.
Prod nur über einen Merge-Commit `develop` → `main` (`git merge --no-ff develop`), wie bei Kansho.
@@ -172,15 +169,15 @@ Beide Workflows rufen nur `deploy/deploy.sh dev|prod` auf. Jeder Schritt bricht
1. Container-Tests im Test-Image mit `--network none` (Preflight, Erreichbarkeit gegen Fake-Server, statische Compose-/Workflow-Prüfungen), **blockierend**.
2. Volle Testsuite mit `--network none`, **informativ**, bis die 17 bekannten Fehler behoben sind ([Migrationsplan §4](../05_Development/05_docker_migration_plan.md)). Ohne Netzwerk kann kein Test einen echten Dienst erreichen.
3. Image bauen, Tag `<env>-<commit>`.
4. `preflight --live` in einem Wegwerf-Container (Prod mit `--no-deps`; Dev startet dafür die eigene Qdrant).
4. Vault und Präfix aus der systemd-`.env` ableiten (`deploy/appenv.py`), danach `preflight --live` in einem Wegwerf-Container.
5. `up -d --wait` (Healthchecks) und danach `deploy/smoke.py` über die veröffentlichten Ports, also aus Sicht des Hosts:
- API `/healthz`: Status `ok`, erwartetes Präfix.
- API `/admin/stats`: Vektorgröße 768; die API erreicht Qdrant (Collection-Counts ≠ −1).
- UI `/_stcore/health`.
- Prod zusätzlich `--require-data`: alle Collections lesbar, Notes nicht leer.
6. Erfolg: Der Tag wird in `last_good_tag` neben der env-Datei vermerkt. Prod bei Fehler: Rückkehr zum letzten erfolgreichen Tag und erneuter Smoke-Test; der Workflow bleibt trotzdem rot.
- `--require-data`: alle Collections lesbar, Notes nicht leer, denn die Daten der systemd-Instanz sind vorhanden.
6. Erfolg: Der Tag wird in `last_good_tag` neben der Container-Datei vermerkt. Verwaiste Container früherer Stände entfernt `--remove-orphans`. Prod bei Fehler: Rückkehr zum letzten erfolgreichen Tag und erneuter Smoke-Test; der Workflow bleibt trotzdem rot.
Die env-Dateien liegen nur auf dem Host (`/home/llmadmin/docker/mindnet-dev/dev.env`, `/home/llmadmin/docker/mindnet/prod.env`). Die Compose-Dateien lesen sie über `MINDNET_ENV_FILE`; Secrets landen nicht im Runner-Workspace.
Beide env-Dateien liegen nur auf dem Host (Tabelle in Abschnitt 1). Compose liest sie direkt über `MINDNET_APP_ENV_FILE` und `MINDNET_ENV_FILE`; Secrets landen nicht im Runner-Workspace.
**Unterschiede zu Kansho, bewusst:**
@@ -192,7 +189,7 @@ Die env-Dateien liegen nur auf dem Host (`/home/llmadmin/docker/mindnet-dev/dev.
| Image | `build --no-cache`, kein Tag | Hash-Lock, Tag pro Commit, Rollback in Prod |
| Zustand des Hosts | `.env` im Checkout | env-Datei und `last_good_tag` außerhalb des Checkouts |
**Umzug auf einen anderen Mini-PC:** Runner dort registrieren, in beiden Workflows `runs-on` und `MINDNET_ENV_FILE` anpassen, env-Dateien und Vault-Mount einrichten. Hostspezifisch ist sonst nur `host.docker.internal` (über `host-gateway`, funktioniert auf jedem Linux-Docker).
**Umzug auf einen anderen Mini-PC:** Runner dort registrieren, in beiden Workflows `runs-on`, `MINDNET_APP_ENV_FILE` und `MINDNET_ENV_FILE` anpassen. Hostspezifisch ist sonst nur `host.docker.internal` (über `host-gateway`, funktioniert auf jedem Linux-Docker).
## 9. Altbestand `docker/` (MiniLM)
@@ -68,7 +68,7 @@ Für eine CI-Pipeline wie bei Kansho: zuerst A beheben, B/D portieren, C entsche
| **G0** | Repo `Lars/mindnet` auf privat stellen (oder anderes privates Ziel benennen); danach Push von `codex/privacy-gateway`, `develop`, `feature/containerization` | Lars |
| **G1** | Review dieses Stands; Merge `feature/containerization` → `develop` | Lars |
| **G2** | **Nur lesende** Prüfungen auf llm-node: Docker-/Compose-Version, Port-Bindung Qdrant/Ollama (`ss -ltnp`), `docker ps` (läuft `mindnet-embed`?), `pip freeze` der Prod-venv, NAS-Mount (`findmnt`), Lesbarkeit für UID 10001 | Freigabe Lars |
| **G3** | Dev-Stack auf llm-node bauen und starten (eigene Qdrant, Testdaten-Vault), `preflight --live`; `.gitea/workflows/deploy-dev.yml` aktiv, jeder Push auf `develop` deployt Dev | **freigegeben 28.10.2026** |
| **G3** | Dev-Container auf llm-node mit derselben Konfiguration wie systemd-Dev (`.env`, Vault, Qdrant-Präfix), parallel auf 8012/8512, `preflight --live`; `.gitea/workflows/deploy-dev.yml` aktiv, jeder Push auf `develop` deployt Dev | **freigegeben 28.10.2026** |
| **G4** | Prod-Container parallel zu systemd starten (nur lesend auf Prod-Qdrant, Vault `ro`), Vergleich der Antworten | Freigabe Lars |
| **G5** | Umschaltung Prod auf Container; systemd 2–3 Wochen als Rückfallebene; im selben Commit `deploy-prod.yml` aktivieren und `.gitea/workflows/deploy.yml` entfernen | Freigabe Lars; Voraussetzung R2, falls Schreibzugriff nötig |
+78
View File
@@ -0,0 +1,78 @@
"""
FILE: tests/test_container_appenv.py
DESCRIPTION: Prüft deploy/appenv.py: Aus der unveränderten .env der systemd-Instanz
werden Vault-Mount und Präfix so abgeleitet, dass der Container dieselbe
Konfiguration nutzt; die Container-Datei darf nichts davon überschreiben.
"""
import importlib.util
import shlex
from pathlib import Path
import pytest
DEPLOY = Path(__file__).resolve().parents[1] / "deploy"
_spec = importlib.util.spec_from_file_location("mindnet_appenv", DEPLOY / "appenv.py")
appenv = importlib.util.module_from_spec(_spec)
_spec.loader.exec_module(appenv)
APP_ENV = "/home/llmadmin/mindnet_dev/.env"
def _files(tmp_path, app_text, container_text="MINDNET_UI_PORT=8512\n"):
app = tmp_path / "app.env"
app.write_text(app_text, encoding="utf-8")
container = tmp_path / "container.env"
container.write_text(container_text, encoding="utf-8")
return str(app), str(container)
def test_parse_handles_export_quotes_and_comments(tmp_path):
app, _ = _files(tmp_path, '# Kommentar\nexport A=1\nB="mit # Raute"\nC=wert # Kommentar\nD=\n')
assert appenv.parse(app) == {"A": "1", "B": "mit # Raute", "C": "wert", "D": ""}
@pytest.mark.parametrize("root, host, target", [
("./vault", "/home/llmadmin/mindnet_dev/vault", "/app/vault"),
("vault_dev", "/home/llmadmin/mindnet_dev/vault_dev", "/app/vault_dev"),
("../shared/vault", "/home/llmadmin/shared/vault", "/shared/vault"),
("/mnt/nas/vault/", "/mnt/nas/vault", "/mnt/nas/vault"),
])
def test_vault_mount_points_where_the_app_looks(root, host, target):
# Relativ: systemd löst gegen WorkingDirectory (= Ordner der .env) auf, der Container gegen /app.
assert appenv.vault_mount(APP_ENV, {"MINDNET_VAULT_ROOT": root}) == (host, target)
def test_vault_mount_uses_app_default_when_unset():
assert appenv.vault_mount(APP_ENV, {}) == ("/home/llmadmin/mindnet_dev/vault_master", "/app/vault_master")
def test_derive_takes_prefix_from_systemd_env(tmp_path):
app, container = _files(tmp_path, "COLLECTION_PREFIX=mindnet_dev\nMINDNET_VAULT_ROOT=/srv/vault\n")
derived = appenv.derive(app, container)
assert derived["MINDNET_EXPECTED_PREFIX"] == "mindnet_dev"
assert derived["MINDNET_VAULT_HOST_PATH"] == derived["MINDNET_VAULT_TARGET"] == "/srv/vault"
def test_derive_falls_back_to_app_default_prefix(tmp_path):
app, container = _files(tmp_path, "MINDNET_VAULT_ROOT=/srv/vault\n")
assert appenv.derive(app, container)["MINDNET_EXPECTED_PREFIX"] == "mindnet"
@pytest.mark.parametrize("key", ["COLLECTION_PREFIX", "MINDNET_VAULT_ROOT", "OPENROUTER_API_KEY", "QDRANT_URL"])
def test_container_env_must_not_override_app_config(tmp_path, key):
app, container = _files(tmp_path, "COLLECTION_PREFIX=mindnet_dev\n", f"MINDNET_UI_PORT=8512\n{key}=x\n")
with pytest.raises(appenv.AppEnvError, match=key):
appenv.derive(app, container)
def test_main_prints_shell_safe_assignments(tmp_path, capsys):
app, container = _files(tmp_path, "COLLECTION_PREFIX=mindnet_dev\nMINDNET_VAULT_ROOT=/srv/my vault\n")
assert appenv.main(["appenv.py", app, container]) == 0
lines = capsys.readouterr().out.splitlines()
parsed = dict(shlex.split(line)[0].split("=", 1) for line in lines)
assert parsed["MINDNET_VAULT_HOST_PATH"] == "/srv/my vault"
def test_main_reports_missing_file(tmp_path, capsys):
assert appenv.main(["appenv.py", str(tmp_path / "fehlt.env"), str(tmp_path / "auch.env")]) == 1
assert "appenv:" in capsys.readouterr().err
+33 -34
View File
@@ -13,16 +13,18 @@ import yaml
ROOT = Path(__file__).resolve().parents[1]
DEPLOY = ROOT / "deploy"
SYSTEMD_PORTS = {8001, 8002, 8501, 8502}
# WorkingDirectory der systemd-Units (llm-node), deren .env der Container unverändert liest.
SYSTEMD_ENV_FILES = {"dev": "/home/llmadmin/mindnet_dev/.env", "prod": "/home/llmadmin/mindnet/.env"}
def _load_entrypoint():
spec = importlib.util.spec_from_file_location("mindnet_entrypoint", DEPLOY / "entrypoint.py")
def _load_deploy_module(name):
spec = importlib.util.spec_from_file_location(f"mindnet_{name}", DEPLOY / f"{name}.py")
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)
return module
ep = _load_entrypoint()
ep = _load_deploy_module("entrypoint")
@pytest.fixture
@@ -189,26 +191,29 @@ def test_compose_app_services_hardened(envname):
@pytest.mark.parametrize("envname", ["dev", "prod"])
def test_compose_vault_is_read_only_bind_without_autocreate(envname):
mounts = [v for v in COMPOSE[envname]["services"]["api"]["volumes"]
if isinstance(v, dict) and v.get("target") == "/vault"]
if isinstance(v, dict) and v.get("type") == "bind"]
assert len(mounts) == 1
assert mounts[0]["target"].startswith("${MINDNET_VAULT_TARGET:?") # aus der systemd-.env abgeleitet
assert mounts[0]["read_only"] is True
assert mounts[0]["bind"]["create_host_path"] is False
assert all(":/vault" not in v for v in COMPOSE[envname]["services"]["ui"]["volumes"] if isinstance(v, str))
assert not [v for v in COMPOSE[envname]["services"]["ui"]["volumes"] if isinstance(v, dict)]
@pytest.mark.parametrize("envname", ["dev", "prod"])
def test_compose_api_only_on_loopback(envname):
assert all(p.startswith("127.0.0.1:") for p in COMPOSE[envname]["services"]["api"]["ports"])
def test_compose_api_defaults_to_loopback(envname):
assert all(p.startswith("${MINDNET_API_BIND:-127.0.0.1}:") for p in COMPOSE[envname]["services"]["api"]["ports"])
def test_prod_uses_existing_qdrant_and_dev_its_own():
assert "qdrant" not in COMPOSE["prod"]["services"]
dev_qdrant = COMPOSE["dev"]["services"]["qdrant"]
assert "@sha256:" in dev_qdrant["image"]
@pytest.mark.parametrize("envname", ["dev", "prod"])
def test_compose_uses_existing_host_services_and_app_config(envname):
# Wie systemd: gemeinsame Host-Qdrant und Host-Ollama; Präfix/Vault aus der systemd-.env.
assert set(COMPOSE[envname]["services"]) == set(APP_SERVICES)
for name in APP_SERVICES:
dev_env = COMPOSE["dev"]["services"][name]["environment"]
assert dev_env["QDRANT_URL"] == "http://qdrant:6333"
assert dev_env["COLLECTION_PREFIX"].endswith("_dev")
env = COMPOSE[envname]["services"][name]["environment"]
assert env["MINDNET_ENV"] == envname
assert env["QDRANT_URL"] == "http://host.docker.internal:6333"
assert env["MINDNET_OLLAMA_URL"] == "http://host.docker.internal:11434"
assert not {"COLLECTION_PREFIX", "MINDNET_VAULT_ROOT", "MINDNET_VOCAB_PATH"} & set(env)
def test_dockerfile_pinned_and_non_root():
@@ -235,10 +240,11 @@ def test_dockerignore_is_allowlist_without_env_files():
assert not any(l.startswith("!") and ("vault" in l or ".env" in l) for l in lines)
def test_prod_env_example_blocks_cloud_egress():
values = dict(l.split("=", 1) for l in (DEPLOY / "env" / "prod.env.example").read_text(encoding="utf-8").splitlines()
if "=" in l and not l.startswith("#"))
assert values["OPENROUTER_API_KEY"] == "" and values["GOOGLE_API_KEY"] == ""
@pytest.mark.parametrize("envname", ["dev", "prod"])
def test_container_env_example_has_only_container_keys(envname):
appenv = _load_deploy_module("appenv")
values = appenv.parse(str(DEPLOY / "env" / f"{envname}.env.example"))
assert set(values) <= appenv.CONTAINER_KEYS
assert values["MINDNET_ALLOW_CLOUD_EGRESS"] == "false"
@@ -260,7 +266,8 @@ def test_workflow_maps_branch_to_environment(name, branch, envname):
assert on["push"]["branches"] == [branch]
job = wf["jobs"]["deploy"]
assert job["runs-on"] == "linux_host"
assert job["env"]["MINDNET_ENV_FILE"].startswith("/") and job["env"]["MINDNET_ENV_FILE"].endswith(f"{envname}.env")
assert job["env"]["MINDNET_ENV_FILE"].startswith("/") and job["env"]["MINDNET_ENV_FILE"].endswith("container.env")
assert job["env"]["MINDNET_APP_ENV_FILE"] == SYSTEMD_ENV_FILES[envname]
assert any(s.get("run") == f"bash deploy/deploy.sh {envname}" for s in job["steps"])
@@ -274,32 +281,24 @@ def test_deploy_script_checks_before_touching_running_stack():
script = (DEPLOY / "deploy.sh").read_text(encoding="utf-8")
assert "\r" not in script
steps = script.split('step "1/5', 1)[1] # ohne Kopfkommentar und Funktionsdefinitionen
order = [steps.index(s) for s in ("--network none", "preflight --live", "up -d --wait --no-build && smoke")]
order = [steps.index(s) for s in ("--network none", "preflight --live", "up -d --wait --no-build --remove-orphans && smoke")]
assert order == sorted(order)
assert "RUN_DEPS=(--no-deps)" in script and "SMOKE_ARGS=(--require-data)" in script
assert "preflight --live" in script and "run --rm --no-deps api preflight" in script
assert "--require-data" in script and "deploy/appenv.py" in script
assert "last_good_tag" in script
@pytest.mark.parametrize("envname", ["dev", "prod"])
def test_compose_reads_env_file_from_host(envname):
assert COMPOSE[envname]["x-hardening"]["env_file"] == [f"${{MINDNET_ENV_FILE:-env/{envname}.env}}"]
def test_compose_reads_systemd_env_then_container_env(envname):
files = COMPOSE[envname]["x-hardening"]["env_file"]
assert files[0].startswith("${MINDNET_APP_ENV_FILE:?")
assert files[1] == f"${{MINDNET_ENV_FILE:-env/{envname}.env}}"
def test_prod_workflow_not_active_before_switchover():
assert not (ROOT / ".gitea" / "workflows" / "deploy-prod.yml").exists()
def test_dev_testvault_is_synthetic_and_parseable():
vault = DEPLOY / "testvault"
vocab = (vault / "_system" / "dictionary" / "edge_vocabulary.md").read_text(encoding="utf-8")
# Gleiches Muster wie app/services/edge_registry.py
rows = re.findall(r"\|\s*\*\*`?([a-zA-Z0-9_-]+)`?\*\*\s*\|\s*`?([a-zA-Z0-9_-]+)`?\s*\|\s*([^|]+)\|", vocab)
assert len(rows) >= 10
assert (vault / "_system" / "dictionary" / "graph_schema.md").is_file()
notes = [f for f in vault.rglob("*.md") if "_system" not in f.parts]
assert notes and all("topic/test" in f.read_text(encoding="utf-8") for f in notes)
@pytest.mark.parametrize("name", ["deploy-dev.yml", "deploy-prod.yml"])
def test_workflow_needs_no_external_actions(name):
# Der Runner-Host soll ohne Internet/DNS deployen können (kein github.com).