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:
1 parent
eae30775e3
commit
6cdad8b046
20 files changed
+373
-415
No files matched your search
@@ -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
@@ -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"]
|
||||
@@ -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
@@ -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
@@ -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
@@ -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
|
||||
|
||||
Vendored
+10
-34
@@ -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
|
||||
Vendored
+10
-42
@@ -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
|
||||
@@ -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 | - |
|
||||
@@ -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 |
|
||||
|
||||
|
||||
@@ -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
|
||||
@@ -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).
|
||||
|
||||
Reference in new issue
Block a user