Close Lid, Uptime, Auth

Setup-Guide: Hyprlock, Authelia & Uptime Kuma
TEIL 1: HYPRLOCK AUTO-LOCK BEI LID CLOSE
Hyprland Lid-Event Handler
Methode 1: Mit Hyprland Event (empfohlen!)
Hyprland hat ein eingebautes Event-System!
Config erweitern:
nano ~/.config/hypr/hyprland.conf
Füge hinzu:
# Lid close event
bindl = , switch:on:Lid Switch, exec, hyprlock
Das war's!
Test:
Laptop-Deckel zuklappen
Sollte sofort sperren
Methode 2: Mit systemd-logind (Alternative)
Falls Methode 1 nicht funktioniert:
Script erstellen:
sudo nano /usr/local/bin/lock-on-lid.sh
Inhalt:
#!/bin/bash
# User und Display finden
USER=$(who | grep tty | awk '{print $1}' | head -1)
DISPLAY_NUM=$(who | grep "($USER)" | awk '{print $5}' | sed 's/[()]//g' | head -1)
if [ -z "$DISPLAY_NUM" ]; then
    DISPLAY_NUM=":0"
fi
# Als User ausführen
export DISPLAY="$DISPLAY_NUM"
sudo -u $USER WAYLAND_DISPLAY=wayland-1 hyprlock
Ausführbar machen:
sudo chmod +x /usr/local/bin/lock-on-lid.sh
Systemd-Service:
sudo nano /etc/systemd/system/lock-on-lid@.service
Inhalt:
[Unit]
Description=Lock screen on lid close
Before=sleep.target
[Service]
Type=oneshot
User=%i
ExecStart=/usr/local/bin/lock-on-lid.sh
[Install]
WantedBy=sleep.target
Aktivieren:
sudo systemctl enable lock-on-lid@denode.service
logind.conf anpassen:
sudo nano /etc/systemd/logind.conf
Ändere:
HandleLidSwitch=lock
HandleLidSwitchExternalPower=lock
HandleLidSwitchDocked=ignore
logind neu starten:
sudo systemctl restart systemd-logind
TEIL 2: AUTHELIA SSO INSTALLATION
Was ist Authelia?
Authelia ersetzt Basic Auth durch moderne Login-Seite mit:
Schöne Login-UI
2FA (TOTP, U2F)
SSO für alle Services
Session-Management
Passwort-Reset
Aussehen: Wie Google/GitHub Login - professionell!
Schritt 1: Verzeichnis erstellen
WICHTIG: Wir nutzen die HDD um Speicherplatz zu sparen!
# Auf dem Homeserver - auf der HDD!
sudo mkdir -p /mnt/hdd/authelia/{config,data,data/redis}
sudo chown -R denode:denode /mnt/hdd/authelia
cd /mnt/hdd/authelia
Schritt 2: Docker-Compose erstellen
nano docker-compose.yml
Inhalt:
version: '3.8'
services:
  authelia:
    image: authelia/authelia:latest
    container_name: authelia
    restart: unless-stopped
    environment:
      - TZ=Europe/Berlin
    volumes:
      - ./config:/config
      - ./data:/data
    ports:
      - "9091:9091"
    networks:
      - authelia
  redis:
    image: redis:7-alpine
    container_name: authelia-redis
    restart: unless-stopped
    volumes:
      - ./data/redis:/data
    networks:
      - authelia
networks:
  authelia:
    driver: bridge
Schritt 3: Authelia Config
nano config/configuration.yml
Komplette Config:
---
theme: dark
jwt_secret: CHANGE_THIS_TO_RANDOM_STRING_123456789012345678901234567890
default_redirection_url: https://denode.eu
server:
  host: 0.0.0.0
  port: 9091
log:
  level: info
totp:
  issuer: denode.eu
  period: 30
  skew: 1
authentication_backend:
  file:
    path: /config/users_database.yml
    password:
      algorithm: argon2id
      iterations: 1
      salt_length: 16
      parallelism: 8
      memory: 64
access_control:
  default_policy: deny
  rules:
    - domain: "*.denode.eu"
      policy: one_factor
session:
  name: authelia_session
  domain: denode.eu
  expiration: 1h
  inactivity: 5m
  remember_me_duration: 1M
  redis:
    host: redis
    port: 6379
regulation:
  max_retries: 3
  find_time: 2m
  ban_time: 5m
storage:
  local:
    path: /data/db.sqlite3
notifier:
  disable_startup_check: true
  filesystem:
    filename: /data/notification.txt
WICHTIG: Ändere 
jwt_secret zu einem zufälligen String!
# Generiere Random String
openssl rand -hex 32
# Kopiere Output und ersetze jwt_secret
Schritt 4: Users erstellen
nano config/users_database.yml
Inhalt:
---
users:
  denode:
    displayname: "Denode"
    password: "$argon2id$v=19$m=65536,t=3,p=4$HASH_HIER"
    email: admin@denode.local
    groups:
      - admins
      - dev
Passwort hashen:
docker run --rm authelia/authelia:latest authelia crypto hash generate argon2 --password 'DeinPasswort'
Kopiere den Hash (komplette Zeile mit 
$argon2id$...) und ersetze in 
users_database.yml!
Schritt 5: Authelia starten
cd /mnt/hdd/authelia
docker compose up -d
# Logs ansehen
docker compose logs -f
Warte bis: "Authelia is now listening"
Test:
curl http://localhost:9091/api/health
# Sollte {"status":"UP"} zurückgeben
Schritt 6: Caddy auf Homeserver anpassen
sudo nano /etc/caddy/Caddyfile
Füge nach dem 
homeserver.mora-stairs.ts.net Block hinzu:
# Authelia
auth.denode.eu {
    reverse_proxy localhost:9091
}
http://:80 {
    @from_tunnel remote_ip 10.100.0.1
    
    # Authelia API
    @authelia host auth.denode.eu
    handle @authelia {
        handle @from_tunnel {
            reverse_proxy localhost:9091
        }
        handle {
            respond "Access denied" 403
        }
    }
    
    # ... rest bleibt gleich
}
Caddy neuladen:
sudo systemctl reload caddy
Schritt 7: DNS-Record setzen
Bei spaceship.com:
Type: A
Name: auth
Value: 46.224.8.110
TTL: 3600
Schritt 8: Caddy auf Hetzner mit Authelia
ssh hetzner
nano /etc/caddy/Caddyfile
Ändere z.B. den notes.denode.eu Block:
notes.denode.eu {
    # Forward Auth zu Authelia
    forward_auth auth.denode.eu {
        uri /api/verify?rd=https://auth.denode.eu
        copy_headers Remote-User Remote-Groups Remote-Name Remote-Email
    }
    
    encode gzip
    reverse_proxy 10.100.0.2:4567 {
        header_up Host {host}
        header_up X-Real-IP {remote_host}
        header_up X-Forwarded-For {remote_host}
        header_up X-Forwarded-Proto {scheme}
    }
}
Gleich für alle Services (denode.eu, overleaf.denode.eu, etc.):
denode.eu {
    forward_auth auth.denode.eu {
        uri /api/verify?rd=https://auth.denode.eu
        copy_headers Remote-User Remote-Groups Remote-Name Remote-Email
    }
    
    root * /var/www/denode
    file_server
    encode gzip
}
overleaf.denode.eu {
    forward_auth auth.denode.eu {
        uri /api/verify?rd=https://auth.denode.eu
        copy_headers Remote-User Remote-Groups Remote-Name Remote-Email
    }
    
    encode gzip
    reverse_proxy 10.100.0.2:4568 {
        header_up Host {host}
        header_up X-Real-IP {remote_host}
        header_up X-Forwarded-For {remote_host}
        header_up X-Forwarded-Proto {scheme}
    }
}
Caddy neuladen:
systemctl reload caddy
Schritt 9: Authelia testen!
Öffne: 
https://notes.denode.eu
Du wirst weitergeleitet zu: 
https://auth.denode.eu
Login-Seite erscheint!
Einloggen:
Username: 
denode
Passwort: DeinPasswort
Nach Login: Zurück zu BookStack!
2FA einrichten (optional):
Nach Login: Klick auf dein Profil
Two-Factor Authentication
QR-Code mit Authenticator-App scannen (z.B. Authy, Google Authenticator)
Authelia Features
Session-Management:
Nach Login: 1 Stunde gültig
"Remember Me": 1 Monat
Auto-Logout bei Inaktivität: 5 Minuten
Sicherheit:
3 Fehlversuche → 5 Minuten Ban
Passwort-Hashing mit Argon2id
Optional: 2FA mit TOTP
Aussehen:
Dark Mode (in Config: 
theme: dark)
Responsive Design
Moderne UI
Troubleshooting Authelia
Logs ansehen:
cd /mnt/hdd/authelia
docker compose logs authelia -f
Container neu starten:
docker compose restart authelia
Config testen:
docker exec authelia authelia validate-config /config/configuration.yml
Passwort zurücksetzen:
# Neuen Hash generieren
docker run --rm authelia/authelia:latest authelia crypto hash generate argon2 --password 'NeuesPasswort'
# In users_database.yml eintragen
nano config/users_database.yml
# Authelia neu starten
docker compose restart authelia
TEIL 3: UPTIME KUMA INSTALLATION
Was ist Uptime Kuma?
Uptime Kuma ist ein modernes Monitoring-Dashboard.
Features:
Schöne Status-Seite
Monitort HTTP, TCP, Ping, Docker, etc.
Benachrichtigungen (Telegram!)
Öffentliche Status-Page möglich
Response-Time Graphen
Uptime-Statistiken
Sieht aus wie: Professionelles Monitoring-Dashboard!
Schritt 1: Installation
WICHTIG: Auf HDD installieren!
# Auf dem Homeserver - auf der HDD!
sudo mkdir -p /mnt/hdd/uptime-kuma/data
sudo chown -R denode:denode /mnt/hdd/uptime-kuma
cd /mnt/hdd/uptime-kuma
nano docker-compose.yml
Inhalt:
version: '3.8'
services:
  uptime-kuma:
    image: louislam/uptime-kuma:latest
    container_name: uptime-kuma
    restart: unless-stopped
    volumes:
      - ./data:/app/data
    ports:
      - "3001:3001"
Starten:
docker compose up -d
# Logs
docker compose logs -f
Schritt 2: Caddy konfigurieren
Auf Homeserver:
sudo nano /etc/caddy/Caddyfile
Füge in 
http://:80 Block hinzu:
@uptime host uptime.denode.eu
handle @uptime {
    handle @from_tunnel {
        reverse_proxy localhost:3001 {
            header_up X-Real-IP {remote_host}
            header_up X-Forwarded-For {remote_host}
            header_up X-Forwarded-Proto {scheme}
        }
    }
    handle {
        respond "Access denied" 403
    }
}
Auf Hetzner:
ssh hetzner
nano /etc/caddy/Caddyfile
Hinzufügen:
uptime.denode.eu {
    # Optional: Mit Authelia schützen
    forward_auth auth.denode.eu {
        uri /api/verify?rd=https://auth.denode.eu
        copy_headers Remote-User Remote-Groups Remote-Name Remote-Email
    }
    
    encode gzip
    reverse_proxy 10.100.0.2:3001 {
        header_up Host {host}
        header_up X-Real-IP {remote_host}
        header_up X-Forwarded-For {remote_host}
        header_up X-Forwarded-Proto {scheme}
    }
}
Beide Caddy neu laden:
# Homeserver
sudo systemctl reload caddy
# Hetzner
ssh hetzner "systemctl reload caddy"
Schritt 3: DNS-Record
Bei spaceship.com:
Type: A
Name: uptime
Value: 46.224.8.110
TTL: 3600
Schritt 4: Uptime Kuma Setup
Öffne: 
https://uptime.denode.eu
Erster Login: Account erstellen
Username: admin
Passwort: DeinSicheresPasswort
Dashboard öffnet sich!
Schritt 5: Monitors erstellen
Nextcloud Monitor
Klick "Add New Monitor"
Monitor Type: HTTP(s)
Friendly Name: Nextcloud
URL: 
https://nextcloud.denode.eu
Heartbeat Interval: 60 seconds
Retries: 3
Method: GET
Accepted Status Codes: 200-299, 302
Save
BookStack Monitor
Name: BookStack
URL: 
https://notes.denode.eu
Rest gleich
Overleaf Monitor
Name: Overleaf
URL: 
https://overleaf.denode.eu
Landing-Page Monitor
Name: Landing Page
URL: 
https://denode.eu
Wireguard-Tunnel Monitor
Monitor Type: Ping
Name: Wireguard Tunnel
Hostname: 
10.100.0.1 (Hetzner) oder 
10.100.0.2 (Homeserver)
Save
Schritt 6: Telegram-Benachrichtigungen
Settings → Notifications
Setup Notification → Telegram
Bot Token: 
8446514684:AAEthBJXkEVMw9kOVfrjdtpDuE5S3P9Heas
Chat ID: 
1916692273
Test → sollte Nachricht in Telegram kommen!
Save
Für jeden Monitor aktivieren:
Monitor öffnen → Notifications Tab
Telegram aktivieren
Schritt 7: Status-Page erstellen (Optional)
Öffentliche Status-Seite für Freunde/Familie:
Status Pages (links im Menü)
Add New Status Page
Title: Denode Services
Slug: 
public (wird zu: uptime.denode.eu/status/public)
Description: "Status meiner Self-Hosted Services"
Theme: Dark
Add a Group:
Name: "Services"
Wähle alle Monitore
Save
Jetzt können andere 
https://uptime.denode.eu/status/public aufrufen und sehen den Status!
Uptime Kuma Features
Dashboard:
Live-Status aller Services (🟢🔴)
Durchschnittliche Response-Time
Uptime Prozent (24h, 7d, 30d)
Incident-History
Benachrichtigungen:
Telegram
Discord
Email
Slack
Webhook
... und viele mehr!
Monitoring-Typen:
HTTP(s)
TCP Port
Ping/ICMP
DNS
Docker Container
Keyword (prüft ob Text auf Seite)
Troubleshooting Uptime Kuma
Container neu starten:
cd /mnt/hdd/uptime-kuma
docker compose restart
Logs:
docker compose logs -f
Daten zurücksetzen:
docker compose down
rm -rf data/
docker compose up -d
ZUSAMMENFASSUNG
Was du jetzt hast:
1. Hyprlock Auto-Lock ✅
Laptop sperrt automatisch beim Zuklappen
Hyprland Event-Handler
2. Authelia SSO ✅
Moderne Login-Seite für alle Services
Kein nerviges Basic-Auth mehr!
Optional: 2FA
Session-Management
Sieht professionell aus!
3. Uptime Kuma ✅
Monitoring aller Services
Schönes Dashboard
Telegram-Benachrichtigungen
Status-Page für andere
URLs:
Authelia: https://auth.denode.eu
Uptime Kuma: https://uptime.denode.eu
Status-Page: https://uptime.denode.eu/status/public
Wichtige Befehle:
Authelia:
cd /mnt/hdd/authelia
docker compose ps
docker compose logs -f
docker compose restart
Uptime Kuma:
cd /mnt/hdd/uptime-kuma
docker compose ps
docker compose logs -f
Hyprlock testen:
hyprlock
Ports:
Authelia: 9091
Uptime Kuma: 3001
Backup:
In Backup-Script einfügen:
# Authelia Backup (liegt auf HDD!)
tar -czf "$BACKUP_DIR/authelia/authelia_${DATE}.tar.gz" -C /mnt/hdd authelia/
# Uptime Kuma Backup (liegt auf HDD!)
tar -czf "$BACKUP_DIR/uptime-kuma/uptime-kuma_${DATE}.tar.gz" -C /mnt/hdd uptime-kuma/
Backup-Verzeichnisse erstellen:
mkdir -p /mnt/hdd/backups/authelia
mkdir -p /mnt/hdd/backups/uptime-kuma
Landing-Page erweitern:
Füge neue Service-Cards hinzu:
<div class="service-card">
    <div class="service-icon">🔐</div>
    <h3>Login</h3>
    <p>Single Sign-On für alle Services.</p>
    <a href="https://auth.denode.eu" class="service-link">Öffnen →</a>
</div>
<div class="service-card">
    <div class="service-icon">📊</div>
    <h3>Status</h3>
    <p>Monitoring & Uptime aller Services.</p>
    <a href="https://uptime.denode.eu" class="service-link">Öffnen →</a>
</div>
✅ Automatisches Laptop-Lock
✅ Moderne Login-Seite
✅ Professionelles Monitoring