Physical Address

304 North Cardinal St.
Dorchester Center, MA 02124

Linux Administration #8: Virtualisierung und VM-Management

Linux Administration #8: Virtualisierung und VM-Management
Navigation

Willkommen zum achten und letzten Teil unserer technischen Wiki-Serie über Linux-Administration!

Nachdem wir in den vorherigen Artikeln die Grundlagen, Benutzerverwaltung, Prozesse, Netzwerkkonfiguration, Shell-Scripting, Backup-Strategien und Systemsicherheit behandelt haben, widmen wir uns heute der Virtualisierung und dem VM-Management. Die Virtualisierung ist heute ein fundamentaler Bestandteil moderner IT-Infrastrukturen.

Virtualisierungsgrundlagen

Die Virtualisierung ist eine fundamentale Technologie moderner IT-Infrastrukturen. Sie transformiert physische Serverressourcen in flexible, isolierte Umgebungen und ermöglicht dadurch eine effizientere Ressourcennutzung. Die Virtualisierung von Servern, Netzwerken und Storage-Systemen bildet heute das Rückgrat vieler Rechenzentren und Cloud-Umgebungen.

Markdown
Virtualisierungs-Ebenen:
┌─────────── Hardware ─────────────┐
│ Physischer Computer              │
│ (CPU, RAM, Festplatte)           │
├─────────── Hypervisor ───────────┤
│ Verwaltet und verteilt           │
│ alle Ressourcen                  │
├─────────── VMs ──────────────────┤
│ VM1   │ VM2     │ VM3   │ VM4    │
│ Linux │ Windows │ Linux │ BSD    │
└──────────────────────────────────┘

Warum Virtualisierung?

  • Ressourceneffizienz: Bessere Nutzung der Hardware
  • Isolation: Jede VM läuft unabhängig von den anderen
  • Flexibilität: Schnelles Erstellen und Löschen von VMs
  • Sicherheit: Getrennte Umgebungen für verschiedene Zwecke
  • Testing: Gefahrloses Testen neuer Konfigurationen

Hypervisor-Typen verstehen:

  1. Typ 1 (Bare-Metal)
    • Läuft direkt auf der Hardware
    • Höhere Leistung
    • Beispiele: KVM, VMware ESXi, Xen
    • Typisch für Server und Rechenzentren
  2. Typ 2 (Hosted)
    • Läuft als Programm auf einem Betriebssystem
    • Einfacher zu installieren und verwalten
    • Beispiele: VirtualBox, VMware Workstation
    • Gut für Desktop und Entwicklung

KVM/QEMU im Detail

KVM (Kernel-based Virtual Machine) und QEMU bilden das Fundament der Linux-Virtualisierung. KVM, als Kernel-Modul, stellt die Virtualisierungsfunktionen auf Hardware-Ebene bereit, während QEMU die Emulation der virtuellen Hardware übernimmt. Diese Kombination ermöglicht eine effiziente und flexible Virtualisierungsumgebung.

  • KVM ist der Grundriss und die Struktur
  • QEMU sind die Möbel und Einrichtung
  • Zusammen erschaffen sie komplette „Wohnungen“ (VMs)
Wie funktioniert das Zusammenspiel?
Markdown
Virtualisierungs-Stack im Detail:
┌─────────── Verwaltungstools ──────────┐
│ virt-manager (Grafische Oberfläche)   │
│ virsh (Kommandozeile)                 │
│ Cockpit (Weboberfläche)               │
├─────────── libvirt ───────────────────┤
│ Verwaltungs-API                       │
│ Konfigurationsverwaltung              │
│ VM-Definitionen                       │
├─────────── QEMU/KVM ──────────────────┤
│ QEMU: Hardware-Emulation              │
│ KVM: Kernel-Modul für Virtualisierung │
│ Ressourcen-Verwaltung                 │
├─────────── Hardware ──────────────────┤
│ CPU mit Virtualisierungsunterstützung │
│ Arbeitsspeicher                       │
│ Festplattenspeicher                   │
└───────────────────────────────────────┘
Installation Schritt für Schritt:

a) Prüfen der Hardware-Voraussetzungen

Bash
egrep -c '(vmx|svm)' /proc/cpuinfo

# Wenn die Ausgabe größer als 0 ist, unterstützt dein CPU Virtualisierung

b) Notwendige Pakete installieren

Bash
sudo apt install qemu-kvm libvirt-daemon-system libvirt-clients bridge-utils virtinst virt-manager

c) Benutzerrechte einrichten

Bash
sudo usermod -aG libvirt $USER
sudo usermod -aG kvm $USER

d) Dienste prüfen

Bash
sudo systemctl status libvirtd

# Sollte "active (running)" anzeigen

VM-Erstellung im Detail

Die Erstellung einer virtuellen Maschine ähnelt der Konfiguration eines physischen Systems. Die virtuellen Komponenten wie CPU, RAM und Festplatte werden dabei aus den Ressourcen des Host-Systems bereitgestellt und können flexibel an die jeweiligen Anforderungen angepasst werden.

a) Vorbereitung der Umgebung

Bash
# Storage-Pool für VM-Images erstellen

sudo virsh pool-define-as --name vmpool --type dir --target /var/lib/libvirt/images
Bash
# Storage-Pool aktivieren

sudo virsh pool-build vmpool
sudo virsh pool-start vmpool
sudo virsh pool-autostart vmpool

b) ISO-Image vorbereiten

Bash
# Verzeichnis für ISO-Images erstellen

sudo mkdir -p /var/lib/libvirt/images/iso
Bash
# ISO-Image herunterladen (Beispiel: Ubuntu Server)

sudo wget https://releases.ubuntu.com/22.04/ubuntu-22.04.3-live-server-amd64.iso \
     -O /var/lib/libvirt/images/iso/ubuntu-22.04.3-server.iso

c) VM über Kommandozeile erstellen

Bash
virt-install \
  --name ubuntu-server \            # Name der VM für die Verwaltung
  --memory 2048 \                   # Arbeitsspeicher in MB (hier 2GB)
  --vcpus 2 \                       # Anzahl virtueller CPU-Kerne
  --disk size=20,format=qcow2 \     # Festplattengröße und Format
  --os-variant ubuntu22.04 \        # Optimierungen für das Betriebssystem
  --network bridge=virbr0 \         # Netzwerkkonfiguration
  --graphics vnc \                  # Grafische Konsole via VNC
  --console pty,target_type=serial  # Textkonsole für die Installation

d) Parameter im Detail erklärt:

  1. –memory (RAM-Zuweisung)
    • Minimum: 1024 MB für moderne Systeme
    • Empfohlen: 2048 MB für Server
    • Maximum: Abhängig vom Host-System
    • Tipp: Lass noch genug RAM für das Host-System
  2. –vcpus (Virtuelle CPUs)
    • Minimum: 1 CPU für basic Server
    • Standard: 2 CPUs für normale Workloads
    • Maximum: Nicht mehr als physische CPU-Kerne
    • Tipp: Reserviere Kerne für das Host-System
  3. –disk (Festplattenkonfiguration)
    • size: Größe in GB
    • format:
      • qcow2: Dynamisch wachsend, platzsparend
      • raw: Feste Größe, bessere Performance
    • Tipp: Plane genug Speicherplatz für Updates ein
  4. –network (Netzwerkanbindung)
    • bridge: Direkter Netzwerkzugang
    • nat: Über Host geroutet (Standard)
    • none: Kein Netzwerk
    • Tipp: virbr0 ist die Standard-NAT-Brücke

e) Erweiterte Netzwerk-Optionen

Die Netzwerkkonfiguration ist entscheidend für die Kommunikation deiner VMs. Es gibt verschiedene Netzwerk-Modi, die für unterschiedliche Anwendungsfälle geeignet sind:

Markdown
Netzwerk-Modi:
┌─────────── NAT ──────────────────┐
│ - Standard-Modus                 │
│ - Internet über Host             │
│ - VM von außen nicht sichtbar    │
├─────────── Bridge ───────────────┤
│ - Direkter Netzwerkzugriff       │
│ - VM wie physischer Computer     │
│ - Voller Netzwerkzugang          │
├─────────── Internal ─────────────┤
│ - Nur VM-zu-VM Kommunikation     │
│ - Isoliertes Netzwerk            │
│ - Höhere Sicherheit              │
└──────────────────────────────────┘

NAT-Netzwerk erstellen:

Bash
virsh net-define nat-network.xml
virsh net-start nat-network
virsh net-autostart nat-network

Bridge-Netzwerk einrichten:

Bash
# In /etc/network/interfaces:

auto br0
iface br0 inet dhcp
    bridge_ports enp0s3
    bridge_stp on
    bridge_fd 0

VM-Verwaltung und Monitoring

Die Verwaltung virtueller Maschinen gehört zu den Kernaufgaben in der Virtualisierungsumgebung. VMs sind eigenständige Systeme, die auf einem physischen Host-System laufen. Ihre effiziente Verwaltung und kontinuierliche Überwachung sind entscheidend für einen stabilen Betrieb.

Markdown
VM-Management-Komponenten:
┌─────────── Verwaltung ───────────────┐
│ - Start/Stop/Pause                   │
│ - Snapshots                          │
│ - Backup/Restore                     │
├─────────── Monitoring ───────────────┤
│ - Ressourcenauslastung               │
│ - Performance-Metriken               │
│ - Systemzustand                      │
├─────────── Wartung ──────────────────┤
│ - Updates                            │
│ - Optimierung                        │
│ - Troubleshooting                    │
└──────────────────────────────────────┘

a) Grundlegende VM-Verwaltung

Deine VMs haben verschiedene Zustände:

  • Gestartet (running): VM läuft und verbraucht Ressourcen
  • Angehalten (paused): VM ist pausiert, aber noch im Speicher
  • Ausgeschaltet (shutdown): VM ist komplett heruntergefahren
  • Gespeichert (saved): Zustand wurde gespeichert für späteren Start
Bash
# VM-Status anzeigen
virsh list --all

# Zeigt:
Id   Name           Status
--------------------------------
1    ubuntu-server  running
-    debian-test    shut off

b) Tägliche Verwaltungsaufgaben

VM starten:

Bash
# VM normal starten
virsh start ubuntu-server

# Status überprüfen
virsh domstate ubuntu-server

VM herunterfahren:

Bash
# Sanftes Herunterfahren (wie Power-Button drücken)
virsh shutdown ubuntu-server

# Wenn die VM nicht reagiert (wie Stecker ziehen - nur im Notfall!)
virsh destroy ubuntu-server

c) Snapshot-Verwaltung

Ein Snapshot ist wie ein Foto deiner VM zu einem bestimmten Zeitpunkt. Du kannst später zu diesem Zustand zurückkehren, wenn etwas schiefgeht.

Markdown
Snapshot-Typen:
┌─────────── Disk-Only ────────────┐
│ - Nur Festplattenzustand         │
│ - Weniger Speicherplatz          │
│ - VM muss laufen                 │
├─────────── Internal ─────────────┤
│ - Kompletter VM-Zustand          │
│ - Inkl. RAM-Inhalt               │
│ - VM wird pausiert               │
└──────────────────────────────────┘

Snapshots erstellen und verwalten:

Bash
# Snapshot erstellen
virsh snapshot-create-as ubuntu-server snapshot1 "Vor dem Update" --disk-only --atomic
    
# Snapshot mit RAM-Zustand
virsh snapshot-create-as ubuntu-server snapshot2 "Vor Update" --memspec file=/path/to/ram.img

# Alle Snapshots anzeigen
virsh snapshot-list ubuntu-server

# Snapshot-Details anzeigen
virsh snapshot-info ubuntu-server snapshot1

# Zu Snapshot zurückkehren
virsh snapshot-revert ubuntu-server snapshot1
Markdown
Snapshot-Hierarchie:
Base Image
    │
    ├── Snapshot 1 (Nach Installation)
    │   └── Snapshot 2 (Nach Updates)
    │       └── Snapshot 3 (Aktuell)
    └── Backup-Snapshot

Wichtige Hinweise für Snapshots:

  • Vor großen Änderungen (Updates, Konfigurationen) Snapshot erstellen
  • Snapshots sind kein Backup-Ersatz
  • Regelmäßig alte Snapshots aufräumen
  • Disk-Only Snapshots sparen Speicherplatz
  • Performance-Einbußen bei vielen Snapshots beachten

e) Praktisches VM-Monitoring

Die kontinuierliche Überwachung virtueller Maschinen ist ein zentraler Aspekt des VM-Managements. Ein effektives Monitoring hilft dabei, Performance-Probleme frühzeitig zu erkennen und die Ressourcennutzung zu optimieren.

Hier sind die wichtigsten Monitoring-Werkzeuge:

Markdown
Monitoring-Bereiche:
┌─────────── Ressourcen ───────────┐
│ CPU-Auslastung                   │
│ Arbeitsspeicher                  │
│ Festplattennutzung               │
├─────────── Status ───────────────┤
│ Laufzeit                         │
│ Netzwerkaktivität                │
│ Systemzustand                    │
├─────────── Protokolle ───────────┤
│ Systemlogs                       │
│ Fehlermeldungen                  │
│ Performance-Daten                │
└──────────────────────────────────┘

Grundlegende Monitoring-Befehle:

Bash
# Detaillierte Informationen über eine VM
virsh dominfo ubuntu-server

# Zeigt:
# - CPU-Nutzung
# - Speicherauslastung
# - Laufzeit
# - Status

# Echtzeit-Statistiken
virt-top

# Ähnlich wie 'top', aber speziell für VMs:
# - CPU-Auslastung pro VM
# - Speichernutzung
# - I/O-Aktivität
Markdown
VM-Monitoring-System:
┌─────────── Host-System ──────────────────────┐
│ ┌─── VM1 ───┐ ┌─── VM2 ───┐ ┌─── VM3 ───┐    │
│ │CPU: 30%   │ │CPU: 50%   │ │CPU: 20%   │    │
│ │RAM: 2GB   │ │RAM: 4GB   │ │RAM: 1GB   │    │
│ │Disk: 50%  │ │Disk: 70%  │ │Disk: 30%  │    │
│ └───────────┘ └───────────┘ └───────────┘    │
│                                              │
│ ┌─────────── Monitoring-Tools ────────────┐  │
│ │ - virsh domstats    → Status & Stats    │  │
│ │ - virt-top         → Live-Monitoring    │  │
│ │ - domblkstat      → Disk-Performance    │  │
│ │ - domifstat      → Netzwerk-Stats       │  │
│ └─────────────────────────────────────────┘  │
└──────────────────────────────────────────────┘

Monitoring-Fluss:
┌─── Datensammlung ──┐     ┌── Analyse ───┐     ┌── Aktion ───┐
│ CPU-Nutzung        │ ──> │ Auswertung   │ ──> │ Warnungen   │
│ RAM-Auslastung     │     │ Trends       │     │ Anpassung   │
│ Disk-I/O           │     │ Grenzwerte   │     │ Skalierung  │
└────────────────────┘     └──────────────┘     └─────────────┘

f) Erweiterte Monitoring-Funktionen

Ein proaktives Monitoring-System ermöglicht es, potenzielle Probleme frühzeitig zu erkennen und zu beheben. Dabei spielen verschiedene Metriken eine wichtige Rolle.

Markdown
Monitoring-Bereiche:
┌─────────── Performance ───────────┐
│ CPU-Auslastung                    │
│ Arbeitsspeicher                   │
│ Festplattennutzung                │
├─────────── Netzwerk ──────────────┤
│ Durchsatz                         │
│ Latenz                            │
│ Verbindungen                      │
├─────────── Status ────────────────┤
│ Verfügbarkeit                     │
│ Dienste                           │
│ Fehler                            │
└───────────────────────────────────┘

Performance-Überwachung:

Bash
# CPU und Speicher einer VM überwachen
virt-top

# Detaillierte VM-Statistiken
virsh domstats ubuntu-server

# Ressourcennutzung anzeigen
virsh dommemstat ubuntu-server
virsh cpu-stats ubuntu-server

Netzwerk-Monitoring:

Bash
# Netzwerkschnittstellen anzeigen
virsh domiflist ubuntu-server

# Netzwerkstatistiken
virsh domifstat ubuntu-server vnet0

Festplatten-Monitoring:

Bash
# Festplattennutzung anzeigen
virsh domblklist ubuntu-server

# Detaillierte Blockgeräte-Statistiken
virsh domblkstat ubuntu-server vda

g) Best Practices für VM-Monitoring

Markdown
Monitoring-Strategie:
┌─────────── Grundüberwachung ─────────┐
│ - CPU-Auslastung                     │
│ - RAM-Nutzung                        │
│ - Festplattenspace                   │
│ - Netzwerkauslastung                 │
├─────────── Erweitert ────────────────┤
│ - Performance-Metriken               │
│ - Dienste-Status                     │
│ - Log-Analyse                        │
├─────────── Automatisierung ──────────┤
│ - Warnmeldungen                      │
│ - Reports                            │
│ - Trending                           │
└──────────────────────────────────────┘

Praktische Implementierung:

Regelmäßige Überprüfungen:

Bash
# Stündliche Ressourcenprüfung
watch -n 3600 'virsh domstats ubuntu-server | grep "cpu\|balloon"'

# Tägliche Disk-Prüfung
virsh domblkstat ubuntu-server vda --human

# Wöchentliche Performance-Analyse
virt-top -n 1 > /var/log/vm_performance_$(date +%Y%m%d).log

Warnmeldungen einrichten:

Bash
# Beispiel-Skript für Ressourcen-Warnung
if virsh dommemstat ubuntu-server | awk '/actual/ {if($2>90) print "Warning: High Memory Usage"}'; then
    echo "VM Memory Critical" | mail -s "VM Alert" admin@domain.com
fi

VM Backup und Migration

1. BackUp

Die regelmäßige Sicherung virtueller Maschinen ist ein kritischer Aspekt des VM-Managements. Ein durchdachtes Backup-Konzept schützt nicht nur vor Datenverlust, sondern ermöglicht auch eine schnelle Wiederherstellung im Fehlerfall.

Markdown
Backup-Arten:
┌─────────── Vollbackup ───────────┐
│ - Komplette VM                   │
│ - Alle Daten                     │
│ - Hoher Speicherbedarf           │
├─────────── Inkrementell ─────────┤
│ - Nur Änderungen                 │
│ - Platzsparend                   │
│ - Schneller                      │
├─────────── Snapshot ─────────────┤
│ - Momentaufnahme                 │
│ - Für Tests & Updates            │
│ - Temporär                       │
└──────────────────────────────────┘

Backup-Prozess:
Source VM ──> Backup-Tool ──> Storage
    │            │             │
    │            │             └── Ziel
    │            └──────────────── Methode
    └────────────────────────────── Quelle

a) Praktische Backup-Methoden

Es gibt verschiedene Backup-Methoden die du kennen und erlernen sollst, damit du diese anwenden kannst:

Markdown
Backup-Methoden:
┌─────────── Vollbackup ───────────┐
│ - Komplette VM                   │
│ - Alle Daten                     │
│ - Hoher Speicherbedarf           │
├─────────── Inkrementell ─────────┤
│ - Nur Änderungen                 │
│ - Platzsparend                   │
│ - Schneller                      │
├─────────── Differentiell ────────┤
│ - Änderungen seit Vollbackup     │
│ - Mittlerer Speicherbedarf       │
│ - Schnelle Wiederherstellung     │
└──────────────────────────────────┘

Backup-Prozess:
VM ──> Vorbereitung ──> Sicherung ──> Verifizierung
 │          │             │            │
 │          │             │            └── Test
 │          │             └────────────── Kopie
 │          └────────────────────────── Snapshot
 └──────────────────────────────────── Quell-VM

b) Vollständiges VM-Backup

Bash
# VM anhalten (wenn offline Backup)
virsh shutdown ubuntu-server

# Konfiguration sichern
virsh dumpxml ubuntu-server > /backup/ubuntu-server.xml

# Disk-Image kopieren
cp /var/lib/libvirt/images/ubuntu-server.qcow2 /backup/

c) Inkrementelle Backup-Methoden

Inkrementelle Backups speichern nur die Änderungen seit dem letzten Backup. Das spart Speicherplatz und Zeit.

Markdown
Backup-Hierarchie:
┌─────────── Vollbackup ───────────┐
│ Tag 1: Komplettes System         │
├─────────── Inkrementell ─────────┤
│ Tag 2: Nur neue/geänderte        │
│        Dateien                   │
├─────────── Inkrementell ─────────┤
│ Tag 3: Nur neue/geänderte        │
│        Dateien                   │
└──────────────────────────────────┘

Wiederherstellungsprozess:

Vollbackup → Inkr.1 → Inkr.2 → Inkr.3
    │          │        │        │
    └──────────┴────────┴────────┘
     Alle werden nacheinander
     eingespielt

Praktische Implementierung:

Bash
# Vollbackup erstellen (Tag 1)
qemu-img create -f qcow2 ubuntu-server-base.qcow2

# Inkrementelles Backup (Tag 2)
qemu-img create -f qcow2 -b ubuntu-server-base.qcow2 ubuntu-server-inkr1.qcow2

# Weiteres inkrementelles Backup (Tag 3)
qemu-img create -f qcow2 -b ubuntu-server-inkr1.qcow2 ubuntu-server-inkr2.qcow2

d) Backup-Best-Practices

Eine durchdachte Backup-Strategie ist fundamental für den sicheren Betrieb virtueller Maschinen. Die folgenden Praktiken haben sich in der professionellen Systemadministration bewährt.

Markdown
Backup-Strategie:
┌─────────── Planung ─────────────┐
│ - Was wird gesichert?           │
│ - Wie oft wird gesichert?       │
│ - Wo wird gesichert?            │
├─────────── Durchführung ────────┤
│ - Automatisierung               │
│ - Monitoring                    │
│ - Verifizierung                 │
├─────────── Wiederherstellung ───┤
│ - Test-Prozeduren               │
│ - Dokumentation                 │
│ - Notfallplan                   │
└─────────────────────────────────┘

1. Die 3-2-1 Backup-Regel:

  • 3 Kopien deiner Daten
  • 2 verschiedene Speichermedien
  • 1 Kopie an einem anderen Ort

2. Automatisierung mit Cron:

ShellScript
# Backup-Skript Beispiel
#!/bin/bash
# VM herunterfahren oder Snapshot erstellen
virsh shutdown ubuntu-server
# Warten bis VM gestoppt ist
sleep 30
# Backup erstellen
cp /var/lib/libvirt/images/ubuntu-server.qcow2 /backup/
# VM wieder starten
virsh start ubuntu-server
Bash
# Tägliches Backup um 2 Uhr morgens
0 2 * * * /usr/local/bin/vm-backup.sh
2. Migration

Als Administrator musst du manchmal VMs von einem Host auf einen anderen verschieben. Das kann verschiedene Gründe haben:

  • Hardware-Upgrades
  • Lastverteilung
  • Wartungsarbeiten
  • Disaster Recovery
Markdown
Migrations-Arten:
┌─────────── Live-Migration ─────────┐
│ - VM läuft während Migration       │
│ - Minimale Ausfallzeit             │
│ - Für kritische Systeme            │
├─────────── Cold-Migration ─────────┤
│ - VM wird gestoppt                 │
│ - Kompletter Transfer              │
│ - Längere Downtime                 │
└────────────────────────────────────┘

Migrations-Prozess:
Source Host ────> Transfer ────> Target Host
    │              │              │
    │              │              └── VM-Start
    │              └─────────────── Daten-Transfer
    └────────────────────────────── VM-Vorbereitung

a) Voraussetzungen für Migration

Bash
# Auf beiden Hosts:
# 1. Gleiche libvirt-Version
libvirtd --version

# 2. Netzwerkverbindung prüfen
ping ziel-host

# 3. Gemeinsamer Storage oder ausreichend Platz
df -h /var/lib/libvirt/images/

b) Praktische Migrationsbeispiele

Die Migration virtueller Maschinen ist ein komplexer Prozess, der verschiedene Techniken und Methoden umfasst. Je nach Anforderung und Szenario kommen unterschiedliche Migrationsstrategien zum Einsatz.

Markdown
Migrations-Arten im Detail:
┌─────────── Live-Migration ──────────┐
│ VM läuft während der Migration      │
│ Minimale Ausfallzeit                │
│ Für kritische Systeme               │
├─────────── Storage-Migration ───────┤
│ Nur Festplatten werden bewegt       │
│ VM kann weiterlaufen                │   
│ Für Speicheroptimierung             │
├─────────── Cold-Migration ──────────┤
│ VM wird gestoppt                    │
│ Kompletter Transfer                 │
│ Für unkritische Systeme             │
└─────────────────────────────────────┘

Live-Migration durchführen:

Bash
# Voraussetzungen prüfen
# 1. Netzwerkverbindung testen
ping ziel-host

# 2. SSH-Zugriff einrichten
ssh-copy-id ziel-host

# 3. Gemeinsamen Storage prüfen
virsh pool-list --all

# Live-Migration starten
virsh migrate --live ubuntu-server qemu+ssh://ziel-host/system --verbose --persistent --undefinesource

Storage-Migration

Die Storage-Migration ist wie ein Umzug deiner VM-Festplatten. Dies kann notwendig sein für:

  • Performance-Optimierung
  • Speicherplatz-Management
  • Hardware-Upgrades
  • Wartungsarbeiten
Markdown
Storage-Migration-Typen:
┌─────────── Offline ──────────────┐
│ - VM ist gestoppt                │
│ - Sicherer Transfer              │
│ - Längere Downtime               │
├─────────── Online ───────────────┤
│ - VM läuft weiter                │
│ - Minimale Unterbrechung         │
│ - Höhere Komplexität             │
└──────────────────────────────────┘

Migration-Prozess:
Quelle ─────> Transfer ─────> Ziel
   │            │            │
   │            │            └── Verifizierung
   │            └─────────────── Kopiervorgang
   └──────────────────────────── Vorbereitung

Praktische Beispiele:

Bash
# VM herunterfahren
virsh shutdown ubuntu-server

# Storage migrieren
virsh vol-download --pool default ubuntu-server.qcow2 /backup/
virsh vol-upload --pool new_storage ubuntu-server.qcow2 /backup/

# VM-Konfiguration anpassen
virsh edit ubuntu-server

Cold-Migration

Eine Cold-Migration ist eine Methode, um VMs von einem Host zu einem anderen zu verschieben, wobei die VM während des Transfers ausgeschaltet ist.

Markdown
Cold-Migration-Prozess:
┌─────────── Vorbereitung ─────────┐
│ 1. VM herunterfahren             │
│ 2. Ressourcen prüfen             │
│ 3. Netzwerk testen               │
├─────────── Transfer ─────────────┤
│ 4. VM-Dateien kopieren           │
│ 5. Konfiguration anpassen        │
├─────────── Aktivierung ──────────┤
│ 6. VM auf Ziel starten           │
│ 7. Funktionstest durchführen     │
└──────────────────────────────────┘

Vorteile der Cold-Migration:

  • Sicherer Transfer ohne Datenverlust
  • Keine Ressourcenkonflikte während der Migration
  • Ermöglicht Migration zwischen verschiedenen CPU-Architekturen (z.B. Intel zu AMD)
  • Höhere Kompatibilität als Live-Migration

Nachteile:

  • Geplante Downtime erforderlich
  • Dienste sind während der Migration nicht verfügbar
  • Längere Unterbrechung des Betriebs

Praktische Beispiele:

Bash
# 1. VM herunterfahren
virsh shutdown ubuntu-server
# Warten bis VM gestoppt ist
virsh list --all | grep ubuntu-server

# 2. VM-Konfiguration exportieren
virsh dumpxml ubuntu-server > ubuntu-server.xml

# 3. VM-Dateien auf Zielhost kopieren
scp /var/lib/libvirt/images/ubuntu-server.qcow2 \
    ziel-host:/var/lib/libvirt/images/
scp ubuntu-server.xml ziel-host:/tmp/

# 4. Auf Zielhost: VM definieren
virsh define /tmp/ubuntu-server.xml

# 5. VM auf Zielhost starten
virsh start ubuntu-server
3. Best Practices für VM-Backup und Migration
Markdown
Best Practices Übersicht:
┌─────────── Backup ─────────────────┐
│ - Regelmäßige Sicherungen          │
│ - Verschiedene Backup-Typen        │
│ - Backup-Tests                     │
├─────────── Migration ──────────────┤
│ - Voraussetzungen prüfen           │
│ - Downtime minimieren              │
│ - Rollback-Plan erstellen          │
├─────────── Dokumentation ──────────┤
│ - Konfigurationen                  │
│ - Prozeduren                       │
│ - Wiederherstellungspläne          │
└────────────────────────────────────┘

a) Backup Best Practices:

  • Regelmäßige Backups nach festem Zeitplan
  • Kombination aus Voll- und inkrementellen Backups
  • Backups auf externen Speichermedien
  • Regelmäßige Wiederherstellungstests
  • Dokumentation der Backup-Prozeduren

b) Migrations Best Practices:

  • Ausführliche Planung und Vorbereitung
  • Kompatibilitätsprüfung der Systeme
  • Test-Migration vor der eigentlichen Migration
  • Backup vor der Migration
  • Dokumentierte Rollback-Strategie

Container-Virtualisierung

1. Docker

Container sind eine leichtgewichtige Alternative zu vollständigen virtuellen Maschinen sind. Stell dir Container wie kleine, isolierte Apartments in einem großen Gebäude vor, die sich alle dasselbe Fundament (den Kernel) teilen.

Markdown
Virtualisierungs-Vergleich:
┌─────────── Klassische VM ──────────┐
│ App 1   │   App 2   │   App 3      │
│ Libs    │   Libs    │   Libs       │
│ OS      │   OS      │   OS         │
├─────────── Hypervisor ─────────────┤
│           Hardware                 │
└────────────────────────────────────┘

┌─────────── Container ──────────────┐
│ App 1 │ App 2 │ App 3              │
│ Libs  │ Libs  │ Libs               │
├─────────── Container Engine ───────┤
│           OS Kernel                │
│           Hardware                 │
└────────────────────────────────────┘

Vorteile von Containern:

  • Schnellerer Start (Sekunden statt Minuten)
  • Weniger Ressourcenverbrauch
  • Einfachere Verteilung
  • Konsistente Umgebungen

a) Praktische Container-Beispiele

Es wichtig zu verstehen, wie Container in der Praxis eingesetzt werden:

Markdown
Container vs. VM:
┌─────────── Container ────────────┐
│ App 1  │  App 2  │  App 3        │
│ Libs   │  Libs   │  Libs         │
├─────────── Docker Engine ────────┤
│        Betriebssystem            │ 
│           Hardware               │
└──────────────────────────────────┘

┌─────────── VMs ──────────────────┐
│ App+OS │  App+OS │  App+OS       │
│ Kernel │  Kernel │  Kernel       │
├─────────── Hypervisor ───────────┤
│           Hardware               │
└──────────────────────────────────┘

Container erstellen und verwalten:

Bash
# Docker installieren
sudo apt install docker.io

# Status prüfen
sudo systemctl status docker

# Erstes Container-Image herunterladen
sudo docker pull ubuntu:latest

# Container starten
sudo docker run -it ubuntu:latest /bin/bash

Container-Netzwerke und Storage

Container müssen miteinander und mit der Außenwelt kommunizieren können. Außerdem brauchen sie Speicherplatz für ihre Daten.

Markdown
Container-Netzwerk-Typen:
┌─────────── Bridge ──────────────┐
│ - Standard-Netzwerk             │
│ - Container ↔ Container         │
│ - Container ↔ Internet          │    
├─────────── Host ────────────────┤
│ - Teilt Host-Netzwerk           │
│ - Direkte Performance           │
│ - Weniger Isolation             │
├─────────── None ────────────────┤
│ - Kein Netzwerk                 │
│ - Maximale Isolation            │
│ - Nur lokaler Zugriff           │
└─────────────────────────────────┘

Container-Storage:
┌─────────── Volumes ─────────────┐
│ /var/lib/docker/volumes         │
│ ├── Web-Daten                   │
│ ├── Datenbank                   │
│ └── Konfiguration               │
├─────────── Bind Mounts ─────────┤
│ Host ←→ Container               │
│ Direktes Dateisystem            │
└─────────────────────────────────┘

Netzwerk-Konfiguration:

Bash
# Netzwerke anzeigen
docker network ls

# Neues Netzwerk erstellen
docker network create mein-netzwerk

# Container mit Netzwerk verbinden
docker run -d --network mein-netzwerk --name webserver nginx

c) Container-Orchestrierung

Container-Orchestrierung hilft dir, viele Container effizient zu verwalten und zu koordinieren. Stell dir das wie einen Dirigenten vor, der ein großes Orchester leitet.

Markdown
Container-Orchestrierung:
┌─────────── Kubernetes ───────────┐
│ Master Node                      │
│ ├── API Server                   │
│ ├── Scheduler                    │
│ └── Controller Manager           │
├─────────── Worker Nodes ─────────┤
│ ├── Container Runtime            │
│ ├── kubelet                      │
│ └── kube-proxy                   │
└──────────────────────────────────┘

Container-Lebenszyklus:
Image ──> Container ──> Pod ──> Service
  │         │           │         │
  │         │           │         └── Netzwerk
  │         │           └──────────── Gruppierung
  │         └──────────────────────── Ausführung
  └────────────────────────────────── Template

Praktische Beispiele mit Docker Compose:

Bash
# Docker Compose installieren
sudo apt install docker-compose

# Einfache Compose-Datei erstellen
cat << EOF > docker-compose.yml
version: '3'
services:
  web:
    image: nginx
    ports:
      - "80:80"
  db:
    image: mysql
    environment:
      MYSQL_ROOT_PASSWORD: example
EOF

# Container starten
docker-compose up -d

d) Fortgeschrittene Container-Orchestrierung

Markdown
Orchestrierungs-Ebenen:
┌─────────── Kubernetes ───────────┐
│ Master                           │
│ ├── API Server                   │
│ ├── Scheduler                    │
│ └── Controller                   │
├─────────── Worker Nodes ─────────┤
│ ├── Container Runtime            │
│ ├── kubelet                      │
│ └── Services                     │
└──────────────────────────────────┘

Deployment-Prozess:
Pod ──> ReplicaSet ──> Deployment ──> Service
 │          │             │            │
 │          │             │            └── Netzwerk
 │          │             └────────────── Skalierung
 │          └──────────────────────────── Redundanz
 └─────────────────────────────────────── Container

Praktische Beispiele:

Bash
# Kubernetes Cluster Status
kubectl get nodes
kubectl get pods --all-namespaces

# Deployment erstellen
kubectl create deployment web-app --image=nginx:latest --replicas=3

# Service erstellen
kubectl expose deployment web-app --port=80 --type=LoadBalancer

e) Container-Sicherheit

Die Sicherheit von Containern ist ein kritischer Aspekt, den du als Administrator verstehen und implementieren musst.

Markdown
Container-Sicherheitsebenen:
┌─────────── Image-Sicherheit ─────────┐
│ - Vertrauenswürdige Quellen          │
│ - Vulnerability Scanning             │
│ - Image-Updates                      │
├─────────── Runtime-Sicherheit ───────┤
│ - Privilegien minimieren             │
│ - Ressourcen begrenzen               │
│ - Netzwerk-Isolation                 │
├─────────── Host-Sicherheit ──────────┤
│ - System-Updates                     │
│ - Zugriffskontrolle                  │
│ - Monitoring                         │
└──────────────────────────────────────┘

Grundlegende Sicherheitsmaßnahmen:

Bash
# Container nicht als Root ausführen
docker run --user 1000:1000 nginx

# Ressourcen begrenzen
docker run --memory=512m --cpus=1 nginx

# Privilegien einschränken
docker run --security-opt=no-new-privileges nginx

Best Practices für Container-Sicherheit:

  • Nur vertrauenswürdige Base Images verwenden
  • Regelmäßige Sicherheits-Updates durchführen
  • Container-Images auf Schwachstellen scannen
  • Netzwerkzugriff minimieren
  • Sensible Daten nicht im Container speichern

Fortgeschrittene Sicherheitskonzepte

Als Administrator musst du Container sicher betreiben. Hier sind die wichtigsten Sicherheitsaspekte:

Markdown
Container-Sicherheitsebenen:
┌─────────── Container ───────────┐
│ - Applikation                   │
│ - Bibliotheken                  │
│ - Konfiguration                 │
├─────────── Isolation ───────────┤
│ - Netzwerk                      │
│ - Prozesse                      │
│ - Dateisystem                   │
├─────────── Host-System ─────────┤
│ - Kernel                        │
│ - Ressourcen                    │
│ - Zugriffsrechte                │
└─────────────────────────────────┘

Container absichern:

Bash
# Container ohne Root-Rechte ausführen
docker run --user 1000:1000 nginx

# Ressourcen begrenzen
docker run --memory=512m --cpus=1 nginx

# Capabilities einschränken
docker run --cap-drop=ALL --cap-add=NET_BIND_SERVICE nginx

Best Practices für Container-Sicherheit:

  • Minimale Base Images verwenden
  • Regelmäßige Sicherheits-Updates
  • Keine sensiblen Daten in Images
  • Netzwerkzugriff beschränken
  • Container überwachen

g) Container-Überwachung

Die Überwachung von Containern ist ein essentieller Bestandteil des Container-Betriebs. Ein proaktives Monitoring ermöglicht die frühzeitige Erkennung von Performance-Engpässen und potenziellen Problemen.

Markdown
Container-Monitoring:
┌─────────── Ressourcen ───────────┐
│ - CPU-Auslastung                 │
│ - Speicherverbrauch              │
│ - Netzwerk-Traffic               │
├─────────── Logs ─────────────────┤
│ - Container-Logs                 │
│ - System-Logs                    │
│ - Application-Logs               │
├─────────── Status ───────────────┤
│ - Container-Zustand              │
│ - Dienste-Status                 │
│ - Health-Checks                  │
└──────────────────────────────────┘

Monitoring-Workflow:
Daten ──> Sammeln ──> Analysieren ──> Handeln
  │          │           │            │
  │          │           │            └── Anpassungen
  │          │           └─────────────── Auswertung
  │          └─────────────────────────── Metriken
  └────────────────────────────────────── Container

Praktische Monitoring-Befehle:

Bash
# Grundlegende Container-Informationen
docker ps
docker stats

# Detaillierte Container-Informationen
docker inspect container_name

# Container-Logs anzeigen
docker logs container_name

# Ressourcen-Nutzung in Echtzeit
docker stats --format "table {{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}"

h) Container Best Practices

Die professionelle Container-Verwaltung erfordert ein durchdachtes Konzept für Sicherheit und Effizienz. Die folgenden Best Practices haben sich in der Praxis bewährt.

Markdown
Container Best Practices:
┌─────────── Sicherheit ───────────┐
│ - Minimale Base Images           │
│ - Regelmäßige Updates            │   
│ - Least Privilege                │
├─────────── Performance ──────────┤
│ - Resource Limits                │
│ - Multi-Stage Builds             │
│ - Cache optimieren               │
├─────────── Management ───────────┤
│ - Klare Namensgebung             │
│ - Versionierung                  │
│ - Dokumentation                  │
└──────────────────────────────────┘

Sicherheits-Best-Practices:

Bash
# Minimales Base Image verwenden
FROM alpine:latest

# Als nicht-root Benutzer ausführen
USER nobody

# Ressourcen begrenzen
docker run --memory=512m --cpus=1 --security-opt=no-new-privileges meine-app

Performance-Best-Practices:

Bash
# Multi-Stage Build Beispiel
FROM node:alpine AS builder
WORKDIR /app
COPY . .
RUN npm install && npm run build

FROM nginx:alpine
COPY --from=builder /app/dist /usr/share/nginx/html

3. Management-Best-Practices:

  • Klare Image-Tags verwenden
  • Container regelmäßig aktualisieren
  • Logging und Monitoring einrichten
  • Backup-Strategien implementieren
2. LXC und LXD

LXC (Linux Containers) und LXD bieten eine systemnahe Virtualisierungslösung, die sich besonders für Server-Umgebungen eignet. Im Gegensatz zu Docker, das auf Anwendungs-Container spezialisiert ist, ermöglichen LXC/LXD das Betreiben vollständiger Linux-Systeme in einer isolierten Umgebung.

Markdown
Container-Technologien:
┌─────────── LXC ──────────────────┐
│ - System Container               │
│ - Vollständiges OS               │
│ - Kernel-Level Isolation         │
├─────────── LXD ──────────────────┤
│ - Management Layer               │
│ - Erweiterte Features            │
│ - REST API                       │
└──────────────────────────────────┘

Unterschied zu Docker:
LXC/LXD           vs     Docker
┌─────────┐              ┌─────────┐
│ System  │              │  App    │
│Container│              │Container│
└─────────┘              └─────────┘
    │                         │
Vollständiges          Einzelne App
    OS                  + Dependencies

a) Praktische LXC/LXD-Beispiele

LXC/LXD Container bieten eine ressourcenschonende Alternative zu klassischen virtuellen Maschinen. Im Gegensatz zu vollständigen VMs teilen sich diese Container den Kernel des Host-Systems und ermöglichen dadurch eine effizientere Nutzung der verfügbaren Ressourcen.

Markdown
Container-Struktur:
┌─────────── Host System ──────────┐
│ Linux Kernel & Betriebssystem    │
│                                  │
│ ┌─── LXC Container 1 ──┐         │
│ │ Dateisystem          │         │
│ │ Netzwerk             │         │
│ │ Prozesse             │         │
│ └──────────────────────┘         │
│                                  │
│ ┌─── LXC Container 2 ──┐         │
│ │ Dateisystem          │         │
│ │ Netzwerk             │         │
│ │ Prozesse             │         │
│ └──────────────────────┘         │
└──────────────────────────────────┘

Installation und erste Schritte:

Markdown
Installation-Abhängigkeiten:
┌─────────── LXD Paket ───────────┐
│ - LXD Daemon                    │
│ - LXC Bibliotheken              │
│ - LXC Tools                     │
├─────────── Automatisch ─────────┤
│ - liblxc1                       │
│ - lxcfs                         │
│ - lxc-common                    │
└─────────────────────────────────┘
Bash
# LXD installieren
sudo apt install lxd

# Dies installiert automatisch:
# - liblxc1 (LXC Bibliotheken)
# - lxc-common (Gemeinsame LXC Dateien)
# - lxcfs (LXC Dateisystem)

# LXD initialisieren
sudo lxd init

# Folge dem Assistenten für:
# - Speicher-Backend (dir oder zfs)
# - Netzwerk-Konfiguration
# - IPv4/IPv6-Einstellungen

# Ersten Container erstellen
lxc launch ubuntu:22.04 mein-container

Container-Verwaltung:

Bash
# Container-Status anzeigen
lxc list

# In Container wechseln
lxc exec mein-container -- bash

# Container stoppen/starten
lxc stop mein-container
lxc start mein-container

b) Container-Konfiguration

Die Konfiguration von LXC/LXD Containern ermöglicht eine präzise Anpassung der Ressourcen und Funktionen. Eine durchdachte Konfiguration ist entscheidend für die Performance und Sicherheit der Container-Umgebung.

Markdown
Container-Konfiguration:
┌─────────── Ressourcen ───────────┐
│ - CPU-Limits                     │
│ - RAM-Limits                     │
│ - Disk-Quotas                    │
├─────────── Netzwerk ─────────────┤
│ - Interfaces                     │
│ - IP-Adressen                    │
│ - Firewall                       │
├─────────── Storage ──────────────┤
│ - Volumes                        │
│ - Mounts                         │
│ - Snapshots                      │
└──────────────────────────────────┘

Ressourcen-Konfiguration:

Bash
# CPU-Limits setzen
lxc config set mycontainer limits.cpu 2

# RAM-Limits setzen (2GB)
lxc config set mycontainer limits.memory 2GB

# Disk-Quota (20GB)
lxc config set mycontainer limits.disk.size 20GB

Netzwerk-Konfiguration:

Bash
# Netzwerk-Interface hinzufügen
lxc config device add mycontainer eth0 nic \
    name=eth0 \
    nictype=bridged \
    parent=lxdbr0

# Statische IP setzen
lxc config device set mycontainer eth0 ipv4.address 192.168.1.100

c) LXC/LXD Container-Sicherheit

Die Sicherheit von LXC/LXD Containern ist ein kritischer Aspekt im professionellen Betrieb. Ein durchdachtes Sicherheitskonzept schützt sowohl die Container als auch das Host-System vor unberechtigten Zugriffen und potenziellen Sicherheitsrisiken.

Markdown
Sicherheitsebenen:
┌─────────── Container ────────────┐
│ - Unprivilegiert                 │
│ - Privilegiert                   │
│ - Root-Einschränkungen           │
├─────────── Host ─────────────────┤
│ - AppArmor/SELinux               │
│ - Ressourcenlimits               │
│ - Netzwerk-Isolation             │
├─────────── Storage ──────────────┤
│ - Verschlüsselung                │
│ - Quota                          │
│ - Snapshots                      │
└──────────────────────────────────┘

Unprivilegierte Container (empfohlen):

Markdown
┌─────────── Unprivilegiert ───────┐
│ - Eingeschränkte Rechte          │
│ - Sicherer                       │  
│ - Standard-Empfehlung            │
└──────────────────────────────────┘
Bash
# Container erstellen mit Sicherheitseinstellungen
lxc launch ubuntu:22.04 sicher-container \
    -c security.privileged=false \
    -c security.nesting=false \
    -c linux.kernel_modules=false

# Ressourcenlimits setzen
lxc config set sicher-container limits.memory 2GB
lxc config set sicher-container limits.cpu 2

Privilegierter Container

Markdown
Container-Privilegien:
┌─────────── Privilegiert ─────────┐
│ - Voller Systemzugriff           │
│ - Gefährlich!                    │
│ - Nur für spezielle Fälle        │
└──────────────────────────────────┘
Bash
# Privilegierten Container erstellen
lxc launch ubuntu:22.04 priv-container \
    -c security.privileged=true \
    -c security.nesting=true \
    -c linux.kernel_modules=true

# Container-Status überprüfen
lxc config show priv-container | grep security

WICHTIG: Sicherheitsrisiken

  • Privilegierte Container haben vollen Systemzugriff
  • Können auf Host-Hardware zugreifen
  • Können Kernel-Module laden
  • Sollten nur in Testumgebungen verwendet werden
  • Nie in Produktivumgebungen einsetzen

AppArmor-Profile konfigurieren:

Bash
# AppArmor-Status prüfen
sudo aa-status

# Container mit spezifischem Profil
lxc config set secure-container \
    lxc.apparmor.profile=lxc-container-default-cgns

# Eigenes Profil erstellen
sudo nano /etc/apparmor.d/lxc-secure

Seccomp-Filter anwenden:

Bash
# Standard Seccomp-Filter aktivieren
lxc config set secure-container \
    lxc.seccomp.profile=default

# Erweiterte Einschränkungen
lxc config set secure-container \
    security.syscalls.blacklist=mount,umount2

d) Verschlüsselung, Quota und Snapshots

Markdown
Container-Management:
┌─────────── Verschlüsselung ────────┐
│ - LUKS Encryption                  │
│ - Storage Pool Security            │
│ - Zugriffsschutz                   │
├─────────── Quota ──────────────────┤
│ - Speicherplatz-Limits             │
│ - Ressourcen-Kontrolle             │
│ - Überwachung                      │
├─────────── Snapshots ──────────────┤
│ - Momentaufnahmen                  │
│ - Backup & Restore                 │ 
│ - Versionierung                    │
└────────────────────────────────────┘

Container-Verschlüsselung:

Bash
# Storage-Pool mit LUKS verschlüsseln
lxc storage create encrypted_pool dir \
    source=/encrypted/pool \
    security.luks=true

# Container im verschlüsselten Pool erstellen
lxc launch ubuntu:22.04 secure-container \
    -s encrypted_pool

Quota-Management:

Bash
# Speicherplatz-Limit setzen
lxc config set mein-container limits.disk.size 10GB

# RAM-Limit setzen
lxc config set mein-container limits.memory 2GB

Snapshot-Verwaltung:

Bash
# Snapshot erstellen
lxc snapshot mein-container snap01

# Snapshot wiederherstellen
lxc restore mein-container snap01

# Snapshots auflisten
lxc info mein-container

e) Best Practices für LXC/LXD

  • Regelmäßige Snapshots erstellen
  • Klare Namenskonventionen verwenden
  • Container-Konfigurationen dokumentieren
  • Monitoring-Strategie implementieren
  • Backup-Plan entwickeln und testen

Übung

Virtualisierungsumgebung aufsetzen

Szenario: Du bist Junior System Administrator in einem mittelständischen Unternehmen. Deine Aufgabe ist es, eine Test-Umgebung für die Entwicklungsabteilung aufzusetzen.

Markdown
Anforderungen:
┌─────────── Entwicklungsserver ───────┐
│ - Ubuntu Server 22.04 LTS            │
│ - 4GB RAM, 2 vCPUs                   │
│ - 50GB Speicher                      │
├─────────── Testserver ───────────────┤
│ - Debian 12                          │
│ - 2GB RAM, 1 vCPU                    │
│ - 20GB Speicher                      │
├─────────── Monitoring ───────────────┤
│ - LXC Container                      │
│ - Prometheus + Grafana               │
│ - 1GB RAM                            │
└──────────────────────────────────────┘

Aufgaben:

  1. VM-Setup
    • Erstelle beide VMs mit den angegebenen Spezifikationen
    • Konfiguriere Netzwerk für Kommunikation zwischen VMs
    • Erstelle Snapshots nach Basisinstallation
  2. Backup-Konfiguration
    • Richte tägliche Backups ein
    • Implementiere Snapshot-Rotation (max. 7 Snapshots)
    • Teste die Wiederherstellung
  3. Container-Setup
    • Erstelle LXC Container für Monitoring
    • Konfiguriere Netzwerkzugriff
    • Implementiere Basis-Sicherheit

Mögliche Lösung:

VM-Setup:

Bash
# Entwicklungsserver erstellen
virt-install \
  --name dev-server \
  --memory 4096 \
  --vcpus 2 \
  --disk size=50 \
  --os-variant ubuntu22.04 \
  --network bridge=virbr0 \
  --location 'http://archive.ubuntu.com/ubuntu/dists/jammy/main/installer-amd64/'

# Testserver erstellen
virt-install \
  --name test-server \
  --memory 2048 \
  --vcpus 1 \
  --disk size=20 \
  --os-variant debian12 \
  --network bridge=virbr0

# Snapshots erstellen
virsh snapshot-create-as dev-server snap01 "Nach Installation"
virsh snapshot-create-as test-server snap01 "Nach Installation"

Backup-Konfiguration:

Bash
# Backup-Skript erstellen
cat << 'EOF' > /usr/local/bin/vm-backup.sh
#!/bin/bash
# Snapshot erstellen
virsh snapshot-create-as dev-server backup-$(date +%Y%m%d)
# Alte Snapshots löschen (älter als 7 Tage)
for snap in $(virsh snapshot-list dev-server --name | grep backup- | sort -r | tail -n +8); do
    virsh snapshot-delete dev-server $snap
done
EOF

# Backup-Skript ausführbar machen
chmod +x /usr/local/bin/vm-backup.sh

# Cron-Job einrichten
echo "0 2 * * * /usr/local/bin/vm-backup.sh" | sudo crontab -

Container-Setup:

Bash
# LXC Container erstellen
lxc launch ubuntu:22.04 monitoring

# Container konfigurieren
lxc config set monitoring limits.memory 1GB
lxc config set monitoring limits.cpu 1

# Sicherheit konfigurieren
lxc config set monitoring security.privileged false
lxc config set monitoring security.nesting false

Fazit

In diesem Artikel hast du die fundamentalen Konzepte der Virtualisierung und des VM-Managements kennengelernt. Von der klassischen VM-Verwaltung über Container-Technologien bis hin zu Backup-Strategien wurden alle wichtigen Aspekte behandelt. Du hast gelernt, wie du virtuelle Maschinen erstellst, Container verwaltest und eine sichere, effiziente Virtualisierungsumgebung aufbaust.

Die vorgestellten Technologien und Best Practices bilden das Fundament für moderne IT-Infrastrukturen. Besonders wichtig ist das Zusammenspiel verschiedener Virtualisierungstechnologien – von KVM über Docker bis hin zu LXC/LXD. Nur durch die richtige Kombination dieser Werkzeuge kannst du eine flexible und leistungsfähige Virtualisierungsumgebung schaffen.

Damit endet unsere Serie „Linux-Administration“. In den acht Artikeln hast du alle wichtigen Grundlagen der Linux-Administration kennengelernt – von der Benutzerverwaltung über Netzwerkkonfiguration und Sicherheit bis hin zur Virtualisierung. Du verfügst nun über das nötige Wissen, um Linux-Systeme professionell zu verwalten und zu betreuen.

Happy virtualizing!

Schlagwörter

Ähnliche Beiträge

Kommentar verfassen