Virtualisierung & Container – So laufen VMs und Container unter DSM

Virtual Machine Manager und Docker Container auf Synology NAS - Von Grundlagen bis zu fortgeschrittenen Anwendungen

Virtualisierung & Container auf Synology NAS

Überblick

Moderne Synology NAS-Systeme bieten mächtige Virtualisierungslösungen, die aus einem einzigen Gerät ein komplettes Rechenzentrum machen können. Mit Virtual Machine Manager (VMM) und Container Station/Docker kannst du:

  • Vollständige Betriebssysteme in virtuellen Maschinen betreiben
  • Leichtgewichtige Container für spezifische Anwendungen nutzen
  • Entwicklungsumgebungen isoliert testen
  • Legacy-Systeme sicher betreiben
  • Home-Lab für Experimente aufbauen

Virtual Machine Manager (VMM)

Systemanforderungen

Mindestanforderungen:

  • Intel x64-basierte Synology NAS (kein ARM)
  • Mindestens 4 GB RAM (8 GB+ empfohlen)
  • Hardware-Virtualisierung (Intel VT-x)
  • Ausreichend freier Speicherplatz

Unterstützte NAS-Modelle (Auswahl):

  • DS920+, DS1520+, DS1821+
  • RS820+, RS1221+, RS2421+
  • Alle + und FS-Modelle mit Intel-CPU

VMM Installation und Einrichtung

1. Package Center Installation

  1. Package Center öffnen
  2. Nach "Virtual Machine Manager" suchen
  3. Installieren und auf Systemneustarts vorbereiten
  4. VMM aus dem Hauptmenü starten

2. Erste Konfiguration

Speicher-Pool erstellen:

  1. Speicher > Speicher-Pool > Hinzufügen
  2. Speicherort wählen (empfohlen: SSD für bessere Performance)
  3. Größe festlegen (mindestens 100 GB pro VM)
  4. Thin Provisioning aktivieren für effizienten Speicherverbrauch

Netzwerk konfigurieren:

  1. Netzwerk > Virtueller Switch
  2. Standard-Switch verwenden oder neuen erstellen
  3. Physischen Adapter zuweisen
  4. VLAN-Tagging bei Bedarf konfigurieren

Virtuelle Maschinen erstellen

Windows 10/11 VM

VM-Erstellung:

  1. Virtuelle Maschine > Erstellen
  2. Microsoft Windows auswählen
  3. Ressourcen zuweisen:
    • CPU: 2-4 vCores
    • RAM: 4-8 GB
    • Storage: 60-100 GB
  4. ISO-Image hochladen oder mounten

Installation optimieren:

# Synology VMM Tools installieren (nach Windows-Installation)
# 1. VM-Konsole öffnen
# 2. Aktion > VMM Tools installieren
# 3. Setup durchführen für bessere Integration

Performance-Tipps:

  • Virtio-Treiber für bessere I/O-Performance
  • Ballooning für dynamische RAM-Zuteilung
  • SSD-Cache aktivieren falls verfügbar

Linux VMs

Ubuntu Server 22.04 LTS:

Konfiguration:
  CPU: 2 vCores
  RAM: 2-4 GB
  Storage: 20-40 GB
  Netzwerk: Virtio-net
  Sicherheit: UEFI + Secure Boot

Automatisierte Installation:

# Cloud-init für Ubuntu
#cloud-config
users:
  - name: admin
    sudo: ALL=(ALL) NOPASSWD:ALL
    ssh_authorized_keys:
      - ssh-rsa AAAAB3... # Dein SSH-Key

packages:
  - docker.io
  - nginx
  - htop

runcmd:
  - systemctl enable docker
  - usermod -aG docker admin

Container Station / Docker

Docker Grundlagen

Was sind Container?

  • Leichtgewichtige Virtualisierung auf OS-Level
  • Teilen sich den Kernel des Host-Systems
  • Deutlich geringerer Ressourcenverbrauch als VMs
  • Perfekt für Mikroservices und Web-Anwendungen

Container Station Installation

  1. Package Center > Container Station installieren
  2. Docker Hub Registry aktivieren
  3. Registrys für private Images hinzufügen
  4. Ressourcenlimits konfigurieren

Populäre Container-Anwendungen

Home Assistant (Smart Home)

Über Container Station UI:

  1. Registry > Home Assistant suchen
  2. Download neueste Version
  3. Container erstellen:
    Name: homeassistant
Port-Mapping: 8123:8123
Volume: /docker/homeassistant:/config
Umgebungsvariablen: TZ=Europe/Berlin

Über Docker Compose:

version: "3.8"
services:
  homeassistant:
    container_name: homeassistant
    image: ghcr.io/home-assistant/home-assistant:stable
    volumes:
      - /volume1/docker/homeassistant:/config
      - /etc/localtime:/etc/localtime:ro
    restart: unless-stopped
    privileged: true
    network_mode: host

Plex Media Server

version: "3.8"
services:
  plex:
    image: lscr.io/linuxserver/plex:latest
    container_name: plex
    network_mode: host
    environment:
      - PUID=1026 # Synology Docker User ID
      - PGID=100 # users group
      - TZ=Europe/Berlin
      - VERSION=docker
    volumes:
      - /volume1/docker/plex:/config
      - /volume1/media:/media
    restart: unless-stopped

Nextcloud (Privat-Cloud)

version: "3.8"
services:
  nextcloud:
    image: nextcloud:latest
    container_name: nextcloud
    ports:
      - "8080:80"
    volumes:
      - /volume1/docker/nextcloud:/var/www/html
      - /volume1/nextcloud-data:/var/www/html/data
    environment:
      - MYSQL_HOST=nextcloud-db
      - MYSQL_DATABASE=nextcloud
      - MYSQL_USER=nextcloud
      - MYSQL_PASSWORD=secure_password
    depends_on:
      - nextcloud-db
    restart: unless-stopped

  nextcloud-db:
    image: mariadb:latest
    container_name: nextcloud-db
    volumes:
      - /volume1/docker/nextcloud-db:/var/lib/mysql
    environment:
      - MYSQL_ROOT_PASSWORD=secure_root_password
      - MYSQL_DATABASE=nextcloud
      - MYSQL_USER=nextcloud
      - MYSQL_PASSWORD=secure_password
    restart: unless-stopped

Pi-hole (DNS-Werbeblocker)

version: "3.8"
services:
  pihole:
    container_name: pihole
    image: pihole/pihole:latest
    ports:
      - "53:53/tcp"
      - "53:53/udp"
      - "67:67/udp"
      - "8081:80/tcp"
    environment:
      - TZ=Europe/Berlin
      - WEBPASSWORD=admin123
      - DNS1=8.8.8.8
      - DNS2=8.8.4.4
    volumes:
      - /volume1/docker/pihole/etc:/etc/pihole
      - /volume1/docker/pihole/dnsmasq:/etc/dnsmasq.d
    cap_add:
      - NET_ADMIN
    restart: unless-stopped

Praktische Anwendungsfälle

Development Environment

Isolierte Entwicklungsumgebung:

version: "3.8"
services:
  dev-environment:
    image: node:18-alpine
    container_name: dev-env
    working_dir: /app
    volumes:
      - /volume1/projects:/app
    ports:
      - "3000:3000"
      - "3001:3001"
    command: sh -c "npm install && npm run dev"
    restart: unless-stopped

Monitoring Stack

Grafana + Prometheus + Node Exporter:

version: "3.8"
services:
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    ports:
      - "9090:9090"
    volumes:
      - /volume1/docker/prometheus:/etc/prometheus
    command:
      - "--config.file=/etc/prometheus/prometheus.yml"
      - "--storage.tsdb.path=/prometheus"
      - "--web.console.libraries=/etc/prometheus/console_libraries"
      - "--web.console.templates=/etc/prometheus/consoles"

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    ports:
      - "3000:3000"
    volumes:
      - /volume1/docker/grafana:/var/lib/grafana
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin123

Backup-Lösung

Duplicati für automatisierte Backups:

version: "3.8"
services:
  duplicati:
    image: lscr.io/linuxserver/duplicati:latest
    container_name: duplicati
    environment:
      - PUID=1026
      - PGID=100
      - TZ=Europe/Berlin
    volumes:
      - /volume1/docker/duplicati:/config
      - /volume1:/source
      - /volume1/backups:/backups
    ports:
      - "8200:8200"
    restart: unless-stopped

Performance und Ressourcen-Management

Hardware-Ressourcen optimal nutzen

CPU-Zuteilung:

# Container CPU-Limits setzen
docker run --cpus="2.0" --memory="4g" nginx

# VMM: CPU-Reservierung für kritische VMs
# GUI: VM-Einstellungen > Hardware > CPU > Reservierung

Memory-Management:

# Docker Compose Resource-Limits
version: "3.8"
services:
  app:
    image: myapp:latest
    deploy:
      resources:
        limits:
          cpus: "2.0"
          memory: 4G
        reservations:
          cpus: "1.0"
          memory: 2G

Storage-Performance:

  • SSD-Cache für VM-Dateien aktivieren
  • NVMe-SSDs für Container-Volumes verwenden
  • RAID-1 für kritische VMs
  • Separate Volumes für Logs und temporäre Daten

Monitoring und Überwachung

Resource Monitor Integration:

  1. Systemsteuerung > Ressourcen-Monitor
  2. Virtualisierung-Tab für VM-Übersicht
  3. Container-Ressourcen in Container Station

Command Line Monitoring:

# SSH ins NAS
ssh admin@nas-ip

# Docker Stats
docker stats

# Top-Prozesse
htop

# VM-Status über CLI
# (VMM API calls falls verfügbar)

Sicherheit und Isolation

Netzwerk-Segmentierung

Separate VLANs für VMs:

  1. Switch konfigurieren mit VLAN-Support
  2. VMM > Netzwerk > Virtueller Switch
  3. VLAN-IDs zuweisen
  4. Firewall-Regeln zwischen VLANs

Container-Netzwerke:

version: "3.8"
networks:
  frontend:
    driver: bridge
  backend:
    driver: bridge
    internal: true # Kein Internet-Zugang

services:
  web:
    image: nginx
    networks:
      - frontend

  database:
    image: postgres
    networks:
      - backend

Zugriffskontrolle

VM-Berechtigungen:

  • Separate Benutzerkonten für VM-Verwaltung
  • Gruppe "vmm-user" für eingeschränkte Rechte
  • 2FA aktivieren für kritische VMs

Container-Security:

# Sichere Container-Konfiguration
version: "3.8"
services:
  secure-app:
    image: myapp:latest
    user: "1001:1001" # Non-root user
    read_only: true
    cap_drop:
      - ALL
    cap_add:
      - NET_BIND_SERVICE
    security_opt:
      - no-new-privileges:true

Backup-Strategien

VM-Backups

Automatisierte Snapshots:

  1. VMM > Virtuelle Maschine > Einstellungen
  2. Snapshot > Zeitplan aktivieren
  3. Aufbewahrungsrichtlinie festlegen
  4. Speicherort für Snapshots wählen

Replikation:

# VM-Replikation auf zweites NAS
# VMM > Replikation > Aufgabe erstellen
Quelle: Lokale VM
Ziel: Remote NAS (über QuickConnect oder VPN)
Zeitplan: Täglich 02:00 Uhr
Aufbewahrung: 7 Tage

Container-Backups

Volume-Backups:

#!/bin/bash
# Container-Backup-Script

# Container stoppen
docker stop container_name

# Volume sichern
docker run --rm \
  -v container_volume:/source:ro \
  -v /volume1/backups:/backup \
  alpine \
  tar czf /backup/container_name_$(date +%Y%m%d).tar.gz -C /source .

# Container starten
docker start container_name

Datenbank-Backups:

# PostgreSQL Backup
docker exec postgres_container \
  pg_dump -U username database_name > \
  /volume1/backups/db_backup_$(date +%Y%m%d).sql

# MySQL Backup
docker exec mysql_container \
  mysqldump -u root -p database_name > \
  /volume1/backups/mysql_backup_$(date +%Y%m%d).sql

Troubleshooting

Häufige VM-Probleme

VM startet nicht:

# Prüfungen:
1. Ausreichend RAM verfügbar?
2. Hardware-Virtualisierung aktiviert?
3. Storage-Pool hat freien Speicher?
4. ISO-Image korrekt gemountet?

# Logs prüfen:
# VMM > Virtuelle Maschine > Protokoll

Performance-Probleme:

  • CPU-Typ auf "Host" ändern für bessere Performance
  • Virtio-Treiber installieren
  • RAM-Balloning deaktivieren falls Issues
  • SSD-Cache aktivieren

Container-Debugging

Container startet nicht:

# Container-Logs prüfen
docker logs container_name

# Interactive debugging
docker run -it --entrypoint /bin/bash image_name

# Port-Konflikte prüfen
netstat -tulpn | grep :port_number

Network-Issues:

# Container-Netzwerk prüfen
docker network ls
docker network inspect bridge

# DNS-Tests
docker exec container_name nslookup google.com

Best Practices

Resource Planning

Sizing Guidelines:

Kleine Umgebung (4-8 GB RAM):
  - 2-3 Container ODER 1 kleine VM
  - Monitoring: Basis-Setup

Mittlere Umgebung (16-32 GB RAM):
  - 10-15 Container UND 1-2 VMs
  - Monitoring: Vollständiger Stack
  - Development: Separate Umgebungen

Große Umgebung (64+ GB RAM):
  - 20+ Container UND 3-5 VMs
  - Production-Workloads
  - Multi-Tenant-Setup

Wartung und Updates

Regelmäßige Aufgaben:

# Wöchentlich:
- Container-Images aktualisieren
- Ungenutzten Images aufräumen: docker system prune
- VM-Snapshots überprüfen

# Monatlich:
- VMM Tools in VMs aktualisieren
- Performance-Metriken analysieren
- Backup-Integrität testen

Dokumentation

Wichtige Informationen festhalten:

  • Container-Konfigurationen (docker-compose.yml)
  • VM-Spezifikationen und Zweck
  • Netzwerk-Topologie
  • Backup-Verfahren und Recovery-Tests
  • Passwörter und Zugangsdaten (sicher verwahrt)

Fazit

Virtualisierung und Container auf Synology NAS öffnen unendliche Möglichkeiten - von einfachen Heimserver-Anwendungen bis hin zu komplexen Entwicklungsumgebungen. Mit der richtigen Planung und Umsetzung wird dein NAS zum Herzstück deiner IT-Infrastruktur.

Nächste Schritte:

  1. Klein anfangen mit 1-2 Containern
  2. Monitoring einrichten für Ressourcen-Übersicht
  3. Backup-Strategie implementieren
  4. Schrittweise erweitern je nach Bedarf

Wichtiger Hinweis: Experimentiere zuerst in einer Testumgebung und führe regelmäßige Backups durch, bevor du produktive Systeme virtualisierst!