#!/usr/bin/env bash # dxEvent 2 – Eventbox auf einem Intel NUC (oder anderem x86-Rechner) einrichten. Anleitung: docs/eventbox-nuc.md # # Einzeiler auf einem frisch installierten Debian 13 (oder 12), als root (`su -`): # # wget -qO- https://install.dxevent.ch | bash # # install.dxevent.ch zeigt auf die Demo; jede dxEvent-Instanz liefert dieses Skript auch unter /installieren.sh aus, # mit docker-compose.yml und update.sh eingebettet und ihrer eigenen Version als Vorgabe. Fehlende Angaben fragt es # im Terminal nach. # Angaben als Argumente (… | bash -s -- --box 3 --usv) oder aus der Umgebung (für den Installer aus dxIT): # --box N / DXEVENT_BOX Nummer der Box: eventNN.dxevent.ch, Netz 10.0.(49+N).0/24, Box .10, Router .1 # --dxit-url URL / DXEVENT_DXIT_URL, --dxit-token T / DXEVENT_DXIT_TOKEN # dxIT (Erweiterung dxb.eventboxen): Fernwartung, Cloud-Sicherung, WLAN, Vorlagen # REGISTRY_TOKEN Token des Kontos dx-registry-pull (sonst Rückfrage) # DXEVENT_ADMIN_PASSWORT Passwort des ersten Admins (sonst Rückfrage, leer = zufällig) # --usv --version --keepalive host:port --ip --router --praefix --schnittstelle --ja # --nur-dateien nur die Dateien erzeugen, nichts am System ändern (Probe) # # Was es tut: Rechnername und feste IP, Zeitzone, Docker aus der offiziellen Quelle, dnsmasq als lokales DNS # (eventNN.dxevent.ch → IP der Box, alles andere an den Router), Docker-DNS auf die Box, automatische # Sicherheitsupdates, kein Ruhezustand, /opt/dxevent mit docker-compose.yml und .env (Schlüssel neu erzeugt), # Auto-Update (update.sh), Keepalive, Anmeldung an der Registry, Start. DHCP macht der Router (Option 6 = Box). # Mehrfach ausführbar: eine bestehende .env (Schlüssel!) bleibt erhalten, nur --version setzt DX_VERSION. set -euo pipefail # Alles steckt in haupt(), aufgerufen in der letzten Zeile: bei «wget … | bash» liest Bash das Skript aus der Pipe; # so ist es ganz gelesen, bevor etwas läuft, und kein Befehl verschluckt den Rest. haupt() { # Eingebettet von tools/eventbox/paket.mjs: inhalt_compose() { cat <<'DXEVENT_COMPOSE_ENDE' # Eventbox (P10.5): ein Dienst, TLS in der App, Daten im Volume. Werte in .env (Beispiel: .env.example). # Start: docker compose up -d Update: DX_VERSION in .env ändern, docker compose pull && docker compose up -d # DX_VERSION = voller Commit eines vom Deployer gebauten Images (docs/auslieferung.md); «main» = jeweils neuster Bau. services: dxevent: image: git.dxb.ch/dxb/dxevent:${DX_VERSION:-main} restart: unless-stopped env_file: .env environment: DXEVENT_DATEN: /daten DXEVENT_UPDATE: /update DXEVENT_TLS: ${DXEVENT_TLS:-an} PORT: 80 PORT_HTTPS: 443 ports: - '80:80' - '443:443' # Ports unter 1024 ohne Root-Rechte im Container (Docker setzt das ab 20.10 meist selbst). sysctls: net.ipv4.ip_unprivileged_port_start: 0 # apcupsd läuft auf dem Rechner der Box: in den Einstellungen als USV-Host «host.docker.internal» eintragen. extra_hosts: - 'host.docker.internal:host-gateway' volumes: - dxevent-daten:/daten # Auto-Update: die App legt hier den Auftrag ab, update.sh auf dem Rechner der Box führt ihn aus # (tools/eventbox/installieren.sh richtet beides ein; ohne die Datei «bereit» ist das Update im Admin aus). - ./update:/update # Wahlweise: USB-Stick für die Kopie der Sicherungen (Einstellung sicherung.pfad = /usb). # - /media/usb/dxevent:/usb # Wahlweise: Ordner, den das bestehende Abholskript mit fullchain.pem/privkey.pem befüllt (Quelle «datei»). # - /etc/dxevent/zert:/zert-eingang:ro stop_grace_period: 30s volumes: dxevent-daten: DXEVENT_COMPOSE_ENDE } inhalt_update() { cat <<'DXEVENT_UPDATE_ENDE' #!/usr/bin/env bash # dxEvent 2 – Update der Eventbox ausführen (auf dem Rechner der Box, als root; Anleitung: docs/eventbox-nuc.md). # # Die App legt einen Auftrag in /opt/dxevent/update/auftrag (im Container /update/auftrag), ausgelöst im Admin unter # «System» oder von dxIT. systemd (dxevent-update.path) startet dann dieses Skript. Es zieht das Image der neuen # Version, setzt DX_VERSION in .env, startet neu und prüft /health auf den neuen Commit. Startet die neue Version nicht, # stellt es auf die bisherige zurück. Den Stand schreibt es nach update/stand.json; die App zeigt ihn und meldet ihn an # dxIT. Die Sicherung vor dem Update macht die App, bevor sie den Auftrag schreibt. # # Auftrag (Textdatei): version=, id=, quelle=box|dxit # Umgebung (nur für Tests): DXEVENT_ORDNER (Vorgabe /opt/dxevent), DXEVENT_HEALTH_URL, DXEVENT_WARTEN_SEK set -euo pipefail ORDNER="${DXEVENT_ORDNER:-/opt/dxevent}" U="$ORDNER/update" AUFTRAG="$U/auftrag" HEALTH="${DXEVENT_HEALTH_URL:-http://127.0.0.1/health}" WARTEN="${DXEVENT_WARTEN_SEK:-180}" [ -f "$AUFTRAG" ] || exit 0 # Nie zwei Updates gleichzeitig. exec 9>"$U/.sperre" flock -n 9 || exit 0 [ -f "$AUFTRAG" ] || exit 0 inhalt=$(cat "$AUFTRAG") rm -f "$AUFTRAG" wert() { printf '%s\n' "$inhalt" | sed -n "s/^$1=//p" | head -1 | tr -d '\r'; } NEU=$(wert version) ID=$(wert id) QUELLE=$(wert quelle) [[ "$ID" =~ ^[A-Za-z0-9._-]{1,64}$ ]] || ID=unbekannt [[ "$QUELLE" =~ ^(box|dxit)$ ]] || QUELLE=box ALT=$(sed -n 's/^DX_VERSION=//p' "$ORDNER/.env" | head -1 | tr -d '\r"') [[ "$ALT" =~ ^[A-Za-z0-9._-]{1,64}$ ]] || ALT=main stand() { local t t=$(mktemp "$U/.stand.XXXXXX") printf '{"zustand":"%s","id":"%s","quelle":"%s","von":"%s","nach":"%s","meldung":"%s","am":%s}\n' \ "$1" "$ID" "$QUELLE" "$ALT" "$NEU_SICHER" "$2" "$(($(date +%s) * 1000))" >"$t" chmod 644 "$t" mv -f "$t" "$U/stand.json" } NEU_SICHER="$NEU" [[ "$NEU" =~ ^[0-9a-f]{40}$ ]] || { NEU_SICHER=ungueltig stand fehler "Ungültige Version (erwartet ein voller Commit)." exit 0 } if [ "$NEU" = "$ALT" ]; then stand fertig "Diese Version läuft bereits." exit 0 fi setze_version() { if grep -q '^DX_VERSION=' "$ORDNER/.env"; then sed -i "s/^DX_VERSION=.*/DX_VERSION=$1/" "$ORDNER/.env" else echo "DX_VERSION=$1" >>"$ORDNER/.env" fi } # Läuft die Version? Bei einem Commit muss /health genau ihn melden, bei «main» genügt «ok». gesund() { local muster='"status":"ok"' [[ "$1" =~ ^[0-9a-f]{40}$ ]] && muster="\"commit\":\"$1\"" local ende=$(($(date +%s) + WARTEN)) while [ "$(date +%s)" -le "$ende" ]; do curl -fsS -m 3 "$HEALTH" 2>/dev/null | grep -q "$muster" && return 0 sleep 3 done return 1 } cd "$ORDNER" stand laeuft "Die neue Version wird geladen." if ! DX_VERSION="$NEU" docker compose pull -q >"$U/update.log" 2>&1; then stand fehler "Die Version ist nicht ladbar (Registry oder Internet). Es wurde nichts geändert." exit 0 fi stand laeuft "Die neue Version startet." setze_version "$NEU" docker compose up -d >>"$U/update.log" 2>&1 || true if gesund "$NEU"; then docker image prune -f >/dev/null 2>&1 || true stand fertig "Aktualisiert." exit 0 fi setze_version "$ALT" docker compose up -d >>"$U/update.log" 2>&1 || true if gesund "$ALT"; then stand zurueckgestellt "Die neue Version startete nicht; die Box läuft wieder mit der bisherigen." else stand fehler "Die neue Version startete nicht und die bisherige ebenfalls nicht: Sicherung von vor dem Update einspielen." fi DXEVENT_UPDATE_ENDE } # Version, die eine Instanz beim Ausliefern einsetzt (ihr eigener Commit); leer = «main». VERSION_VORGABE="bbe561f4b1b13b97dac7b479c5928242541a05bd" DOMAIN=dxevent.ch ZIEL=/opt/dxevent REGISTRY=git.dxb.ch REGISTRY_BENUTZER=dx-registry-pull BOX="${DXEVENT_BOX:-}" # dxIT der dxb GmbH (Erweiterung dxb.eventboxen), wenn nur ein Token angegeben ist. DXIT_VORGABE="https://dxb.dxit.ch/api/erweiterungen-eingang/dxb.eventboxen" DXIT_URL="${DXEVENT_DXIT_URL:-}" DXIT_TOKEN="${DXEVENT_DXIT_TOKEN:-}" IP="" ROUTER="" PRAEFIX=24 VERSION="" USV=0 JA=0 NUR_DATEIEN="" SCHNITTSTELLE="" # Keepalive durch das VPN: Caddy des Deployers im Netz der dxb (hält den Tunnel offen, damit eventNN.dxevent.ch # von aussen erreichbar bleibt). Leer mit --keepalive "" schaltet ihn aus; im Admin unter «Netz» änderbar. KEEPALIVE="10.0.20.5:443" fehler() { echo "FEHLER: $*" >&2 exit 1 } schritt() { echo; echo "==> $*"; } hilfe() { cat <<'HILFE' dxEvent 2 – Eventbox einrichten (Debian 12/13, als root). wget -qO- https://install.dxevent.ch | bash … | bash -s -- --box 3 [--usv] [--version ] [--keepalive host:port] [--dxit-url URL --dxit-token T] Weitere: --ip --router --praefix --schnittstelle --ja --nur-dateien (nur Dateien, nichts ändern). Umgebung: DXEVENT_BOX, DXEVENT_DXIT_URL, DXEVENT_DXIT_TOKEN, REGISTRY_TOKEN, DXEVENT_ADMIN_PASSWORT. Anleitung: docs/eventbox-nuc.md im Repo dxEvent2. HILFE exit "${1:-0}" } # Rückfragen kommen vom Terminal, nicht aus der Pipe (stdin ist bei «… | bash» das Skript selbst). frage() { [ -r /dev/tty ] || fehler "Keine Rückfrage möglich (kein Terminal): Angaben als Argumente oder Umgebung mitgeben." read -r "$@" &2; hilfe 2 ;; esac done # ---- Werte ableiten und prüfen ---------------------------------------------------------------------------------- if [ -z "$BOX" ] && [ -z "$NUR_DATEIEN" ]; then frage -p "Nummer der Box (1–99, z. B. 3 für event03): " BOX fi [[ "$BOX" =~ ^[0-9]{1,2}$ ]] && [ "$BOX" -ge 1 ] && [ "$BOX" -le 99 ] || fehler "--box 1 bis 99 angeben (Nummer der Box)." BOX=$((10#$BOX)) NAME=$(printf 'event%02d' "$BOX") FQDN="$NAME.$DOMAIN" NETZ="10.0.$((49 + BOX))" IP="${IP:-$NETZ.10}" ROUTER="${ROUTER:-$NETZ.1}" ip_ok() { [[ "$1" =~ ^([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})$ ]] && for t in "${BASH_REMATCH[@]:1}"; do [ "$t" -le 255 ] || return 1; done; } ip_ok "$IP" || fehler "IP der Box ungültig: $IP" ip_ok "$ROUTER" || fehler "IP des Routers ungültig: $ROUTER" [[ "$PRAEFIX" =~ ^[0-9]{1,2}$ ]] && [ "$PRAEFIX" -ge 8 ] && [ "$PRAEFIX" -le 30 ] || fehler "--praefix 8 bis 30" [ -z "$KEEPALIVE" ] || [[ "$KEEPALIVE" =~ ^[^[:space:]:]+:[0-9]{1,5}$ ]] || fehler "--keepalive host:port" [ -z "$VERSION" ] || [[ "$VERSION" =~ ^([0-9a-f]{40}|main)$ ]] || fehler "--version: voller Commit (40 Zeichen) oder main" VERSION_NEU="${VERSION:-${VERSION_VORGABE:-main}}" DXIT_URL="${DXIT_URL%/}" [ -z "$DXIT_URL" ] || [[ "$DXIT_URL" =~ ^https://[^[:space:]]+$ ]] || fehler "--dxit-url muss mit https:// beginnen" pruefe_dxit_token() { [ -z "$DXIT_TOKEN" ] || [[ "$DXIT_TOKEN" =~ ^[A-Za-z0-9_.-]{10,200}$ ]] || fehler "Token aus dxIT ungültig" # Mit Token ohne Adresse: dxIT der dxb GmbH. [ -z "$DXIT_TOKEN" ] || DXIT_URL="${DXIT_URL:-$DXIT_VORGABE}" } pruefe_dxit_token zufall_hex() { head -c "$1" /dev/urandom | od -An -tx1 | tr -d ' \n'; } # ---- Inhalte der Dateien ---------------------------------------------------------------------------------------- dnsmasq_conf() { cat </dev/null && pwd || pwd)" quelle() { local name="$1" funktion="$2" k for k in "$HIER/$name" "$HIER/../../$name"; do [ -f "$k" ] && { cat "$k"; return 0; } done declare -F "$funktion" >/dev/null || fehler "$name fehlt (neben dieses Skript legen oder den Einzeiler nehmen)." "$funktion" } # ---- Nur Dateien (Probe, Tests) -------------------------------------------------------------------------------- if [ -n "$NUR_DATEIEN" ]; then mkdir -p "$NUR_DATEIEN" dnsmasq_conf >"$NUR_DATEIEN/dnsmasq-dxevent.conf" interfaces_datei "${SCHNITTSTELLE:-eno1}" >"$NUR_DATEIEN/interfaces" resolv_datei >"$NUR_DATEIEN/resolv.conf" docker_daemon >"$NUR_DATEIEN/daemon.json" echo "$IP $FQDN $NAME" >"$NUR_DATEIEN/hosts-zeile" [ -f "$NUR_DATEIEN/env" ] || env_datei "$(zufall_hex 12)" >"$NUR_DATEIEN/env" [ "$USV" = 1 ] && apcupsd_conf >"$NUR_DATEIEN/apcupsd.conf" update_path >"$NUR_DATEIEN/dxevent-update.path" update_service >"$NUR_DATEIEN/dxevent-update.service" quelle docker-compose.yml inhalt_compose >"$NUR_DATEIEN/docker-compose.yml" quelle update.sh inhalt_update >"$NUR_DATEIEN/update.sh" echo "Dateien für $FQDN ($IP, Router $ROUTER) in $NUR_DATEIEN" exit 0 fi # ---- Voraussetzungen ------------------------------------------------------------------------------------------- [ "$(id -u)" = 0 ] || fehler "Bitte als root ausführen (su -)." # In einer Unter-Shell lesen: os-release setzt selbst VERSION (würde --version überschreiben). OS_ID=$(. /etc/os-release && echo "${ID:-}") OS_VERSION_ID=$(. /etc/os-release && echo "${VERSION_ID:-}") OS_CODENAME=$(. /etc/os-release && echo "${VERSION_CODENAME:-}") OS_NAME=$(. /etc/os-release && echo "${PRETTY_NAME:-unbekannt}") [ "$OS_ID" = debian ] && [[ "$OS_VERSION_ID" =~ ^(12|13)$ ]] || fehler "Nur für Debian 12 oder 13 gebaut (gefunden: $OS_NAME)." COMPOSE_INHALT=$(quelle docker-compose.yml inhalt_compose) UPDATE_INHALT=$(quelle update.sh inhalt_update) if [ -z "$SCHNITTSTELLE" ]; then SCHNITTSTELLE=$(ip -o -4 route show default 2>/dev/null | awk '{print $5; exit}') [ -n "$SCHNITTSTELLE" ] || SCHNITTSTELLE=$(ls /sys/class/net | grep -E '^(en|eth)' | head -1 || true) fi [ -n "$SCHNITTSTELLE" ] && [ -e "/sys/class/net/$SCHNITTSTELLE" ] || fehler "Netzwerkschnittstelle nicht gefunden (--schnittstelle)." JETZT_IP=$(ip -o -4 addr show dev "$SCHNITTSTELLE" 2>/dev/null | awk '{print $4; exit}' | cut -d/ -f1) # Neue Box ohne Token: einmal nachfragen (über das Terminal, nicht auf der Befehlszeile: kein Eintrag im Verlauf). if [ -z "$DXIT_TOKEN" ] && [ "$JA" != 1 ] && [ ! -f "$ZIEL/.env" ]; then frage -s -p "Token der Box aus dxIT (Eventboxen → $NAME → «Token erzeugen»; leer = ohne dxIT): " DXIT_TOKEN echo pruefe_dxit_token fi cat <>/etc/hosts timedatectl set-timezone Europe/Zurich schritt "Pakete" export DEBIAN_FRONTEND=noninteractive apt-get update -q apt-get install -y -q ca-certificates curl gnupg dnsmasq unattended-upgrades systemd-timesyncd [ "$USV" = 1 ] && apt-get install -y -q apcupsd systemctl enable --now systemd-timesyncd schritt "Docker aus der offiziellen Quelle" if ! command -v docker >/dev/null || ! docker compose version >/dev/null 2>&1; then install -m 0755 -d /etc/apt/keyrings curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc chmod a+r /etc/apt/keyrings/docker.asc echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/debian $OS_CODENAME stable" \ >/etc/apt/sources.list.d/docker.list apt-get update -q apt-get install -y -q docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin fi mkdir -p /etc/docker docker_daemon >/etc/docker/daemon.json systemctl enable docker systemctl restart docker schritt "Lokales DNS (dnsmasq): $FQDN → $IP" dnsmasq_conf >/etc/dnsmasq.d/dxevent.conf dnsmasq --test systemctl enable dnsmasq systemctl restart dnsmasq rm -f /etc/resolv.conf resolv_datei >/etc/resolv.conf if [ "$USV" = 1 ]; then schritt "USV (apcupsd)" apcupsd_conf >/etc/apcupsd/apcupsd.conf [ -f /etc/default/apcupsd ] && sed -i 's/^ISCONFIGURED=.*/ISCONFIGURED=yes/' /etc/default/apcupsd systemctl enable apcupsd systemctl restart apcupsd fi schritt "Kein Ruhezustand, automatische Sicherheitsupdates" systemctl mask sleep.target suspend.target hibernate.target hybrid-sleep.target >/dev/null cat >/etc/apt/apt.conf.d/20auto-upgrades <<'EOF' APT::Periodic::Update-Package-Lists "1"; APT::Periodic::Unattended-Upgrade "1"; EOF # ---- dxEvent 2 ------------------------------------------------------------------------------------------------- schritt "dxEvent 2 in $ZIEL" mkdir -p "$ZIEL" printf '%s\n' "$COMPOSE_INHALT" >"$ZIEL/docker-compose.yml" chmod 644 "$ZIEL/docker-compose.yml" NEUES_PASSWORT="" if [ -f "$ZIEL/.env" ]; then echo "Bestehende .env bleibt (Schlüssel unverändert)." [ -n "$VERSION" ] && sed -i "s/^DX_VERSION=.*/DX_VERSION=$VERSION/" "$ZIEL/.env" else admin="${DXEVENT_ADMIN_PASSWORT:-}" if [ -z "$admin" ] && [ "$JA" != 1 ]; then frage -s -p "Passwort für den Benutzer admin (mindestens 10 Zeichen, leer = zufällig): " admin echo fi if [ -z "$admin" ]; then admin=$(zufall_hex 10) NEUES_PASSWORT="$admin" fi [ "${#admin}" -ge 10 ] || fehler "Das Admin-Passwort braucht mindestens 10 Zeichen." (umask 077 && env_datei "$admin" >"$ZIEL/.env") fi chmod 600 "$ZIEL/.env" schritt "Auto-Update (Auftrag aus dem Admin oder von dxIT)" printf '%s\n' "$UPDATE_INHALT" >"$ZIEL/update.sh" chmod 755 "$ZIEL/update.sh" # Der Ordner ist im Container /update; die App (Benutzer node, UID 1000) schreibt dort den Auftrag. install -d -m 755 -o 1000 -g 1000 "$ZIEL/update" echo "updater=1" >"$ZIEL/update/bereit" update_path >/etc/systemd/system/dxevent-update.path update_service >/etc/systemd/system/dxevent-update.service systemctl daemon-reload systemctl enable --now dxevent-update.path schritt "Registry $REGISTRY" if ! grep -q "\"$REGISTRY\"" /root/.docker/config.json 2>/dev/null; then token="${REGISTRY_TOKEN:-}" [ -n "$token" ] || { frage -s -p "Token des Kontos $REGISTRY_BENUTZER (Passwortsafe): " token; echo; } printf '%s' "$token" | docker login "$REGISTRY" -u "$REGISTRY_BENUTZER" --password-stdin fi schritt "Start" cd "$ZIEL" docker compose pull docker compose up -d # ---- Feste IP -------------------------------------------------------------------------------------------------- interfaces_datei "$SCHNITTSTELLE" >/etc/network/interfaces NEUSTART=0 [ "$JETZT_IP" = "$IP" ] || NEUSTART=1 # ---- Prüfen ---------------------------------------------------------------------------------------------------- schritt "Prüfen" for _ in $(seq 1 30); do curl -fsS -m 3 http://127.0.0.1/health >/dev/null 2>&1 && break; sleep 2; done echo "Health: $(curl -fsS -m 3 http://127.0.0.1/health 2>/dev/null || echo 'noch keine Antwort')" echo "DNS: $FQDN → $(getent ahostsv4 "$FQDN" | awk '{print $1; exit}') (erwartet $IP)" cat <