KVM Grundlagen: Unterschied zwischen den Versionen

Aus Xinux Wiki
Zur Navigation springen Zur Suche springen
← Zum vorherigen Versionsunterschied
Keine Bearbeitungszusammenfassung
 
Zeile 2: Zeile 2:


== Übersicht ==
== Übersicht ==
* Kernel-based Virtual Machine (KVM) ist eine Virtualisierungslösung für Linux.
* Kernel-based Virtual Machine (KVM) ist die Virtualisierungslösung im Linux-Kernel.
* Nutzt Hardwarevirtualisierung (Intel VT, AMD-V).
* Nutzt Hardware-Virtualisierung (Intel VT-x, AMD-V).
* Besteht aus Kernelmodulen (kvm.ko, kvm_intel.ko, kvm_amd.ko) und setzt auf QEMU für Geräteemulation auf.
* Besteht aus Kernelmodulen (<code>kvm.ko</code>, <code>kvm_intel.ko</code> bzw. <code>kvm_amd.ko</code>) und setzt für die Geräteemulation auf QEMU auf.
* Seit 2007 im Linux-Kernel enthalten.
* Fester Bestandteil des Linux-Kernels seit Version 2.6.20 (Februar 2007).


== Webseiten ==
== Webseiten ==
* https://www.linux-kvm.org/page/Main_Page
* https://www.linux-kvm.org/page/Main_Page
* https://www.qemu.org/
* https://www.qemu.org/
* https://libvirt.org/


== Geschichte ==
== Geschichte ==
* Veröffentlicht: Oktober 2006 (Kernel 2.6.20)
* Entwickelt von Avi Kivity bei Qumranet in Israel, vorgestellt im Oktober 2006.
* Entwickelt von Avi Kivity bei Qumranet in Israel.
* Aufgenommen in Kernel 2.6.20, veröffentlicht im Februar 2007.
* 2008 Übernahme von Qumranet durch Red Hat → treibt Entwicklung weiter.
* 2008 Übernahme von Qumranet durch Red Hat, das die Entwicklung seitdem maßgeblich vorantreibt.
* Heute Grundlage vieler Plattformen, z. B. Proxmox VE, OpenStack und großer Cloud-Anbieter.
* Portierungen existieren für FreeBSD und Illumos.
* Portierungen existieren für FreeBSD und Illumos.


== Unterstützte Architekturen ==
== Unterstützte Architekturen ==
* Intel (VT-x)
* x86-64 mit Intel VT-x oder AMD-V
* AMD (AMD-V)
* ARM64 (AArch64)
* System-z
* IBM Z (s390x)
* PowerPC
* PowerPC
* ARM
* RISC-V
 
== Open Virtualization Alliance (OVA) ==
* Gegründet Mai 2011 zur Förderung von KVM und Cloud-Lösungen.
* Wichtige Mitglieder: BMC, Eucalyptus, HP, IBM, Intel, Red Hat, SUSE.


== Architektur von KVM ==
== Architektur von KVM ==
* KVM ist reiner Kernel-Hypervisor → keine Emulation von Hardware.
* KVM virtualisiert CPU und Arbeitsspeicher, emuliert aber selbst keine Geräte.
* Für Geräteemulation wird QEMU genutzt.
* Die Geräte der VM (Festplatte, Netzwerkkarte, Grafik) emuliert QEMU.
* Kombination aus KVM + QEMU ergibt vollständiges Virtualisierungssystem.
* Jede VM ist ein normaler QEMU-Prozess auf dem Host, den der Kernel wie jeden anderen Prozess einplant.
* KVM + QEMU zusammen ergeben ein vollständiges Virtualisierungssystem.


== Übersichtsgrafik ==
== Übersichtsgrafik ==
Zeile 41: Zeile 40:
** Linux (32/64 Bit)
** Linux (32/64 Bit)
** Windows (32/64 Bit)
** Windows (32/64 Bit)
** Haiku, AROS, ReactOS, FreeDOS, Solaris, BSD-Derivate
** BSD-Derivate, Solaris/Illumos, Haiku, ReactOS, FreeDOS u. a.


== Paravirtualisierung mit VirtIO ==
== Paravirtualisierung mit VirtIO ==
* Spezielle paravirtualisierte Treiber für:
* Emulierte Geräte (z. B. Netzwerkkarte e1000, IDE-Platte) bilden echte Hardware nach. Der Gast-Treiber spricht mit ihnen wie mit echter Hardware, das erzeugt viele VM-Exits.
** Festplatten
* VirtIO-Geräte sind für VMs entworfen: Gast und Host tauschen Daten über gemeinsame Warteschlangen (virtqueues) aus, mit wenigen VM-Exits.
** Netzwerkgeräte
* Wichtige VirtIO-Geräte:
* Erhöht die Performance durch optimierten Zugriff auf Host-Ressourcen.
** <code>virtio-blk</code> / <code>virtio-scsi</code> für Festplatten
** <code>virtio-net</code> für Netzwerk
** <code>virtio-balloon</code> für dynamischen Arbeitsspeicher
* Linux bringt die Treiber mit, für Windows gibt es die ISO <code>virtio-win</code>.
* Animation: https://labs.xinux.net/kvm-praxis.html#virtio-1


== Verwaltungswerkzeuge ==
== Verwaltungswerkzeuge ==
* qemu/kvm (Direkter Start)
* <code>qemu-system-x86_64 -accel kvm</code> (direkter Start ohne Verwaltung)
* virsh (CLI)
* <code>virsh</code> (Kommandozeile von libvirt)
* Virtual Machine Manager (VMM)
* <code>virt-install</code> (VMs per Kommandozeile anlegen)
* AQemu
* Virtual Machine Manager (<code>virt-manager</code>, grafisch)
* UCS Virtual Machine Manager
* Cockpit mit <code>cockpit-machines</code> (Weboberfläche)
* Proxmox VE
* Proxmox VE (eigene Verwaltung, nutzt kein libvirt)
* oVirt
* Kimchi


== VT Modell (CPU Privilegienstufen) ==
== VT Modell (CPU Privilegienstufen) ==
{{#drawio:vt-ring}}
{{#drawio:vt-ring}}
''Zeigt die CPU-Ringe: Ring -1 (Hypervisor), Ring 0 (Kernel), Ring 3 (User). KVM nutzt Ring -1.''
''Zeigt die CPU-Modi: VMX Root (Hypervisor, „Ring -1“) und VMX Non-Root (Gast mit eigenem Ring 0 und Ring 3).''
* Ausführlich: [[X86-Virtualisierung]]


== Libvirt Übersicht ==
== Libvirt Übersicht ==
[[Datei:kvm-104.png|500px]]
[[Datei:kvm-104.png|500px]]
*'''Libvirt Architektur: API für Verwaltung von KVM/QEMU und anderen Hypervisoren.'''
* '''Libvirt''' ist eine einheitliche Schnittstelle zur Verwaltung von KVM/QEMU und anderen Hypervisoren.
* Werkzeuge wie <code>virsh</code> und <code>virt-manager</code> sprechen mit dem Dienst <code>libvirtd</code>, der die QEMU-Prozesse startet und verwaltet.
* Die Beschreibung einer VM liegt als XML-Datei unter <code>/etc/libvirt/qemu/</code>.


== VM Lifecycle ==
== VM Lifecycle ==
[[Datei:kvm-105.png|500px]]
[[Datei:kvm-105.png|500px]]
''Lebenszyklus einer virtuellen Maschine (erstellt, gestartet, gestoppt, gelöscht).''
''Lebenszyklus einer virtuellen Maschine (erstellt, gestartet, gestoppt, gelöscht).''
{| class="wikitable"
! Befehl !! Wirkung
|-
| <code>virsh define vm.xml</code> || VM anlegen (Zustand: ausgeschaltet)
|-
| <code>virsh start vm</code> || VM starten
|-
| <code>virsh suspend vm</code> / <code>virsh resume vm</code> || VM anhalten / fortsetzen
|-
| <code>virsh shutdown vm</code> || sauber herunterfahren (ACPI)
|-
| <code>virsh destroy vm</code> || hart ausschalten (Stecker ziehen), löscht nichts
|-
| <code>virsh undefine vm</code> || VM-Definition löschen (Platten bleiben)
|}
* Animation: https://labs.xinux.net/kvm-praxis.html#lifecycle-1


== Folien ==
== Folien ==
Zeile 81: Zeile 101:
* https://mrpointy.wordpress.com/2009/05/12/is-kvm-a-type-1-or-a-type-2/
* https://mrpointy.wordpress.com/2009/05/12/is-kvm-a-type-1-or-a-type-2/
* http://tuxthink.blogspot.de/2011/12/kvm-introduction.html
* http://tuxthink.blogspot.de/2011/12/kvm-introduction.html
[[Kategorie:Virtualisierung]]

Aktuelle Version vom 11. Oktober 2026, 17:46 Uhr

KVM Grundlagen

Übersicht

  • Kernel-based Virtual Machine (KVM) ist die Virtualisierungslösung im Linux-Kernel.
  • Nutzt Hardware-Virtualisierung (Intel VT-x, AMD-V).
  • Besteht aus Kernelmodulen (kvm.ko, kvm_intel.ko bzw. kvm_amd.ko) und setzt für die Geräteemulation auf QEMU auf.
  • Fester Bestandteil des Linux-Kernels seit Version 2.6.20 (Februar 2007).

Webseiten

Geschichte

  • Entwickelt von Avi Kivity bei Qumranet in Israel, vorgestellt im Oktober 2006.
  • Aufgenommen in Kernel 2.6.20, veröffentlicht im Februar 2007.
  • 2008 Übernahme von Qumranet durch Red Hat, das die Entwicklung seitdem maßgeblich vorantreibt.
  • Heute Grundlage vieler Plattformen, z. B. Proxmox VE, OpenStack und großer Cloud-Anbieter.
  • Portierungen existieren für FreeBSD und Illumos.

Unterstützte Architekturen

  • x86-64 mit Intel VT-x oder AMD-V
  • ARM64 (AArch64)
  • IBM Z (s390x)
  • PowerPC
  • RISC-V

Architektur von KVM

  • KVM virtualisiert CPU und Arbeitsspeicher, emuliert aber selbst keine Geräte.
  • Die Geräte der VM (Festplatte, Netzwerkkarte, Grafik) emuliert QEMU.
  • Jede VM ist ein normaler QEMU-Prozess auf dem Host, den der Kernel wie jeden anderen Prozess einplant.
  • KVM + QEMU zusammen ergeben ein vollständiges Virtualisierungssystem.

Übersichtsgrafik

KVM Architektur: KVM übernimmt CPU/RAM Virtualisierung, QEMU emuliert Geräte.

Gastsysteme

  • Unterstützt zahlreiche Betriebssysteme:
    • Linux (32/64 Bit)
    • Windows (32/64 Bit)
    • BSD-Derivate, Solaris/Illumos, Haiku, ReactOS, FreeDOS u. a.

Paravirtualisierung mit VirtIO

  • Emulierte Geräte (z. B. Netzwerkkarte e1000, IDE-Platte) bilden echte Hardware nach. Der Gast-Treiber spricht mit ihnen wie mit echter Hardware, das erzeugt viele VM-Exits.
  • VirtIO-Geräte sind für VMs entworfen: Gast und Host tauschen Daten über gemeinsame Warteschlangen (virtqueues) aus, mit wenigen VM-Exits.
  • Wichtige VirtIO-Geräte:
    • virtio-blk / virtio-scsi für Festplatten
    • virtio-net für Netzwerk
    • virtio-balloon für dynamischen Arbeitsspeicher
  • Linux bringt die Treiber mit, für Windows gibt es die ISO virtio-win.
  • Animation: https://labs.xinux.net/kvm-praxis.html#virtio-1

Verwaltungswerkzeuge

  • qemu-system-x86_64 -accel kvm (direkter Start ohne Verwaltung)
  • virsh (Kommandozeile von libvirt)
  • virt-install (VMs per Kommandozeile anlegen)
  • Virtual Machine Manager (virt-manager, grafisch)
  • Cockpit mit cockpit-machines (Weboberfläche)
  • Proxmox VE (eigene Verwaltung, nutzt kein libvirt)

VT Modell (CPU Privilegienstufen)

vt-ring

Zeigt die CPU-Modi: VMX Root (Hypervisor, „Ring -1“) und VMX Non-Root (Gast mit eigenem Ring 0 und Ring 3).

Libvirt Übersicht

  • Libvirt ist eine einheitliche Schnittstelle zur Verwaltung von KVM/QEMU und anderen Hypervisoren.
  • Werkzeuge wie virsh und virt-manager sprechen mit dem Dienst libvirtd, der die QEMU-Prozesse startet und verwaltet.
  • Die Beschreibung einer VM liegt als XML-Datei unter /etc/libvirt/qemu/.

VM Lifecycle

Lebenszyklus einer virtuellen Maschine (erstellt, gestartet, gestoppt, gelöscht).

Befehl Wirkung
virsh define vm.xml VM anlegen (Zustand: ausgeschaltet)
virsh start vm VM starten
virsh suspend vm / virsh resume vm VM anhalten / fortsetzen
virsh shutdown vm sauber herunterfahren (ACPI)
virsh destroy vm hart ausschalten (Stecker ziehen), löscht nichts
virsh undefine vm VM-Definition löschen (Platten bleiben)

Folien

Quellen

Abgerufen von „https://wiki.ixheim.de/index.php?title=KVM_Grundlagen&oldid=73611“