mocode-software/meldestelle
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update Zora configuration: add detailed runbook, reassign ai-stack to CT 120, and improve infrastructure documentation
All checks were successful
Build and Publish Docker Images / build-and-push (., backend/infrastructure/gateway/Dockerfile, api-gateway, api-gateway) (push) Successful in 8m7s
Details
Build and Publish Docker Images / build-and-push (., backend/services/ping/Dockerfile, ping-service, ping-service) (push) Successful in 7m16s
Details
Build and Publish Docker Images / build-and-push (., config/docker/caddy/web-app/Dockerfile, web-app, web-app) (push) Successful in 1m48s
Details
Build and Publish Docker Images / build-and-push (., config/docker/keycloak/Dockerfile, keycloak, keycloak) (push) Successful in 1m32s
Details

Browse Source
This commit is contained in:
Stefan Mogeritsch 2026-03-08 00:37:34 +01:00
parent 0035225614
commit f022de7358
6 changed files with 593 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
.gitea/workflows/docker-publish.yaml
View File

@ -90,12 +90,20 @@ jobs:
# Pangolin-Bypass: Credentials direkt in config.json schreiben.
# Kein "docker login" → kein Daemon-Ping → kein HTTPS-Fehler.
# BuildKit liest ~/.docker/config.json und verwendet diese Credentials beim Push.
- name: Registry-Credentials konfigurieren (kein Daemon-Kontakt)
run: |
mkdir -p ~/.docker
AUTH=$(echo -n "${{ secrets.REGISTRY_USER }}:${{ secrets.REGISTRY_TOKEN }}" | base64 -w 0)
printf '{"auths":{"%s":{"auth":"%s"}}}\n' "${{ env.REGISTRY_INTERNAL }}" "${AUTH}" > ~/.docker/config.json
echo "✓ Credentials für ${{ env.REGISTRY_INTERNAL }} gespeichert"
# - name: Registry-Credentials konfigurieren (kein Daemon-Kontakt)
# run: |
# mkdir -p ~/.docker
# AUTH=$(echo -n "${{ secrets.REGISTRY_USER }}:${{ secrets.REGISTRY_TOKEN }}" | base64 -w 0)
# printf '{"auths":{"%s":{"auth":"%s"}}}\n' "${{ env.REGISTRY_INTERNAL }}" "${AUTH}" > ~/.docker/config.json
# echo "✓ Credentials für ${{ env.REGISTRY_INTERNAL }} gespeichert"
# NEU (sauber, nach daemon.json-Fix):
- name: Login to Gitea Registry
uses: docker/login-action@v3
with:
registry: ${{ env.REGISTRY_INTERNAL }}
username: ${{ secrets.REGISTRY_USER }}
password: ${{ secrets.REGISTRY_TOKEN }}
# BuildKit-Instanz mit HTTP-Unterstützung für die interne Registry konfigurieren.
# KEIN sudo, KEIN systemctl, KEIN Neustart — rein konfigurativ.

44
docs/01_Architecture/Minisforum-MS-R1/AI_Stack_Ollama_Setup.md
View File

@ -43,7 +43,7 @@ Zora — Proxmox 8.4.10 (10.0.0.20)
├── LXC 100 pangolin-client ← Pangolin Tunnel
├── LXC 101 gitea (10.0.0.22) ← Gitea Server
├── LXC 103 immich ← Immich
└── LXC 111 ai-stack (10.0.0.60) ← Ollama + Open WebUI ← NEU
└── LXC 120 ai-stack (10.0.0.60) ← Ollama + Open WebUI ← NEU
```
**Begründung:** Modelle (5–40 GB pro Modell) wachsen unkontrolliert.
@ -107,39 +107,39 @@ sysctl -p
> ℹ️ **Alle Befehle laufen auf dem Proxmox-Node** (`ssh root@10.0.0.20`)
> Alternativ: Proxmox Web-UI unter `https://pve.mo-code.at:8006`
### 2.1 — Debian 12 Template herunterladen
### 2.1 — Ubuntu 24.04 Template herunterladen
```bash
# Template-Liste aktualisieren
pveam update
# Debian 12 ARM64 Template suchen und herunterladen
pveam available --section system | grep debian-12.*arm64
pveam download local debian-12-standard_12.7-1_arm64.tar.zst
# Ubuntu 24.04 ARM64 Template suchen und herunterladen
pveam available --section system | grep ubuntu-24.04.*arm64
pveam download local ubuntu-24.04-standard_24.04-2_arm64.tar.zst
```
### 2.2 — Container erstellen (CT 111)
### 2.2 — Container erstellen (CT 120)
```bash
pct create 111 local:vztmpl/debian-12-standard_12.7-1_arm64.tar.zst \
pct create 120 local:vztmpl/ubuntu-24.04-standard_24.04-2_arm64.tar.zst \
--hostname ai-stack \
--arch aarch64 \
--cores 10 \
--memory 49152 \
--swap 4096 \
--rootfs local-lvm:200 \
--rootfs local:200 \
--net0 name=eth0,bridge=vmbr0,ip=10.0.0.60/24,gw=10.0.0.138,firewall=1 \
--nameserver 10.0.0.138 \
--searchdomain mo-code.at \
--unprivileged 1 \
--features nesting=1 \
--features nesting=1,keyctl=1 \
--password
# Container starten
pct start 111
pct start 120
# Status prüfen
pct status 111
pct status 120
pct list
```
@ -148,18 +148,18 @@ pct list
```bash
# Kerne 2–11 dem Container zuweisen (Kerne 8–11 = X4 Performance-Kerne!)
# In der Container-Config:
echo "cpulimit: 10" >> /etc/pve/lxc/111.conf
echo "cpuunits: 1024" >> /etc/pve/lxc/111.conf
echo "cpulimit: 10" >> /etc/pve/lxc/120.conf
echo "cpuunits: 1024" >> /etc/pve/lxc/120.conf
# Alternativ via Web-UI:
# CT 111 → Options → CPU Limit: 10 Cores
# CT 120 → Options → CPU Limit: 10 Cores
```
### 2.4 — In Container einloggen und Basis-Setup
```bash
# Direkt per pct:
pct enter 111
pct enter 120
# Im Container:
apt-get update && apt-get upgrade -y
@ -181,7 +181,7 @@ usermod -aG docker aiuser
### 3.1 — Ollama installieren
```bash
# Im Container (pct enter 111):
# Im Container (pct enter 120):
curl -fsSL https://ollama.com/install.sh | sh
# ARM64 wird automatisch erkannt
@ -268,7 +268,7 @@ ollama run llama3.1:8b "Erkläre mir Spring Boot in einem Satz auf Deutsch"
## Phase 5 — Open WebUI installieren
```bash
# Im Container (pct enter 111):
# Im Container (pct enter 120):
docker run -d \
--name open-webui \
--restart always \
@ -392,10 +392,10 @@ Der CIX P1 hat eine integrierte NPU, die aktuell **nicht von Ollama/llama.cpp un
```bash
# Container verwalten (auf Proxmox-Node: ssh root@10.0.0.20)
pct start 111
pct stop 111
pct enter 111
pct status 111
pct start 120
pct stop 120
pct enter 120
pct status 120
# Modelle verwalten (im Container)
ollama list # Installierte Modelle
@ -422,7 +422,7 @@ Zora — Proxmox 8.4.10 (10.0.0.20)
├── VM 110 meldestelle-host 10.0.0.50 Docker App-Stack
├── LXC 101 gitea 10.0.0.22 Gitea Server
├── LXC 103 immich Immich
└── LXC 111 ai-stack 10.0.0.60 Ollama :11434 | Open WebUI :3001
└── LXC 120 ai-stack 10.0.0.60 Ollama :11434 | Open WebUI :3001
Pangolin-Tunnel:
├── ai.mo-code.at → 10.0.0.60:3001 (Open WebUI — nur intern/VPN)

29
docs/01_Architecture/Minisforum-MS-R1/SSoT_Konfigurations-Masterplan_Zora.md
View File

@ -24,7 +24,7 @@ owner: DevOps Engineer
| 102 | gitea-runner | VM | `10.0.0.23` | — | Gitea CI/CD Runner (aarch64) |
| 103 | immich | LXC | `10.0.0.24` | order=3, up=30 | Immich Foto-Server |
| 110 | meldestelle-host | VM | `10.0.0.50` | — | Docker App-Stack |
| 111 | ai-stack | LXC | `10.0.0.60` | — | Ollama + Open WebUI (geplant)|
| 120 | ai-stack | LXC | `10.0.0.60` | — | Ollama + Open WebUI |
### Detaillierte Ressourcen-Konfiguration
@ -63,6 +63,33 @@ owner: DevOps Engineer
| **Typ** | Unprivileged, nesting=1, keyctl=1, fuse=1 |
| **Autostart** | Ja — order=3, up=30 |
#### CT 120 — ai-stack (LXC)
| Parameter | Wert |
|:-----------------|:---------------------------------------|
| **OS** | Ubuntu 24.04, arm64 |
| **CPU** | 10 Cores (cpulimit=10, cpuunits=1024) |
| **RAM** | 48.00 GiB + 4.00 GiB Swap |
| **Disk** | 200 GB (`local:120/vm-120-disk-0.raw`) |
| **Netzwerk** | eth0 → vmbr0, IP `10.0.0.60/24`, GW `10.0.0.138`, Firewall: Yes |
| **Typ** | Unprivileged, nesting=1, keyctl=1 |
| **Autostart** | Nein |
| **Dienste** | Ollama :11434, Open WebUI :3001 |
#### VM 110 — meldestelle-host (QEMU/KVM)
| Parameter | Wert |
|:-----------------|:-----------------------------------------------------------------|
| **BIOS** | OVMF (UEFI) |
| **Machine** | virt (ARM64, aarch64) |
| **CPU** | 8 Cores (1 Socket, host-type, numa=1) |
| **RAM** | 16.00 GiB (balloon=0, kein Dynamic Memory) |
| **Disk** | 150 GB SSD (`local:110/vm-110-disk-1.qcow2`, aio=io_uring, iothread=1, ssd=1) |
| **EFI Disk** | `local:110/vm-110-disk-0.qcow2`, efitype=4m, 64 MB |
| **Netzwerk** | virtio, bridge=vmbr0, Firewall: Yes |
| **SCSI** | VirtIO SCSI single |
| **Autostart** | Nein (order=any) |
| **QEMU Agent** | Enabled |
| **Dienste** | Docker App-Stack (API :8081, Keycloak :8180, Prometheus :9090, Grafana :3000) |
#### VM 102 — gitea-runner (QEMU/KVM)
| Parameter | Wert |
|:-----------------|:-----------------------------------------------------------------|

4
docs/01_Architecture/Minisforum-MS-R1/Zora_Hardware_Zusammenfassung.md
View File

@ -155,8 +155,8 @@ Cores 8–11 → Cortex-X4 (Performance / schnell) ← 4 Kerne
| 101 | gitea | LXC | `10.0.0.22` | 4C | 1 GiB | 20 GB | Gitea Server + Registry |
| 102 | gitea-runner | VM (KVM) | `10.0.0.23` | 8C | 16 GiB | 50 GB | CI/CD Runner (ARM64) |
| 103 | immich | LXC | `10.0.0.24` | 8C | 10 GiB | 200 GB | Foto-Server |
| 110 | meldestelle-host | VM (KVM) | `10.0.0.50` | — | — | — | Docker App-Stack |
| 111 | ai-stack | LXC | `10.0.0.60` | 10C | — | — | Ollama + Open WebUI (geplant)|
| 110 | meldestelle-host | VM (KVM) | `10.0.0.50` | 8C | 16 GiB | 150 GB | Docker App-Stack |
| 120 | ai-stack | LXC | `10.0.0.60` | 10C | 48 GiB | 200 GB | Ollama + Open WebUI |
### Core-Pinning (Stabilisierung)

454
docs/07_Infrastructure/runbooks/zora-setup-runbook.md Normal file
View File

@ -0,0 +1,454 @@
---
type: Runbook
status: ACTIVE
owner: DevOps Engineer
last_update: 2026-03-06
---
# Runbook: Zora — Vollständige Systemkonfiguration
Dieses Runbook beschreibt die vollständige Konfiguration aller drei Zora-Systeme:
**Gitea (CT 101)**, **Gitea-Runner (VM 102)** und **Meldestelle-Host (VM 110)**.
> **Referenz:** `docs/01_Architecture/Minisforum-MS-R1/SSoT_Konfigurations-Masterplan_Zora.md`
---
## Übersicht & IP-Adressen
| System | Typ | IP | Port | Zweck |
|:------------------|:-----|:-------------|:------|:-----------------------------|
| Gitea | LXC | `10.0.0.22` | `3000`| Git-Server + Registry |
| Gitea-Runner | VM | `10.0.0.23` | — | CI/CD ARM64-Builder |
| Meldestelle-Host | VM | `10.0.0.50` | — | Docker App-Stack |
| Proxmox Node | — | `10.0.0.20` | `8006`| Hypervisor Web-UI |
---
## 1. Gitea (CT 101 — `10.0.0.22`)
### 1.1 Erreichbarkeit prüfen
```bash
# Intern (im Heimnetz)
curl -s http://10.0.0.22:3000 | grep -i gitea
# Extern (via Pangolin)
curl -s https://git.mo-code.at | grep -i gitea
```
**Erwartetes Ergebnis:** HTTP 200, Gitea-Login-Seite.
### 1.2 Container-Registry verifizieren
Im Gitea Web-UI (`http://10.0.0.22:3000`):
1. **Einstellungen → Packages** → sicherstellen, dass Packages aktiviert sind.
2. **Organisation `mocode-software` → Packages** → folgende Images müssen vorhanden sein:
- `mocode-software/meldestelle/api-gateway:latest`
- `mocode-software/meldestelle/ping-service:latest`
- `mocode-software/meldestelle/web-app:latest`
- `mocode-software/meldestelle/keycloak:latest`
Falls Images fehlen: Pipeline manuell triggern (Push auf `main` oder Re-Run im Gitea Actions UI).
### 1.3 Org-Secrets prüfen
Im Gitea Web-UI:
**Organisation `mocode-software` → Einstellungen → Secrets & Variables → Actions**
Folgende Secrets müssen gesetzt sein:
| Secret-Name | Wert |
|:-----------------|:----------------------------|
| `REGISTRY_USER` | Gitea-Username des CI-Users |
| `REGISTRY_TOKEN` | Gitea Access-Token (Scope: `package:write`) |
Falls nicht gesetzt:
1. Gitea → Profil → **Settings → Applications → Generate Token**
2. Scope: `package:write` aktivieren
3. Token als `REGISTRY_TOKEN` in Org-Secrets speichern
---
## 2. Gitea-Runner (VM 102 — `10.0.0.23`) — Vollständige Installation
> **Status (06.03.2026):**
> - ✅ `daemon.json` korrekt gesetzt (`insecure-registries: 10.0.0.22:3000`)
> - ❌ `gitea-runner.service` **existiert nicht** — Binary und Service müssen installiert werden!
### 2.1 SSH-Verbindung
```bash
ssh gitearun@10.0.0.23
```
### 2.2 Docker Daemon konfigurieren ✅ (bereits erledigt)
```bash
# Verifizieren — muss bereits korrekt sein:
docker info | grep -A5 "Insecure Registries"
```
**Erwartetes Ergebnis:**
```
Insecure Registries:
10.0.0.22:3000
```
Falls nicht gesetzt:
```bash
sudo tee /etc/docker/daemon.json > /dev/null <<'EOF'
{
"insecure-registries": ["10.0.0.22:3000"]
}
EOF
sudo systemctl restart docker
```
### 2.3 Gitea Actions Runner installieren
#### Schritt 1: Registrierungs-Token holen
Im Gitea Web-UI (`http://10.0.0.22:3000`):
**Site Administration → Actions → Runners → Create new Runner**
> Alternativ auf Organisations-Ebene:
> **Organisation `mocode-software` → Einstellungen → Actions → Runners → Create Runner**
Den angezeigten **Registration Token** kopieren (einmalig gültig).
#### Schritt 2: Binary herunterladen (ARM64)
```bash
# Aktuelle Version prüfen: https://gitea.com/gitea/act_runner/releases
ACT_RUNNER_VERSION="0.2.11"
# ARM64-Binary laden (passend zu Zora/MS-R1)
wget -O act_runner "https://gitea.com/gitea/act_runner/releases/download/v${ACT_RUNNER_VERSION}/act_runner-${ACT_RUNNER_VERSION}-linux-arm64"
# Ausführbar machen und in PATH legen
chmod +x act_runner
sudo mv act_runner /usr/local/bin/act_runner
# Verifizieren
act_runner --version
```
#### Schritt 3: Runner registrieren
```bash
# Interaktive Registrierung
act_runner register \
--no-interactive \
--instance http://10.0.0.22:3000 \
--token <REGISTRATION_TOKEN_AUS_SCHRITT_1> \
--name "zora-arm64-runner" \
--labels "ubuntu-latest:docker://node:20-bullseye"
# Ergebnis: .runner Datei im aktuellen Verzeichnis
ls -la .runner
```
> **Wichtig:** Den Runner-Config-Ordner festlegen:
```bash
mkdir -p ~/.gitea-runner
mv .runner ~/.gitea-runner/
```
#### Schritt 4: Systemd-Service anlegen
```bash
sudo tee /etc/systemd/system/gitea-runner.service > /dev/null <<'EOF'
[Unit]
Description=Gitea Actions Runner
After=docker.service
Requires=docker.service
[Service]
Type=simple
User=gitearun
WorkingDirectory=/home/gitearun/.gitea-runner
ExecStart=/usr/local/bin/act_runner daemon
Restart=always
RestartSec=5
Environment="HOME=/home/gitearun"
[Install]
WantedBy=multi-user.target
EOF
# Service aktivieren und starten
sudo systemctl daemon-reload
sudo systemctl enable --now gitea-runner
# Status prüfen
sudo systemctl status gitea-runner
```
**Erwartetes Ergebnis:**
```
● gitea-runner.service - Gitea Actions Runner
Active: active (running)
```
#### Schritt 5: Runner in Gitea bestätigen
Gitea Web-UI → **Site Administration → Actions → Runners**
Der Runner `zora-arm64-runner` muss als **Online** angezeigt werden.
### 2.4 Workflow-Workaround ablösen (optional, nach Verifikation)
Nach erfolgreichem Permanent-Fix kann der manuelle `config.json`-Schritt im Workflow
durch den Standard-`docker/login-action` ersetzt werden.
> **Hinweis:** Erst nach einem erfolgreichen Test-Run mit der neuen `daemon.json` durchführen.
Im Workflow (`.gitea/workflows/docker-publish.yaml`), den Schritt ersetzen:
```yaml
# ALT (Workaround):
- name: Registry-Credentials konfigurieren (kein Daemon-Kontakt)
run: |
mkdir -p ~/.docker
AUTH=$(echo -n "${{ secrets.REGISTRY_USER }}:${{ secrets.REGISTRY_TOKEN }}" | base64 -w 0)
printf '{"auths":{"%s":{"auth":"%s"}}}\n' "${{ env.REGISTRY_INTERNAL }}" "${AUTH}" > ~/.docker/config.json
# NEU (sauber, nach daemon.json-Fix):
- name: Login to Gitea Registry
uses: docker/login-action@v3
with:
registry: ${{ env.REGISTRY_INTERNAL }}
username: ${{ secrets.REGISTRY_USER }}
password: ${{ secrets.REGISTRY_TOKEN }}
```
---
## 3. Meldestelle-Host (VM 110 — `10.0.0.50`)
### 3.1 SSH-Verbindung
```bash
ssh user@10.0.0.50
```
### 3.2 Voraussetzungen prüfen
```bash
# Docker installiert?
docker --version # erwartet: Docker 27+
docker compose version # erwartet: v2.x
# Git installiert?
git --version # erwartet: 2.x
```
Falls Docker nicht installiert:
```bash
curl -fsSL https://get.docker.com | sh
sudo usermod -aG docker $USER
# Neu einloggen!
```
### 3.3 Git-Deployment einrichten
```bash
# Projektverzeichnis anlegen
mkdir -p ~/meldestelle && cd ~/meldestelle
# Git initialisieren und mit Gitea verknüpfen
git init
git remote add origin http://10.0.0.22:3000/mocode-software/meldestelle.git
# Neueste Konfiguration holen
git fetch origin
git reset --hard origin/main
# Deployment-Skript ausführbar machen
chmod +x config/scripts/deploy.sh
chmod +x config/scripts/backup.sh
```
### 3.4 Environment-Variablen konfigurieren
> **Status (06.03.2026):** `.env` ist befüllt, aber enthält noch **Placeholder-Passwörter**
> (`pg-password`, `kc-password`, `gf-password`). Diese **müssen** vor dem ersten Start
> durch starke Passwörter (min. 20 Zeichen) ersetzt werden!
```bash
nano .env
```
**Pflichtfelder für Production** (Konfig-Matrix beachten!):
```bash
# --- KEYCLOAK ---
KC_COMMAND=start --optimized --import-realm
KC_HOSTNAME=10.0.0.50
KC_HOSTNAME_STRICT=false
KC_HOSTNAME_STRICT_HTTPS=false
KC_ADMIN_PASSWORD=<SICHERES_PASSWORT_MIN_20_ZEICHEN>
KC_DB_PASSWORD=<SICHERES_PASSWORT_MIN_20_ZEICHEN>
KC_HEAP_MAX=4096m
# --- JWT ---
SPRING_SECURITY_OAUTH2_RESOURCESERVER_JWT_ISSUER_URI=http://10.0.0.50:8180/realms/meldestelle
SPRING_SECURITY_OAUTH2_RESOURCESERVER_JWT_JWK_SET_URI=http://keycloak:8080/realms/meldestelle/protocol/openid-connect/certs
# --- POSTGRES ---
POSTGRES_USER=meldestelle
POSTGRES_PASSWORD=<SICHERES_PASSWORT_MIN_20_ZEICHEN>
POSTGRES_DB=meldestelle
POSTGRES_SHARED_BUFFERS=16GB
POSTGRES_EFFECTIVE_CACHE_SIZE=48GB
# --- VALKEY ---
VALKEY_MAXMEMORY=4gb
VALKEY_PASSWORD=<SICHERES_PASSWORT>
# --- GRAFANA ---
GF_ADMIN_PASSWORD=<SICHERES_PASSWORT>
# --- BACKUP ---
BACKUP_DIR=/home/user/backups/meldestelle
BACKUP_RETENTION_DAYS=7
```
> **Wichtig:** `KC_HOSTNAME` darf auf dem Server **niemals** `localhost` sein!
> Ist Pangolin konfiguriert, kann `KC_HOSTNAME=auth.mo-code.at` gesetzt werden.
### 3.5 Interne Registry konfigurieren
Docker muss die Gitea-Registry intern (HTTP) kennen:
```bash
sudo tee /etc/docker/daemon.json > /dev/null <<'EOF'
{
"insecure-registries": ["10.0.0.22:3000"]
}
EOF
sudo systemctl restart docker
```
### 3.6 Images aus Registry pullen
```bash
cd ~/meldestelle
# Mit Gitea-Registry authentifizieren
docker login 10.0.0.22:3000 -u <REGISTRY_USER> -p <REGISTRY_TOKEN>
# Images pullen
docker pull 10.0.0.22:3000/mocode-software/meldestelle/keycloak:latest
docker pull 10.0.0.22:3000/mocode-software/meldestelle/api-gateway:latest
docker pull 10.0.0.22:3000/mocode-software/meldestelle/ping-service:latest
docker pull 10.0.0.22:3000/mocode-software/meldestelle/web-app:latest
```
### 3.7 Stack starten
```bash
cd ~/meldestelle
# Schritt 1: Infrastruktur (DB, Keycloak, Valkey, Consul)
docker compose -f dc-infra.yaml up -d
echo "Warte 30s auf Keycloak-Start..."
sleep 30
# Schritt 2: Backend (API-Gateway, Ping-Service)
docker compose -f dc-backend.yaml up -d
# Schritt 3: Ops (Prometheus, Grafana, Zipkin)
docker compose -f dc-ops.yaml up -d
```
### 3.8 Smoke-Tests
```bash
# 1. Keycloak Health
curl -s http://10.0.0.50:9000/health/ready | python3 -m json.tool
# Erwartet: {"status": "UP"}
# 2. Keycloak Admin-Dashboard erreichbar
curl -s -o /dev/null -w "%{http_code}" http://10.0.0.50:8180/admin/
# Erwartet: 200
# 3. API-Gateway Ping
curl -s http://10.0.0.50:8081/ping
# Erwartet: {"status":"UP"} o.ä.
# 4. Consul Service Discovery
curl -s http://10.0.0.50:8500/v1/agent/services | python3 -m json.tool
# Erwartet: api-gateway + ping-service registriert
# 5. Grafana erreichbar
curl -s -o /dev/null -w "%{http_code}" http://10.0.0.50:3000
# Erwartet: 200
```
### 3.9 Backup-Cron einrichten
```bash
# Backup-Verzeichnis anlegen
mkdir -p ~/backups/meldestelle
# Cron-Job: täglich um 02:00 Uhr
(crontab -l 2>/dev/null; echo "0 2 * * * /home/user/meldestelle/config/scripts/backup.sh >> /home/user/backups/meldestelle/backup.log 2>&1") | crontab -
# Verifizieren
crontab -l
```
---
## 4. Abschluss-Checkliste
> Stand 06.03.2026 — ✅ = erledigt, ❌ = offen
```
[✅] Gitea erreichbar (intern + extern via Pangolin)
[✅] Registry-Images (4x) vorhanden und aktuell
[✅] Org-Secrets REGISTRY_USER + REGISTRY_TOKEN gesetzt
[✅] VM 102: /etc/docker/daemon.json mit insecure-registries gesetzt
[❌] VM 102: act_runner Binary installiert (/usr/local/bin/act_runner)
[❌] VM 102: gitea-runner.service angelegt, enabled und active
[❌] VM 102: Runner in Gitea als "Online" sichtbar
[⚠️] VM 110: .env befüllt — Placeholder-Passwörter ersetzen!
[✅] VM 110: /etc/docker/daemon.json mit insecure-registries gesetzt (prüfen!)
[❌] VM 110: Stack gestartet (infra + backend + ops)
[❌] Keycloak Health: UP
[❌] Keycloak Admin-Dashboard: erreichbar
[❌] API-Gateway Ping: antwortet
[❌] Grafana: erreichbar
[❌] Backup-Cron: eingerichtet
```
---
## 5. Troubleshooting
### Keycloak startet nicht
```bash
docker logs meldestelle-keycloak --tail 50
```
- `start-dev` statt `start --optimized`? → `.env`: `KC_COMMAND=start --optimized --import-realm`
- `KC_HOSTNAME=localhost` auf Server? → `KC_HOSTNAME=10.0.0.50` setzen
### Docker-Pull schlägt fehl (x509/TLS)
```bash
# daemon.json prüfen
cat /etc/docker/daemon.json
docker info | grep -A5 "Insecure"
# Falls leer: daemon.json nochmals setzen + docker restart
```
### API-Gateway findet Keycloak nicht
```bash
# JWT_ISSUER_URI prüfen
docker exec meldestelle-api-gateway env | grep ISSUER
# Muss sein: http://10.0.0.50:8180/realms/meldestelle (Public)
# JWK_SET_URI muss sein: http://keycloak:8080/... (intern)
```
### Pipeline schlägt fehl (RAM-OOM)
- `max-parallel: 1` im Workflow prüfen — muss immer gesetzt sein auf VM 102 (16 GB RAM).

73
docs/99_Journal/2026-03-06_Session_Log_Zora_Konfiguration.md Normal file
View File

@ -0,0 +1,73 @@
---
type: Session Log
date: 2026-03-06
agent: DevOps Engineer + Curator
status: DONE
---
# Session Log: Zora — Vollständige Konfigurationsanalyse
## Ziel
Ist-Zustand aller drei Zora-Systeme (Gitea CT 101, Runner VM 102, Meldestelle-Host VM 110)
erfassen und ein vollständiges, ausführbares Konfigurationsrunbook erstellen.
---
## Erkenntnisse aus User-Feedback
### VM 102 (Gitea-Runner — `10.0.0.23`)
| Punkt | Status | Detail |
|:---|:---|:---|
| `daemon.json` | ✅ OK | `insecure-registries: ["10.0.0.22:3000"]` gesetzt und verifiziert |
| `gitea-runner.service` | ❌ FEHLT | Binary (`act_runner`) nie installiert — Service existiert nicht |
**Root Cause:** Der Gitea Actions Runner wurde bisher nur als Prozess gestartet (oder gar nicht),
nie als systemd-Service mit Binary aus den offiziellen `act_runner`-Releases eingerichtet.
### Gitea CT 101 (`10.0.0.22`)
| Punkt | Status |
|:---|:---|
| Registry-Packages (4x Images) | ✅ Vorhanden (Screenshot bestätigt) |
| Org-Secrets `REGISTRY_USER` + `REGISTRY_TOKEN` | ✅ Gesetzt (Screenshot bestätigt) |
### VM 110 (Meldestelle-Host — `10.0.0.50`)
| Punkt | Status | Detail |
|:---|:---|:---|
| `.env` befüllt | ⚠️ Teilweise | Echte Werte für Ports/Hostnamen OK, aber Passwörter sind noch Placeholder |
| `backup.sh` / `deploy.sh` | ✅ Vorhanden | Scripts korrekt implementiert |
| Stack gestartet | ❌ Offen | Erst nach Passwort-Fix starten |
**Kritisch:** `.env` enthält `pg-password`, `kc-password`, `gf-password` — **vor Stack-Start ersetzen!**
### Workflow `.gitea/workflows/docker-publish.yaml`
| Punkt | Status |
|:---|:---|
| `docker/login-action@v3` | ✅ Aktiv |
| Alter Workaround (config.json manuell) | ✅ Auskommentiert |
| `max-parallel: 1` (OOM-Schutz) | ✅ Gesetzt |
---
## Durchgeführte Änderungen
### `docs/07_Infrastructure/runbooks/zora-setup-runbook.md` (neu → erweitert)
- **Abschnitt 2** komplett überarbeitet: Ist-Status-Box, `daemon.json`-Verifikation als ✅-Schritt,
vollständiger `act_runner`-Installationsworkflow (5 Schritte: Token → Binary → Register → Service → Bestätigung).
- **Abschnitt 3.4**: Passwort-Warnung als prominenten Hinweis vor `nano .env`.
- **Abschnitt 4 (Checkliste)**: Echten Stand eingetragen (✅/❌/⚠️ statt alle offen).
---
## Offene Aufgaben (nächste Session)
```
[ ] VM 102: act_runner Binary laden (ARM64, v0.2.11)
[ ] VM 102: Runner bei Gitea registrieren (Token aus Admin-UI)
[ ] VM 102: gitea-runner.service anlegen + enable --now
[ ] VM 102: Runner in Gitea als "Online" bestätigen
[ ] VM 110: .env — Passwörter ersetzen (pg, kc, gf, valkey)
[ ] VM 110: Stack starten (dc-infra → dc-backend → dc-ops)
[ ] VM 110: Smoke-Tests (Keycloak Health, API-Gateway, Grafana)
[ ] VM 110: Backup-Cron einrichten
```
**Referenz:** `docs/07_Infrastructure/runbooks/zora-setup-runbook.md`