diff --git a/.gitignore b/.gitignore index 237b02c..75922dc 100644 --- a/.gitignore +++ b/.gitignore @@ -5,3 +5,5 @@ deploy/.env deploy/.env.* !deploy/.env.beispiel deploy/.vorige-version-* +deploy/data/ +deploy/.vorige-version diff --git a/CHANGELOG.md b/CHANGELOG.md index 8c77afd..bd44e20 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,10 @@ Neueste Version oben. Erste Zahl: großer Umbau, zweite: neue Funktionen, dritte: Fehlerbehebungen. +## 0.44.3 (04.11.2026) + +- Server: vorerst nur die Produktion, ohne Testumgebung. Daten in Ordnern statt Docker-Volumes: `deploy/data/db` (Datenbank) und `deploy/data/backup` (Sicherungen). `update.sh` kopiert vorhandene Daten aus den bisherigen Volumes einmalig herüber. Aufruf jetzt `./update.sh ` und `./zurueck.sh`. + ## 0.44.2 (04.11.2026) - Server: Caddy entfällt, TLS macht der vorhandene HAProxy. Die Produktion lauscht an 100.64.0.8:33181, die Testumgebung an 100.64.0.8:33182 (in `.env` änderbar: APP_ADRESSE, APP_PORT, TEST_PORT). diff --git a/README.md b/README.md index 57a0b41..8221981 100644 --- a/README.md +++ b/README.md @@ -36,20 +36,19 @@ Ohne Dev Container: Node 22 und PostgreSQL 16, dann `DATABASE_URL` und für die 1. Änderung im eigenen Zweig, Pull Request, Prüfung muss grün sein. 2. Nach dem Zusammenführen `CHANGELOG.md` ergänzen und einen Tag setzen: `git tag v1.0.0 && git push --tags`. 3. Auf dem Server baut `update.sh` das Image aus diesem Tag (git.deichnet.com), eine Registry ist nicht nötig. -4. Auf dem Server erst die Testumgebung, nach Freigabe die Produktion: +4. Auf dem Server (vorerst nur Produktion, ohne Testumgebung): ```sh cd deploy -./update.sh test 1.0.0 -./update.sh produktion 1.0.0 -./zurueck.sh produktion # falls etwas schiefgeht: vorige Version und Sicherung +./update.sh 1.0.0 +./zurueck.sh # falls etwas schiefgeht: vorige Version und Sicherung ``` ## Server einrichten (einmalig) -1. Server mit Docker und git; ein Reverse Proxy (HAProxy) mit TLS leitet Produktion und Test an die Ports aus `.env` weiter. +1. Server mit Docker und git; ein Reverse Proxy (HAProxy) mit TLS leitet an `APP_ADRESSE:APP_PORT` aus `.env` weiter. 2. Repository von git.deichnet.com auf den Server klonen, `deploy/.env.beispiel` nach `deploy/.env` kopieren und ausfüllen. -3. `cd deploy && ./update.sh test 0.43.0 && ./update.sh produktion 0.43.0` baut das Image und startet beide Umgebungen (`docker compose up -d`). HTTPS macht der vorhandene HAProxy; er erreicht die Apps an `APP_ADRESSE:APP_PORT` und `APP_ADRESSE:TEST_PORT` und setzt `X-Forwarded-Proto: https`. +3. `cd deploy && ./update.sh 0.44.3` baut das Image und startet Programm, Datenbank und Sicherung (`docker compose up -d`). Die Daten liegen in `deploy/data/db` und `deploy/data/backup`. HTTPS macht der vorhandene HAProxy; er setzt `X-Forwarded-Proto: https`. 4. Beim ersten Aufruf fragt das Programm nach dem Inhaber und dem Einrichtungscode (aus `.env` oder `docker compose logs app | grep Einrichtungscode`). Alle weiteren Zugänge legt der Inhaber unter „Benutzer“ an. Sicherung: jede Nacht und vor jedem Update, 30 Tage aufbewahrt, Kopie per WebDAV in die Nextcloud. diff --git a/deploy/.env.beispiel b/deploy/.env.beispiel index 26d65bd..6e15183 100644 --- a/deploy/.env.beispiel +++ b/deploy/.env.beispiel @@ -1,12 +1,10 @@ # Kopieren nach .env und ausfüllen. Die Datei bleibt nur auf dem Server. # Name des Images, das update.sh aus dem Git-Tag baut IMAGE=betrieb -APP_VERSION=0.43.0 -TEST_VERSION=0.43.0 -# Hier lauschen die Apps für den HAProxy (Adresse des Docker-Rechners im VPN) +APP_VERSION=0.44.3 +# Hier lauscht das Programm für den HAProxy (Adresse des Docker-Rechners im VPN) APP_ADRESSE=100.64.0.8 APP_PORT=33181 -TEST_PORT=33182 # Lang und zufällig, z. B. openssl rand -hex 24. Sonderzeichen sind erlaubt; enthält es ein $, den Wert in einfache Anführungszeichen setzen. DB_PASSWORT=bitte-lang-und-zufaellig # Code für die Einrichtung beim ersten Start (Inhaber anlegen). Leer lassen: das Programm diff --git a/deploy/docker-compose.yml b/deploy/docker-compose.yml index f2f39eb..56f0c59 100644 --- a/deploy/docker-compose.yml +++ b/deploy/docker-compose.yml @@ -1,45 +1,12 @@ -# Betrieb auf dem Server: Produktion und Testumgebung nebeneinander, -# jede mit eigener Datenbank und eigener Sicherung. TLS macht Hennings HAProxy (Henning, 04.11.2026): -# er erreicht die Apps über das VPN an APP_ADRESSE:APP_PORT bzw. TEST_PORT. +# Betrieb auf dem Server: Programm, Datenbank und Sicherung (vorerst ohne Testumgebung, Henning 04.11.2026). +# TLS macht Hennings HAProxy; er erreicht das Programm über das VPN an APP_ADRESSE:APP_PORT. +# Die Daten liegen in Ordnern neben dieser Datei: ./data/db (Datenbank) und ./data/backup (Sicherungen). # Start: docker compose up -d (Werte aus .env, Vorlage .env.beispiel) -x-app: &app - restart: unless-stopped - networks: [intern] - -x-db: &db - image: postgres:16-alpine - restart: unless-stopped - environment: - POSTGRES_USER: betrieb - POSTGRES_PASSWORD: ${DB_PASSWORT} - POSTGRES_DB: betrieb - healthcheck: - test: ["CMD", "pg_isready", "-U", "betrieb"] - interval: 5s - retries: 20 - networks: [intern] - -x-backup: &backup - build: ../backup - image: betrieb-backup - restart: unless-stopped - networks: [intern] - -x-backup-env: &backup-env - PGUSER: betrieb - PGPASSWORD: ${DB_PASSWORT} - PGDATABASE: betrieb - AUFBEWAHREN_TAGE: "30" - UHRZEIT: ${BACKUP_UHRZEIT:-02:30} - NEXTCLOUD_URL: ${NEXTCLOUD_URL:-} - NEXTCLOUD_BENUTZER: ${NEXTCLOUD_BENUTZER:-} - NEXTCLOUD_PASSWORT: ${NEXTCLOUD_PASSWORT:-} - services: app: - <<: *app image: ${IMAGE}:${APP_VERSION} + restart: unless-stopped ports: ["${APP_ADRESSE:-100.64.0.8}:${APP_PORT:-33181}:3000"] environment: DATABASE_URL: postgres://betrieb@db:5432/betrieb @@ -50,48 +17,41 @@ services: NEXTCLOUD_PASSWORT: ${NEXTCLOUD_PASSWORT:-} depends_on: db: { condition: service_healthy } + networks: [intern] + db: - <<: *db - volumes: [db:/var/lib/postgresql/data] - backup: - <<: *backup + image: postgres:16-alpine + restart: unless-stopped + environment: + POSTGRES_USER: betrieb + POSTGRES_PASSWORD: ${DB_PASSWORT} + POSTGRES_DB: betrieb + volumes: ["./data/db:/var/lib/postgresql/data"] + healthcheck: + test: ["CMD", "pg_isready", "-U", "betrieb"] + interval: 5s + retries: 20 + networks: [intern] + + backup: + build: ../backup + image: betrieb-backup + restart: unless-stopped environment: - <<: *backup-env PGHOST: db + PGUSER: betrieb + PGPASSWORD: ${DB_PASSWORT} + PGDATABASE: betrieb NAME: produktion - volumes: [sicherungen:/sicherungen] + AUFBEWAHREN_TAGE: "30" + UHRZEIT: ${BACKUP_UHRZEIT:-02:30} + NEXTCLOUD_URL: ${NEXTCLOUD_URL:-} + NEXTCLOUD_BENUTZER: ${NEXTCLOUD_BENUTZER:-} + NEXTCLOUD_PASSWORT: ${NEXTCLOUD_PASSWORT:-} + volumes: ["./data/backup:/sicherungen"] depends_on: db: { condition: service_healthy } - - app-test: - <<: *app - image: ${IMAGE}:${TEST_VERSION} - ports: ["${APP_ADRESSE:-100.64.0.8}:${TEST_PORT:-33182}:3000"] - environment: - DATABASE_URL: postgres://betrieb@db-test:5432/betrieb - PGPASSWORD: ${DB_PASSWORT} - EINRICHTUNGSCODE: ${EINRICHTUNGSCODE:-} - depends_on: - db-test: { condition: service_healthy } - db-test: - <<: *db - volumes: [db-test:/var/lib/postgresql/data] - backup-test: - <<: *backup - environment: - <<: *backup-env - PGHOST: db-test - NAME: test - NEXTCLOUD_URL: "" - volumes: [sicherungen-test:/sicherungen] - depends_on: - db-test: { condition: service_healthy } - -volumes: - db: - db-test: - sicherungen: - sicherungen-test: + networks: [intern] networks: intern: diff --git a/deploy/update.sh b/deploy/update.sh index 70a1c2c..736a737 100755 --- a/deploy/update.sh +++ b/deploy/update.sh @@ -1,29 +1,39 @@ #!/bin/sh # Neue Version einspielen: Image aus dem Git-Tag bauen, Sicherung, dann starten. # Migrationen laufen beim Start der App automatisch. -# ./update.sh test 1.1.0 Testumgebung -# ./update.sh produktion 1.1.0 Produktion (erst nach Freigabe in der Testumgebung) +# ./update.sh 0.44.3 set -eu cd "$(dirname "$0")" -umgebung="$1" -version="$2" -case "$umgebung" in - test) app=app-test; backup=backup-test; variable=TEST_VERSION ;; - produktion) app=app; backup=backup; variable=APP_VERSION ;; - *) echo "Umgebung: test oder produktion" >&2; exit 1 ;; -esac -alt=$(grep "^$variable=" .env | cut -d= -f2) -echo "$umgebung: Update von $alt auf $version" +# frühere Aufrufform „./update.sh produktion 0.44.3“ geht weiter +[ "${1:-}" = "produktion" ] && shift +version="${1:?Version angeben, z. B. ./update.sh 0.44.3}" +alt=$(grep "^APP_VERSION=" .env | cut -d= -f2) +echo "Update von $alt auf $version" image=$(grep "^IMAGE=" .env | cut -d= -f2) git fetch --tags origin if ! docker image inspect "$image:$version" >/dev/null 2>&1; then git -C .. archive "v$version" | docker build ${BUILD_OPTS:-} -t "$image:$version" --build-arg APP_VERSION="$version" - fi # Bei der ersten Einrichtung läuft noch nichts, dann gibt es auch nichts zu sichern. -if [ -n "$(docker compose ps -q --status running "$backup")" ]; then - docker compose exec -T "$backup" sicherung vor-update +if [ -n "$(docker compose ps -q --status running backup)" ]; then + docker compose exec -T backup sicherung vor-update fi -echo "$alt" > ".vorige-version-$umgebung" -sed -i "s/^$variable=.*/$variable=$version/" .env -docker compose up -d --remove-orphans "$app" "$backup" -echo "Fertig. Zurück mit: ./zurueck.sh $umgebung" +mkdir -p data/db data/backup +# Umstellung von Docker-Volumes auf ./data (0.44.3): vorhandene Daten einmalig herüberkopieren, die Volumes bleiben stehen +projekt=${COMPOSE_PROJECT_NAME:-$(basename "$PWD")} +umziehen() { + if [ -z "$(ls -A "data/$2")" ] && docker volume inspect "${projekt}_$1" >/dev/null 2>&1; then + echo "Kopiere Volume ${projekt}_$1 nach data/$2" + docker run --rm -v "${projekt}_$1:/von:ro" -v "$PWD/data/$2:/nach" postgres:16-alpine sh -c 'cp -a /von/. /nach/' + fi +} +if [ -z "$(ls -A data/db)" ] && docker volume inspect "${projekt}_db" >/dev/null 2>&1; then + docker compose stop >/dev/null 2>&1 || true + docker stop "${projekt}-db-1" >/dev/null 2>&1 || true + umziehen db db + umziehen sicherungen backup +fi +echo "$alt" > .vorige-version +sed -i "s/^APP_VERSION=.*/APP_VERSION=$version/" .env +docker compose up -d --remove-orphans +echo "Fertig. Zurück mit: ./zurueck.sh" diff --git a/deploy/zurueck.sh b/deploy/zurueck.sh index ac0e00a..7438ba3 100755 --- a/deploy/zurueck.sh +++ b/deploy/zurueck.sh @@ -1,19 +1,13 @@ #!/bin/sh # Rückkehr zur vorigen Version und zur Sicherung vor dem letzten Update. -# ./zurueck.sh produktion +# ./zurueck.sh set -eu cd "$(dirname "$0")" -umgebung="$1" -case "$umgebung" in - test) app=app-test; backup=backup-test; variable=TEST_VERSION ;; - produktion) app=app; backup=backup; variable=APP_VERSION ;; - *) echo "Umgebung: test oder produktion" >&2; exit 1 ;; -esac -vorige=$(cat ".vorige-version-$umgebung") -sicherung=$(docker compose exec -T "$backup" sh -c 'ls -t /sicherungen/*_vor-update.dump | head -1' | tr -d '\r') -echo "$umgebung: zurück auf $vorige mit Sicherung $sicherung" -docker compose stop "$app" -docker compose exec -T "$backup" pg_restore --clean --if-exists --no-owner -d betrieb "$sicherung" -sed -i "s/^$variable=.*/$variable=$vorige/" .env -docker compose up -d "$app" +vorige=$(cat .vorige-version) +sicherung=$(docker compose exec -T backup sh -c 'ls -t /sicherungen/*_vor-update.dump | head -1' | tr -d '\r') +echo "Zurück auf $vorige mit Sicherung $sicherung (liegt auch unter ./data/backup)" +docker compose stop app +docker compose exec -T backup pg_restore --clean --if-exists --no-owner -d betrieb "$sicherung" +sed -i "s/^APP_VERSION=.*/APP_VERSION=$vorige/" .env +docker compose up -d app echo "Fertig." diff --git a/package.json b/package.json index cb45fd0..5608459 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "betrieb", - "version": "0.44.2", + "version": "0.44.3", "private": true, "description": "Betriebsführungsprogramm Schaarschmidt Holzbau", "type": "module",