apt update && apt upgrade -y && apt install curl

curl -sSL https://install.pi-hole.net | bash

Für den Anfang ok aber wird dann nach einiger Zeit auf (2) Hide domains and clients umgestellt, da ein absolut Anonymer Service wichtig ist.

Adminpasswort am besten gleich ändern.

pihole -a -p

Als erstes bekommt jede VM eine statische IP Adresse:

sudo nano /etc/netplan/50-cloud-init.yaml

network:
  version: 2
  renderer: networkd
  ethernets:
    ens18:
      dhcp4: false
      addresses:
        - 10.10.0.10/24
      routes:
        - to: default
          via: 10.10.0.1
      nameservers:
        addresses:
          - 8.8.8.8
          - 8.8.4.4

sudo chmod 600 /etc/netplan/50-cloud-init.yaml
sudo rm -r /etc/netplan/00-installer-config.yaml
sudo netplan apply

Passwordless Login

Ich habe einen SSH Key auf meinem Notebook erstellt um mich ohne Passwort auf meinen Servern einzuloggen.

scp -R id_ed25519.pub mschneider@10.10.0.10:/home/mschneider/

Auf meiner PVE Maschine einloggen.

mkdir -p ~/.ssh
cat id_ed25519.pub >> .ssh/authorized_keys
chmod 700 ~/.ssh
chmod 600 ~/.ssh/authorized_keys

Auf PVE VIM installieren und einige SSH Einstellungen durchführen

sudo vim /etc/ssh/sshd_config

Zum kopieren

PermitRootLogin prohibit-password
PasswordAuthentication no
PubkeyAuthentication yes
AuthorizedKeysFile .ssh/authorized_keys

sudo apt install -y ca-certificates curl gnupg

Updates durchführen

sudo apt update && sudo apt upgrade -y

Docker installieren

sudo apt install -y ca-certificates curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | \
  sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

echo "deb [arch=$(dpkg --print-architecture) \
  signed-by=/etc/apt/keyrings/docker.gpg] \
  https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin

sudo usermod -aG docker mschneider

4TB Datastorage einrichten

Mit diesen Befehlen wird nachgesehen welchen Laufwerksnamen der 4TB Storage hat und ein Filesystem damit erstellt.

lsblk

sudo mkfs.ext4 /dev/sdb

Ein Mount Verzeichnis und automatischer Mount wird nun erstellt.

sudo mkdir -p /mnt/nextcloud-data
sudo mount /dev/sdb /mnt/nextcloud-data

Die UUID kopieren

sudo blkid /dev/sdb

sudo nano /etc/fstab

Folgende Zeile mit der UUID versehen und in die FSTAB schreiben

UUID=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx  /mnt/nextcloud-data  ext4  defaults  0  2

Kontrolliert kann es mit folgenden Befehl werden.

df -h | grep nextcloud

Nextcloud Data Verzeichnis erstellen

Nun wird alles für Docker vorbereitet.

sudo mkdir -p /mnt/nextcloud-data/data
sudo mkdir -p /mnt/nextcloud-data/db

sudo chown -R mschneider:mschneider /mnt/nextcloud-data

Docker Compose Verzeichnis erstellen

mkdir -p ~/nextcloud
nano ~/nextcloud/docker-compose.yml

services:
  db:
    image: mariadb:10.11
    container_name: nextcloud-db
    restart: always
    command: --transaction-isolation=READ-COMMITTED --log-bin=binlog --binlog-format=ROW
    volumes:
      - /mnt/nextcloud-data/db:/var/lib/mysql
    environment:
      - MYSQL_ROOT_PASSWORD=rootPasswortAendern
      - MYSQL_DATABASE=nextcloud
      - MYSQL_USER=nextcloud
      - MYSQL_PASSWORD=nextcloudPasswortAendern

  redis:
    image: redis:alpine
    container_name: nextcloud-redis
    restart: always

  app:
    image: nextcloud:latest
    container_name: nextcloud-app
    restart: always
    ports:
      - "8080:80"
    volumes:
      - /mnt/nextcloud-data/data:/var/www/html
    environment:
      - MYSQL_HOST=db
      - MYSQL_DATABASE=nextcloud
      - MYSQL_USER=nextcloud
      - MYSQL_PASSWORD=nextcloudPasswortAendern
      - REDIS_HOST=redis
      - NEXTCLOUD_TRUSTED_DOMAINS=cloud.techdoc.at 10.10.0.10
      - NEXTCLOUD_ADMIN_USER=admin
      - NEXTCLOUD_ADMIN_PASSWORD=adminPasswortAendern
    depends_on:
      - db
      - redis

Nextcloud verwalten

Nun wird Nextcloud gestartet

cd ~/nextcloud
docker compose up -d

Logs auslesen

docker compose logs -f

docker compose logs db

docker compose logs app

Docker abdrehen

docker compose down

Traefik einrichten

Traefik einrichten um Letsencrypt und HA Proxy funktionen für Docker zu haben

cd ~/nextcloud

Nextcloud stoppen da wir verwaltung zukünftig nur über Traefik läuft.

docker compose down

Alle Daten löschen da noch nichts eingerichtet wurde.

sudo rm -rf /mnt/nextcloud-data/db/*
sudo rm -rf /mnt/nextcloud-data/data/*
sudo mv docker-compose.yml ..

Nun wird eine neue Datei erstellt.

sudo vi docker-compose.yml

Hier müssen folgende Werte angepasst werden.
deine@email.at → deine echte Email für Let’s Encrypt
rootPasswortAendern → sicheres Passwort
nextcloudPasswortAendern → sicheres Passwort
adminPasswortAendern → dein Nextcloud Admin Passwort

services:
  traefik:
    image: traefik:v2.11
    container_name: traefik
    restart: always
    command:
      - "--api.insecure=false"
      - "--providers.docker=true"
      - "--providers.docker.exposedbydefault=false"
      - "--entrypoints.web.address=:80"
      - "--entrypoints.websecure.address=:443"
      - "--entrypoints.web.http.redirections.entrypoint.to=websecure"
      - "--entrypoints.web.http.redirections.entrypoint.scheme=https"
      - "--certificatesresolvers.letsencrypt.acme.httpchallenge=true"
      - "--certificatesresolvers.letsencrypt.acme.httpchallenge.entrypoint=web"
      - "--certificatesresolvers.letsencrypt.acme.email=deine@email.at"
      - "--certificatesresolvers.letsencrypt.acme.storage=/letsencrypt/acme.json"
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - traefik-letsencrypt:/letsencrypt
    networks:
      - proxy

  db:
    image: mariadb:10.11
    container_name: nextcloud-db
    restart: always
    command: --transaction-isolation=READ-COMMITTED --log-bin=binlog --binlog-format=ROW
    volumes:
      - /mnt/nextcloud-data/db:/var/lib/mysql
    environment:
      - MYSQL_ROOT_PASSWORD=rootPasswortAendern
      - MYSQL_DATABASE=nextcloud
      - MYSQL_USER=nextcloud
      - MYSQL_PASSWORD=nextcloudPasswortAendern
    networks:
      - internal

  redis:
    image: redis:alpine
    container_name: nextcloud-redis
    restart: always
    networks:
      - internal

  app:
    image: nextcloud:latest
    container_name: nextcloud-app
    restart: always
    volumes:
      - /mnt/nextcloud-data/data:/var/www/html
    environment:
      - MYSQL_HOST=db
      - MYSQL_DATABASE=nextcloud
      - MYSQL_USER=nextcloud
      - MYSQL_PASSWORD=nextcloudPasswortAendern
      - REDIS_HOST=redis
      - NEXTCLOUD_TRUSTED_DOMAINS=cloud.techdoc.at
      - NEXTCLOUD_ADMIN_USER=admin
      - NEXTCLOUD_ADMIN_PASSWORD=adminPasswortAendern
      - OVERWRITEPROTOCOL=https
      - OVERWRITECLIURL=https://cloud.techdoc.at
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.nextcloud.rule=Host(`cloud.techdoc.at`)"
      - "traefik.http.routers.nextcloud.entrypoints=websecure"
      - "traefik.http.routers.nextcloud.tls.certresolver=letsencrypt"
      - "traefik.http.services.nextcloud.loadbalancer.server.port=80"
      - "traefik.http.routers.nextcloud.middlewares=nextcloud-headers"
      - "traefik.http.middlewares.nextcloud-headers.headers.stsSeconds=31536000"
      - "traefik.http.middlewares.nextcloud-headers.headers.stsIncludeSubdomains=true"
    depends_on:
      - db
      - redis
      - traefik
    networks:
      - proxy
      - internal

volumes:
  traefik-letsencrypt:

networks:
  proxy:
    external: false
  internal:
    external: false

Nun den Service starten

docker compose up -d

Die Logs kontrollieren

docker compose logs -f traefik

CronJob und Logrotate einrichten

Für die Firma Gapart verwalte ich eine WordPress Seite mit Woocommerce die auf meinem Webspace läuft. Damit alles reibungslos und automatisiert funktioniert, erstelle ich einen CronJob dafür.

Ebenso habe ich auch für meine Nextcloud Instanz einen Cronjob erstellt.

mkdir ~/bin
vi ~/bin/gapart-cron.sh

#!/bin/bash
LOG=/var/log/gapart-cron.log

CODE=$(/usr/bin/curl -sS -m 60 -o /dev/null -w '%{http_code}' \
       "https://gapart.shop/wp-cron.php?doing_wp_cron")

echo "$(date '+%Y-%m-%d %H:%M') $CODE" >> "$LOG"

chmod +x ~/bin/gapart-cron.sh

crontab -e

*/5 * * * * docker exec -u www-data nextcloud-app php /var/www/html/cron.php
*/15 * * * * /home/mschneider/bin/gapart-cron.sh
0 2 * * * /opt/malenohneende/ftp-optimize.sh

sudo touch /var/log/gapart-cron.log && sudo chown mschneider:mschneider /var/log/gapart-cron.log

sudo chmod 666 -R /var/log/gapart-cron.log

sudo vim /etc/logrotate.d/gapart

/var/log/gapart-cron.log /var/log/gapart-backup.log {
    weekly
    rotate 8
    compress
    missingok
    notifempty
}

sudo vim /etc/logrotate.d/maleohneende

/var/log/malenohneende-ftp.log /var/log/malenohneende-ftp-backup.log {
    weekly
    rotate 8
    compress
    missingok
    notifempty
}

Maleohneende FTP

sudo apt install libheif-examples imagemagick

sudo mkdir -p /opt/malenohneende

sudo vim /opt/malenohneende/ftp-optimize.sh

#!/bin/bash
# ============================================================
#  Naechtliche Bildoptimierung fuer malenohneende.at  (SICHER v2)
#
#  Ablauf pro Bild, streng nacheinander:
#    1. Datei vom Server herunterladen (rclone prueft Integritaet)
#    2. HEIC->JPG konvertieren und/oder verkleinern+komprimieren
#    3. In eine TEMP-Datei am Server hochladen
#    4. Groesse lokal vs. hochgeladen exakt vergleichen
#    5. NUR bei exakter Uebereinstimmung serverseitig umbenennen
#       -> Die Live-Datei wird erst im letzten, schnellen Schritt
#          ersetzt. Ein Abbruch kann sie nie zerstoeren.
#
#  Empfohlen: rclone-Remote "webspace" als SFTP (stabiler als FTPS).
#  Voraussetzung: ImageMagick + libheif
#    sudo apt install imagemagick libheif-examples
#
#  Cron (taeglich 02:00):
#    0 2 * * * /opt/malenohneende/ftp-optimize.sh
# ============================================================

set -u

# ===================== KONFIGURATION =====================
WEB_REMOTE="webspace"
WEB_BASE="wp-content/uploads"
WORKDIR="/opt/malenohneende"
STATE="$WORKDIR/state"
LOG="/var/log/malenohneende-ftp.log"
LOCK="/tmp/malenohneende-ftp.lock"
MAX="2000x2000>"
QUALI=85
KATEGORIEN="uebermich aquarell oelpastellen tinteumonochrom maltechnikdetails verschiedenes"
# =========================================================

if command -v magick >/dev/null 2>&1; then IM="magick"; else IM="convert"; fi
log(){ echo "$(date '+%F %T')  $*" >> "$LOG"; }

# Remote-Dateigroesse in Bytes ermitteln
remote_size(){
  rclone size "$WEB_REMOTE:$1" --json 2>/dev/null | grep -o '"bytes":[0-9]*' | grep -o '[0-9]*$'
}

# Sicherer Upload mit Groessenpruefung: local -> temp -> (Vergleich) -> rename
safe_upload(){
  local lf="$1" ziel="$2" tmpz="${2}.uptmp"
  local localsize remotesize

  localsize=$(stat -c%s "$lf" 2>/dev/null)
  if [ -z "$localsize" ] || [ "$localsize" -le 0 ]; then
    log "  !! lokale Datei leer/fehlt, Upload abgebrochen: $lf"; return 1
  fi

  # 1) Upload in Temp-Datei
  if ! rclone copyto "$lf" "$WEB_REMOTE:$tmpz" 2>>"$LOG"; then
    rclone deletefile "$WEB_REMOTE:$tmpz" 2>/dev/null; return 1
  fi

  # 2) Groesse vergleichen (vollstaendig angekommen?)
  remotesize=$(remote_size "$tmpz")
  if [ -z "$remotesize" ] || [ "$remotesize" != "$localsize" ]; then
    log "  !! Groesse ungleich (lokal $localsize / remote ${remotesize:-0}) – Upload verworfen"
    rclone deletefile "$WEB_REMOTE:$tmpz" 2>/dev/null; return 1
  fi

  # 3) Erst jetzt serverseitig umbenennen (ersetzt Original in einem Schritt)
  if ! rclone moveto "$WEB_REMOTE:$tmpz" "$WEB_REMOTE:$ziel" 2>>"$LOG"; then
    rclone deletefile "$WEB_REMOTE:$tmpz" 2>/dev/null; return 1
  fi
  return 0
}

exec 9>"$LOCK"; flock -n 9 || { log "Lauf uebersprungen (Lock aktiv)"; exit 0; }

log "=== FTP-Optimierung gestartet ==="
mkdir -p "$WORKDIR" "$STATE"

for kat in $KATEGORIEN; do
  statefile="$STATE/$kat.processed"; touch "$statefile"
  tmp="$WORKDIR/tmp/$kat"; mkdir -p "$tmp"

  liste="$(rclone lsf --format "ps" --separator "|" "$WEB_REMOTE:$WEB_BASE/$kat" 2>>"$LOG")" \
    || { log "  $kat: Auflisten fehlgeschlagen"; continue; }

  printf '%s\n' "$liste" | while IFS='|' read -r name size; do
    [ -z "$name" ] && continue
    case "$name" in */) continue ;; esac
    case "$name" in *.uptmp) continue ;; esac
    endung_lc="$(printf '%s' "${name##*.}" | tr 'A-Z' 'a-z')"
    case "$endung_lc" in jpg|jpeg|png|webp|heic|heif) ;; *) continue ;; esac

    # ---- HEIC/HEIF ----
    if [ "$endung_lc" = "heic" ] || [ "$endung_lc" = "heif" ]; then
      rclone copyto "$WEB_REMOTE:$WEB_BASE/$kat/$name" "$tmp/$name" 2>>"$LOG" || { log "  DL-Fehler: $name"; continue; }
      ziel="$tmp/${name%.*}.jpg"; zielname="$(basename "$ziel")"
      if ! $IM "$tmp/$name" -auto-orient -quality "$QUALI" "$ziel" 2>>"$LOG"; then
        command -v heif-convert >/dev/null 2>&1 && heif-convert -q "$QUALI" "$tmp/$name" "$ziel" >>"$LOG" 2>&1
      fi
      if [ -f "$ziel" ]; then
        mogrify -auto-orient -resize "$MAX" -quality "$QUALI" -strip "$ziel" 2>>"$LOG"
        if safe_upload "$ziel" "$WEB_BASE/$kat/$zielname"; then
          rclone deletefile "$WEB_REMOTE:$WEB_BASE/$kat/$name" 2>>"$LOG"
          newsize=$(stat -c%s "$ziel")
          awk -F'|' -v n="$zielname" '$1!=n' "$statefile" > "$statefile.tmp" 2>/dev/null; mv "$statefile.tmp" "$statefile" 2>/dev/null
          echo "$zielname|$newsize" >> "$statefile"
          log "  HEIC->JPG + optimiert: $kat/$zielname"
        else
          log "  !! Upload-Fehler (HEIC), Original bleibt unangetastet: $kat/$name"
        fi
      else
        log "  !! HEIC-Konvertierung fehlgeschlagen: $name (libheif?)"
      fi
      rm -f "$tmp/$name" "$ziel"; continue
    fi

    # ---- JPG/PNG/WebP ----
    if awk -F'|' -v n="$name" -v s="$size" '$1==n && $2==s{f=1} END{exit !f}' "$statefile"; then
      continue
    fi
    rclone copyto "$WEB_REMOTE:$WEB_BASE/$kat/$name" "$tmp/$name" 2>>"$LOG" || { log "  DL-Fehler: $name"; continue; }
    mogrify -auto-orient -resize "$MAX" -quality "$QUALI" -strip "$tmp/$name" 2>>"$LOG"
    if safe_upload "$tmp/$name" "$WEB_BASE/$kat/$name"; then
      newsize=$(stat -c%s "$tmp/$name")
      awk -F'|' -v n="$name" '$1!=n' "$statefile" > "$statefile.tmp" 2>/dev/null; mv "$statefile.tmp" "$statefile" 2>/dev/null
      echo "$name|$newsize" >> "$statefile"
      log "  optimiert: $kat/$name"
    else
      log "  !! Upload-Fehler, Original bleibt unangetastet: $kat/$name"
    fi
    rm -f "$tmp/$name"
  done
done

log "=== FTP-Optimierung beendet ==="
exit 0

sudo touch /var/log/malenohneende-ftp.log && sudo chown mschneider:mschneider /var/log/malenohneende-ftp.log

sudo chmod 666 -R /var/log/malenohneende-ftp.log

sudo chown -R mschneider:mschneider /opt/malenohneende
sudo chmod 755 /opt/malenohneende
chmod +x /opt/malenohneende/ftp-optimize.sh

sudo apt install rclone

rclone config

Passbolt Instanzen

Techdoc Passbolt

mkdir -p ~/passbolt-techdoc

vi ~/passbolt-techdoc/docker-compose.yml

services:
  passbolt-techdoc-db:
    image: mariadb:10.11
    container_name: passbolt-techdoc-db
    restart: always
    environment:
      - MYSQL_ROOT_PASSWORD=rootPasswortAendern
      - MYSQL_DATABASE=passbolt
      - MYSQL_USER=passbolt
      - MYSQL_PASSWORD=dbPasswortAendern
    volumes:
      - passbolt-techdoc-db:/var/lib/mysql
    networks:
      - passbolt-techdoc

  passbolt-techdoc:
    image: passbolt/passbolt:latest-ce
    container_name: passbolt-techdoc
    restart: always
    depends_on:
      - passbolt-techdoc-db
    environment:
      - APP_FULL_BASE_URL=https://passbolt.techdoc.at
      - DATASOURCES_DEFAULT_HOST=passbolt-techdoc-db
      - DATASOURCES_DEFAULT_DATABASE=passbolt
      - DATASOURCES_DEFAULT_USERNAME=passbolt
      - DATASOURCES_DEFAULT_PASSWORD=dbPasswortAendern
      - EMAIL_TRANSPORT_DEFAULT_HOST=smtp.easyname.com
      - EMAIL_TRANSPORT_DEFAULT_PORT=465
      - EMAIL_TRANSPORT_DEFAULT_TLS=false
      - EMAIL_TRANSPORT_DEFAULT_USERNAME=office@techdoc.at
      - EMAIL_TRANSPORT_DEFAULT_PASSWORD=deinEmailPasswort
      - EMAIL_DEFAULT_FROM=office@techdoc.at
      - EMAIL_DEFAULT_FROM_NAME=Passbolt TechDoc
    volumes:
      - passbolt-techdoc-gpg:/etc/passbolt/gpg
      - passbolt-techdoc-jwt:/etc/passbolt/jwt
    command:
      [
        "/usr/bin/wait-for.sh",
        "-t",
        "0",
        "passbolt-techdoc-db:3306",
        "--",
        "/docker-entrypoint.sh",
      ]
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.passbolt-techdoc.rule=Host(`passbolt.techdoc.at`)"
      - "traefik.http.routers.passbolt-techdoc.entrypoints=websecure"
      - "traefik.http.routers.passbolt-techdoc.tls.certresolver=letsencrypt"
      - "traefik.http.services.passbolt-techdoc.loadbalancer.server.port=80"
      - "traefik.http.services.passbolt-techdoc.loadbalancer.server.scheme=http"
    networks:
      - passbolt-techdoc
      - nextcloud

volumes:
  passbolt-techdoc-db:
  passbolt-techdoc-gpg:
  passbolt-techdoc-jwt:

networks:
  passbolt-techdoc:
    name: passbolt-techdoc
  nextcloud:
    external: true

cd ~/passbolt-techdoc && docker compose up -d

docker exec -it passbolt-techdoc su -s /bin/bash -c \
  "/usr/share/php/passbolt/bin/cake passbolt register_user \
  -u office@techdoc.at -f Michael -l Schneider -r admin" www-data

Gapart Passbolt

mkdir -p ~/passbolt-gapart

vi ~/passbolt-gapart/docker-compose.yml

services:
  passbolt-gapart-db:
    image: mariadb:10.11
    container_name: passbolt-gapart-db
    restart: always
    environment:
      - MYSQL_ROOT_PASSWORD=rootPasswortAendern
      - MYSQL_DATABASE=passbolt
      - MYSQL_USER=passbolt
      - MYSQL_PASSWORD=dbPasswortAendern
    volumes:
      - passbolt-gapart-db:/var/lib/mysql
    networks:
      - passbolt-gapart

  passbolt-gapart:
    image: passbolt/passbolt:latest-ce
    container_name: passbolt-gapart
    restart: always
    depends_on:
      - passbolt-gapart-db
    environment:
      - APP_FULL_BASE_URL=https://gapart-passbolt.techdoc.at
      - DATASOURCES_DEFAULT_HOST=passbolt-gapart-db
      - DATASOURCES_DEFAULT_DATABASE=passbolt
      - DATASOURCES_DEFAULT_USERNAME=passbolt
      - DATASOURCES_DEFAULT_PASSWORD=dbPasswortAendern
      - EMAIL_TRANSPORT_DEFAULT_HOST=smtp.easyname.com
      - EMAIL_TRANSPORT_DEFAULT_PORT=465
      - EMAIL_TRANSPORT_DEFAULT_TLS=false
      - EMAIL_TRANSPORT_DEFAULT_USERNAME=office@techdoc.at
      - EMAIL_TRANSPORT_DEFAULT_PASSWORD=deinEmailPasswort
      - EMAIL_DEFAULT_FROM=office@techdoc.at
      - EMAIL_DEFAULT_FROM_NAME=Passbolt Gapart
    volumes:
      - passbolt-gapart-gpg:/etc/passbolt/gpg
      - passbolt-gapart-jwt:/etc/passbolt/jwt
    command:
      [
        "/usr/bin/wait-for.sh",
        "-t",
        "0",
        "passbolt-gapart-db:3306",
        "--",
        "/docker-entrypoint.sh",
      ]
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.passbolt-gapart.rule=Host(`gapart-passbolt.techdoc.at`)"
      - "traefik.http.routers.passbolt-gapart.entrypoints=websecure"
      - "traefik.http.routers.passbolt-gapart.tls.certresolver=letsencrypt"
      - "traefik.http.services.passbolt-gapart.loadbalancer.server.port=80"
      - "traefik.http.services.passbolt-gapart.loadbalancer.server.scheme=http"
    networks:
      - passbolt-gapart
      - nextcloud

volumes:
  passbolt-gapart-db:
  passbolt-gapart-gpg:
  passbolt-gapart-jwt:

networks:
  passbolt-gapart:
    name: passbolt-gapart
  nextcloud:
    external: true

cd ~/passbolt-gapart && docker compose up -d

docker exec -it passbolt-gapart su -s /bin/bash -c \
  "/usr/share/php/passbolt/bin/cake passbolt register_user \
  -u office@techdoc.at -f Michael -l Schneider -r admin" www-data

Zuerst muss am externsten Router der Port 80 und 443 auf opnSense weitergeleitet werden. Danach unter Firewall > NAT > Destination NAT folgendes einrichten.

Wichtig ist dabei, dass unten bei Firewall rule Erlauben ausgewählt wird.

Unter System > Einstellungen > Allgemein alle DNS Server entfernen und den Pihole Server eintragen.

Ursprünglicher Eintrag

Neuer Eintrag

Damit die Webseite, die bei Easyname liegt, und die Cloud, die im internen Netz liegt, für die Wifi Benutzer erreichbar bleiben, muss ein Override in OPNsense erstellt werden. Unter Dienste > Unbound > Überschreibungen folgendes Eintragen.

Ich habe einen SSH Key auf meinem Notebook erstellt um mich ohne Passwort auf meinen Servern einzuloggen.

scp -R id_ed25519.pub mschneider@192.168.68.252:/home/mschneider/

Auf meiner PVE Maschine einloggen.

mkdir -p ~/.ssh
cat id_ed25519.pub >> .ssh/authorized_keys
chmod 700 ~/.ssh
chmod 600 ~/.ssh/authorized_keys

Auf PVE VIM installieren und einige SSH Einstellungen durchführen

sudo vim /etc/ssh/sshd_config

sudo systemctl restart sshd

Updates durchführen

sudo apt update && sudo apt upgrade -y

Zuklappen erlauben und Standby deaktivieren.

sudo vim /etc/systemd/logind.conf

[Login]
HandlePowerKey=ignore  
HandleLidSwitch=ignore 
HandleLidSwitchExternalPower=ignore 
HandleLidSwitchDocked=ignore

sudo systemctl restart systemd-logind

Docker installieren

# Docker offiziell installieren:
sudo apt update
sudo apt install -y ca-certificates curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | \
  sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

echo "deb [arch=$(dpkg --print-architecture) \
  signed-by=/etc/apt/keyrings/docker.gpg] \
  https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin

# User zur Docker-Gruppe hinzufügen:
sudo usermod -aG docker mschneider

# Neu einloggen damit Gruppe aktiv wird:
newgrp docker

# Prüfen:
docker --version

Checkmk installieren

# Verzeichnis erstellen:
mkdir -p ~/checkmk
cd ~/checkmk

# docker-compose.yml erstellen:
cat > docker-compose.yml << 'EOF'
services:
  checkmk:
    image: checkmk/check-mk-raw:latest
    container_name: checkmk
    restart: always
    ports:
      - "8080:5000"
      - "8000:8000"
    volumes:
      - /var/checkmk:/omd/sites
    environment:
      - CMK_SITE_ID=monitoring
      - CMK_PASSWORD=deinPasswortAendern
    tmpfs:
      - /opt/omd/sites/monitoring/tmp:uid=1000,gid=1000
EOF

docker compose up -d

# Logs beobachten (dauert beim ersten Start 1-2 Minuten):
docker compose logs -f checkmk

Um ein neues Passwort zu setzen und auch den User gleich zu entsperren.

# Schritt 1: ! aus htpasswd entfernen:
docker exec -it checkmk sed -i 's/cmkadmin:!/cmkadmin:/' /omd/sites/monitoring/etc/htpasswd

# Schritt 2: locked=True in users.mk auf False setzen:
docker exec -it checkmk sed -i "s/'locked': True/'locked': False/" /omd/sites/monitoring/etc/check_mk/multisite.d/wato/users.mk

# Prüfen ob beide Änderungen geklappt haben:
docker exec -it checkmk cat /omd/sites/monitoring/etc/htpasswd
docker exec -it checkmk grep "locked" /omd/sites/monitoring/etc/check_mk/multisite.d/wato/users.mk

#Passwort neu setzen
docker exec -it checkmk su - monitoring -c "cmk-passwd cmkadmin"

# Neu starten:
docker exec -it checkmk omd restart monitoring

Passwordless Login

Ich habe einen SSH Key auf meinem Notebook erstellt um mich ohne Passwort auf meinen Servern einzuloggen.

scp -R id_ed25519.pub root@192.168.68.254:/root/

Auf meiner PVE Maschine einloggen.

mkdir -p ~/.ssh
cat id_ed25519.pub >> .ssh/authorized_keys
chmod 700 ~/.ssh
chmod 600 ~/.ssh/authorized_keys

Auf PVE VIM installieren und einige SSH Einstellungen durchführen

vim /etc/ssh/sshd_config

systemctl restart sshd

No subscription Meldung deaktivieren

sed -i "s/Ext.Msg.show({/void({/g" \
  /usr/share/javascript/proxmox-widget-toolkit/proxmoxlib.js

systemctl restart pveproxy

Da es nach jedem Update neu überschrieben wird. Ein kleiner Fix

cat > /etc/apt/apt.conf.d/99-pve-nag-fix << 'EOF'
DPkg::Post-Invoke {
  "sed -i 's/Ext.Msg.show({/void({/g' \
  /usr/share/javascript/proxmox-widget-toolkit/proxmoxlib.js || true";
  "systemctl restart pveproxy || true";
};
EOF

ZFS Dataset für Nextcloud einrichten

Mittels diesen Befehlen wird erstmal nur die aktuelle Speichergröße und die Gesundheit des ZFS ermittelt.

zpool list
zfs list

Nun wird der Dataset für Nextcloud erstellt.

zfs create -o quota=4T ZFS/nextcloud-data

Nun wird nochmal kontrolliert ob der Dataset erstellt wurde.

zfs list

ZFS Dataset als Storage in Proxmox registrieren

pvesm add zfspool nextcloud-storage \
  --pool ZFS \
  --content images \
  --nodes pve

Mit diesem Befehl können VMs und ihr
Status kontrolliert werden

qm list

Nun im neuen Dataset ein neues Disk Volume erstellen

pvesm alloc nextcloud-storage 101 vm-101-nextcloud 4000G

Nun wird der neue Storage der VM hinzugefügt

qm set 101 --scsi1 nextcloud-storage:vm-101-nextcloud