Sign inSign up

hawk18x/imphomelab-manager

By hawk18x

•Updated 8 days ago

Self-hosted HomeLab-Management— Devices, Docker, Proxmox, Pi-hole, Monitoring, all-in-one-App.

Image
Networking
Developer tools
Monitoring & observability
1

3.6K

hawk18x/imphomelab-manager repository overview

⁠IMP HomeLab Manager

Eine Sicht. Dein gesamtes HomeLab.

Self-hosted HomeLab-Verwaltung mit 28 Modulen und über 45 Dashboard-Widgets in einer App: Netzwerk-Discovery, Container, VMs, Backups, Mediaserver, IPAM, Notifications, PKI, Reverse-Proxy, SSO, Mesh-VPN, Adblocker, K8s, Audit-Trail, Notes/ToDos — alles untereinander verknüpft über Devices, IPs, MAC-Adressen, Hostnamen, Compose-Stacks und Container-IDs. Kein weiterer Single-Tool-Wrapper, sondern echte Cross-Tool-Sicht.


⁠Funktionsumfang

⁠Netzwerk & Geräte
  • Auto-Discovery — ICMP v4 + v6, ARP-Cache-Read, mDNS, SSDP, NetBIOS. OUI-MAC-Vendor-Lookup.
  • Hostname-Quellen-Tracking — pro Gerät sichtbar, ob der Name aus mDNS, NetBIOS, Pi-hole-DHCP, Reverse-DNS, Alias … kommt. Alias schützt vor Auto-Overwrite.
  • Public-IP/WAN-Widget — Quorum-Probe über drei Echo-Services (ipify · ifconfig.me · icanhazip), Drift-Indikator + Provider-Pillen, ChangeEvent bei IP-Wechsel.
  • Primärgerät (Router/Gateway) — als Wurzel des LANs markierbar, eigene WAN-Card auf der Detail-Seite, Public-IP-ChangeEvents werden mit dem Primärgerät verknüpft.
  • IPAM — Subnetz-Verwaltung, IP-Reservations mit DeviceId-Link, Conflict-Detection gegen Pi-hole-/AdGuard-/Technitium-DHCP-Leases, „nächste freie IP".
  • Service-Graph — React-Flow + Dagre, Devices ↔ Reservations ↔ Container ↔ Stacks ↔ VMs als Knoten + Kanten.
  • Topology — Switch-Port-/Trunk-Sicht via SNMPv2c (IF-MIB).
  • Wake-on-LAN, On-Demand-Port-Scan, Uptime-Probes (ICMP + TCP-Fallback).
⁠Container & VMs
  • Docker — Engine-API via TCP-TLS / Unix-Socket / SSH. Container-, Image-, Volume-, Network-Verwaltung. Image-Update-Checker (Watchtower-Labels), CVE-Scans (Trivy mit Detail-Cache). Live-Stats via SignalR-Push (on-demand pro Container).
  • Compose-Stacks — File-Edit + Apply + Revisions-Historie + Rollback. Reverse-Git-Sync: Stack-Änderungen zurück nach Gitea / GitHub / GitLab pushen, Optimistic-Lock pro Provider, Auto-Push-Toggle pro Stack.
  • Proxmox VE — Token- oder Ticket-Auth. Node-/Guest-Übersicht, Bulk-Actions mit Live-Task-Status, LXC- und VM-Verknüpfung zum Service-Graphen. Guest-Stats via Live-Stream.
  • Proxmox Backup Server — Datastore-Auslastung, Last-Verify, jüngstes Backup, Read-only.
  • Kubernetes — KubernetesClient gegen jeden kubeconfig-Cluster. Cluster-Overview, Node-/Pod-Detail, Live-Pod-Stream, Pod-Operations (Logs / Delete).
⁠Mediaserver & Automation
  • Plex / Jellyfin / Emby — eine Sicht über alle Server. Now-Playing-Liste, Library-Counts, Recently-Added, Aktivitäts-Stream (Watch-History bzw. ActivityLog).
  • Sonarr / Radarr / Lidarr / Bazarr / Sabnzbd / qBittorrent + Transmission — Queue-Tiefe, Aktiv-Items, Speed-Tiles, Sub-Status.
⁠Adblocker (Sub-Tabs)
  • Pi-hole v6 — Stats, DHCP-Leases, Queries mit farblicher Status-Differenzierung (ok / cache / blocked / failed) und DNSSEC-Indikator, Group-/Domain-Management, Local-DNS, Live-Update-Toggle.
  • AdGuard Home — Stats, Status, Filtering, BasicAuth.
  • Technitium DNS — Dashboard-Stats, Token-Auth.
⁠Speicher & Sensoren
  • SMART — SSH-getriggertes smartctl --json, Disk-Health-Aging, Scheduled-Scans.
  • SNMP — SNMPv2c IF-MIB für Switch-Interfaces (Status + Throughput).
  • Smart-Plugs / Strom — Tasmota / Shelly / Zigbee, Watt + kWh-Trend + EUR/CO₂ pro Plug oder Target (cost.electricityPriceEurPerKwh + cost.region).
⁠Sicherheit, Auth & PKI
  • Lokale User + Passkey + 2FA, OIDC-SSO (Authentik & generic), rollen-basierte Authorisierung mit MinRoleId pro Widget / Tab.
  • Authentik-Integration — Counter (User / Apps / Outposts / Events 24h), Recent-Logins.
  • CrowdSec — Bouncers, Decisions, Top-Attackers über alle registrierten Agents.
  • step-ca — interne PKI-Inventarisierung, Root-/Intermediate-Cert-Liste mit Aging-Bar.
  • Cert-Ablauf-Checker für beliebige TLS-Endpunkte (täglicher Job, ChangeEvents).
  • Encrypted Vault — AES-256-GCM für Tokens, SSH-Keys, App-Passwörter.
  • Audit-Trail mit Hash-Chain-Verifikation; kann nicht still überschrieben werden.
⁠Reverse-Proxy & Mesh
  • Traefik / Nginx-Proxy-Manager / Zoraxy — unified Routes-Tabelle mit TLS-/Status-Indikator, ACME-Status.
  • OPNsense — Interface-Status, Throughput, Aliases-Counter pro Host.
  • NetBird — Mesh-VPN-Peers, Connected/Total, zuletzt gesehen.
⁠Operativ
  • Notifications — ntfy, Webhook, Discord, Gotify, MQTT. Glob-Pattern-Rules pro Event-Typ, Throttle + Cooldown + Suppressed-Counter, ActionVerb/SourceEntity-Filter.
  • Inbound Webhooks — externe Systeme können ChangeEvents senden.
  • Action-Queue — alle Mutations laufen über einen sichtbaren Job-Bus mit Live-Footer.
  • Logs — Container-Tail + Live-Stream, zentralisiert via Loki + Vector. Loki-Streams mit Compose-Project/Service als Label.
  • Terminal — interaktive SSH-PTY pro Gerät, Multi-Tab-Sessions (xterm.js), bis zu 8 parallele Sessions pro Browser-Verbindung. One-Shot-exec-Pfad als Alternative.
  • Notes (Tiptap-Markdown), Kanban-ToDos mit Swimlanes/Spalten/Prios + Cross-Links zu 10 Entity-Typen.
  • Gitea-Integration — Repo-Counter, Push-Targets für Compose-Reverse-Sync.
  • Synthetic-Probes — HTTP/TCP/Cmd-Checks gegen beliebige Targets.
  • Dashboard — Multi-Dashboard mit Drag-and-Drop-Grid (react-grid-layout), 45+ Widget-Typen, Section-Header zur Gruppierung, Container-Query-Tiles (Schrift skaliert mit Tile-Größe).

⁠Image-Layout

Dieses Repo enthält beide Komponenten (Backend-API + Frontend-Web) und unterscheidet sie über das Tag-Prefix:

api-Image: .NET 10 ASP.NET Core Web API, hört auf Port 5099. web-Image: nginx + statisches React-Bundle, hört auf Port 8080.

⁠Tag-Schema
TagBedeutung
api-latest / web-latestProduction-Stand. Wer ohne expliziten Tag pullt, bekommt freigegebenen Code — niemals dev.
api-production / web-productionIdentisch mit latest. Stabil, manuell promotet aus staging.
api-staging / web-stagingUAT-Promotion aus dev. Snapshot für Integrationstests vor Production.
api-dev / web-devAktueller Entwicklungsstand. Pinning empfohlen, wenn du immer das Neueste willst (statt versehentlich auf production zu hängen).
api-<MAJOR.MINOR.BUILD.REV> / web-…Versions-Snapshots (Rollback-Historie). Bleiben dauerhaft in der Registry. Beispiel: api-0.46.330.624.

Promotion-Pfad: dev → staging → production (+ latest-Tag mit-aktualisiert). Promotions sind bewusste Operator-Entscheidungen, keine Automation. Versions-Tags laufen niemals rückwärts — Rollback geht über das passende <rev>-Tag.

⁠Welcher Tag für mich?
  • Standard-Anwender: api-latest / web-latest (= production).
  • Reproduzierbarer Deploy: ein konkretes <rev>-Tag pinnen.
  • Bleeding-edge / Beta-Tester: api-dev / web-dev.

⁠Quick Start

Linux-Host mit Docker + Docker Compose. Vier Schritte.

⁠1. Master-Key generieren

Der Vault verschlüsselt alle Secrets (API-Tokens, SSH-Keys, App-Passwörter) mit AES-256-GCM.

openssl rand -base64 32
⁠2. Logs-Stack vorbereiten (Loki + Vector)

Die Logs-Ansicht der App liest Container-Logs aus Loki — Vector liefert die Streams. Lege zwei Config-Dateien neben deine docker-compose.yml:

config/loki-config.yaml

auth_enabled: false

server:
  http_listen_port: 3100
  grpc_listen_port: 9095
  log_level: info

common:
  path_prefix: /loki
  storage:
    filesystem:
      chunks_directory: /loki/chunks
      rules_directory: /loki/rules
  replication_factor: 1
  ring:
    instance_addr: 127.0.0.1
    kvstore: { store: inmemory }

schema_config:
  configs:
    - from: 2024-01-01
      store: tsdb
      object_store: filesystem
      schema: v13
      index: { prefix: index_, period: 24h }

limits_config:
  retention_period: 336h            # 14 Tage
  reject_old_samples: true
  reject_old_samples_max_age: 168h
  allow_structured_metadata: true
  volume_enabled: true

compactor:
  working_directory: /loki/compactor
  compaction_interval: 10m
  retention_enabled: true
  retention_delete_delay: 2h
  delete_request_store: filesystem

analytics:
  reporting_enabled: false

config/vector.yaml

data_dir: /var/lib/vector

api:
  enabled: false

sources:
  docker:
    type: docker_logs
    exclude_containers:
      - imphomelab-vector
      - imphomelab-loki
  journald:
    type: journald
    journal_directory: /var/log/journal
    include_units: []

transforms:
  enrich_docker:
    type: remap
    inputs: [docker]
    source: |
      .source = "docker"
      .compose_project = .label."com.docker.compose.project" || "(none)"
      .compose_service = .label."com.docker.compose.service" || "(none)"
  enrich_journald:
    type: remap
    inputs: [journald]
    source: |
      .source = "journald"
      .container_name = "(host)"

sinks:
  loki:
    type: loki
    inputs: [enrich_docker, enrich_journald]
    endpoint: ${LOKI_ENDPOINT:-http://localhost:3100}
    encoding: { codec: text }
    labels:
      source: "{{ source }}"
      container: "{{ container_name }}"
      image: "{{ image }}"
      compose_project: "{{ compose_project }}"
      compose_service: "{{ compose_service }}"
      unit: "{{ _SYSTEMD_UNIT }}"
    out_of_order_action: accept
    remove_label_fields: true
    batch:
      max_bytes: 1048576
      timeout_secs: 5

💡 Brauchst du nur Discovery + Dashboard + Monitoring ohne Logs-Ansicht? Dann diesen Schritt überspringen und die loki/vector-Services unten weglassen.

⁠3. docker-compose.yml anlegen
services:
  api:
    image: hawk18x/imphomelab-manager:api-latest
    container_name: imphomelab-api
    restart: unless-stopped
    network_mode: host       # Discovery braucht LAN-Zugriff (ICMP, ARP, mDNS, SSDP)
    cap_add: [NET_RAW]       # ICMP ohne Root
    environment:
      - ASPNETCORE_URLS=http://+:5099
      - ConnectionStrings__Default=Data Source=/app/data/imphomelab.db
      - IMPHOMELAB_MASTER_KEY=<OUTPUT_VON_SCHRITT_1>
    volumes:
      - ./data/api:/app/data
      - ./data/logs:/app/logs
    depends_on: [loki]

  web:
    image: hawk18x/imphomelab-manager:web-latest
    container_name: imphomelab-web
    restart: unless-stopped
    network_mode: host       # API ist via http://localhost:5099 erreichbar
    depends_on: [api]

  loki:
    image: grafana/loki:3.0.0
    container_name: imphomelab-loki
    restart: unless-stopped
    network_mode: host
    command: ["-config.file=/etc/loki/local-config.yaml"]
    volumes:
      - ./data/loki:/loki
      - ./config/loki-config.yaml:/etc/loki/local-config.yaml:ro

  vector:
    image: timberio/vector:0.40.0-debian
    container_name: imphomelab-vector
    restart: unless-stopped
    network_mode: host
    environment:
      - LOKI_ENDPOINT=http://localhost:3100
    volumes:
      - ./data/vector:/var/lib/vector
      - ./config/vector.yaml:/etc/vector/vector.yaml:ro
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - /var/log/journal:/var/log/journal:ro
    depends_on: [loki]

💡 Bridge-Network statt Host-Networking? Dann network_mode: host + cap_add bei allen Services entfernen, ein gemeinsames networks:-Feld definieren, ports: ["5099:5099"] + ["8080:8080"] bei api/web ergänzen und in vector LOKI_ENDPOINT=http://loki:3100 setzen. Discovery (mDNS, ARP, ICMP-Sweep) fällt dann aus — der Rest funktioniert.

⁠4. Hochfahren
docker compose up -d

# Healthcheck:
curl http://localhost:5099/healthz       # {"status":"Healthy"}

# Loki ready?
curl http://localhost:3100/ready         # ready

# UI im Browser:
# http://<host>:8080

Beim ersten Start legt die App die SQLite-DB an, führt EF-Migrationen aus und seedet die Default-Scheduled-Tasks (Discovery alle 15 min, Uptime 60 s, Cert-Check 12 h). Anschließend ist alles im UI konfigurierbar — Subnetze, Integrationen, Tags, Widgets, Benutzer.

Logs aktivieren: einmalig in Einstellungen → Logs die Loki-URL eintragen: http://localhost:3100. Sobald gesetzt, listet die Logs-Section die Container-Streams live.


⁠Updates

api-latest / web-latest zeigen immer auf den aktuellen Production-Stand (neu seit RC1: war früher dev — siehe Tag-Schema oben). Für reproduzierbare Deployments einen Versions-Tag pinnen, z. B. api-0.46.330.624 / web-0.46.329.1106.

docker compose pull
docker compose up -d

Wer das absolut Neueste haben will (auch nicht-promotete Builds), pinned auf api-dev / web-dev.


⁠Konfiguration

Env-VariablePflichtDefaultZweck
IMPHOMELAB_MASTER_KEYja—32-byte base64 oder Freitext (→ SHA-256). Vault-Master-Key.
ConnectionStrings__DefaultneinData Source=/app/data/imphomelab.dbSQLite-Pfad. Bind-Mount auf persistenten Storage empfohlen.
ASPNETCORE_URLSneinhttp://+:5099API-Listen-Adresse.

Alle weiteren Settings (Discovery-Intervalle, Polling-Raten, Integrationen, Theme/Branding, Logs-Loki-URL, Modul-Toggles, Notification-Provider, Smart-Plugs, Strompreis …) sind im UI unter Einstellungen persistiert. Module lassen sich einzeln deaktivieren (module.<name>.enabled in AppSettings) — deaktivierte Module blenden Tabs, Widgets und Hilfe-Topics aus.


⁠Stack

  • Backend: .NET 10 / ASP.NET Core Web API, EF Core + SQLite (single-file, embedded), SignalR, Quartz.NET, Serilog
  • Frontend: React 18 + Vite + TypeScript + Tailwind, TanStack Query, React Router, react-grid-layout, React Flow + Dagre, Recharts, Tiptap, @microsoft/signalr
  • Logs: Loki + Vector (offizielle Upstream-Images)
  • K8s: KubernetesClient 19.0.2
  • Observability: Prometheus-Metrics unter /metrics, Healthcheck unter /healthz
  • i18n: Deutsch + Englisch
  • Themes: 7 Themes inkl. Custom-Theme, Dark/Light per Theme

⁠Ports

PortContainerZweck
8080webUI (HTTP)
5099apiREST + SignalR-Hubs (/hubs/events, /hubs/terminal)
3100lokiLoki HTTP-API (intern)

Auf manchen Hosts ist Port 8080 belegt — dann z. B. auf 8090 mappen.


⁠Hostnetz-Hinweis

Die Auto-Discovery (mDNS, SSDP, ARP-Cache-Read, ICMP-Sweep) funktioniert nur mit network_mode: host auf Linux. Auf Docker Desktop (Windows/macOS) greift sie nicht — der Container läuft dort in einer WSL2-VM, das LAN ist nicht direkt sichtbar. Der Rest der App (Docker/Proxmox/Pi-hole/… über deren APIs, Dashboard, Logs) funktioniert auch im Bridge-Mode.

cap_add: [NET_RAW] erlaubt ICMP-Pings ohne Root im Container.

Tag summary

Content type

Image

Digest

sha256:b063991db…

Size

27 MB

Last updated

8 days ago

docker pull hawk18x/imphomelab-manager:web-latest