olreilly - Wartung

Сomentários

Transcrição

olreilly - Wartung
e
he ab
sc g
ut aus
De nal
i
ig
Or
Intelligente Virtualisierungslösungen mit XEN 3
XEN
Kochbuch
O’Reilly
Hans-Joachim Picht
Xen Kochbuch
Hans-Joachim Picht
mit Sebastian Ott
Beijing · Cambridge · Farnham · Köln · Sebastopol · Taipei · Tokyo
Die Informationen in diesem Buch wurden mit größter Sorgfalt erarbeitet. Dennoch können
Fehler nicht vollständig ausgeschlossen werden. Verlag, Autoren und Übersetzer übernehmen
keine juristische Verantwortung oder irgendeine Haftung für eventuell verbliebene Fehler und
deren Folgen.
Alle Warennamen werden ohne Gewährleistung der freien Verwendbarkeit benutzt und sind
möglicherweise eingetragene Warenzeichen. Der Verlag richtet sich im Wesentlichen nach den
Schreibweisen der Hersteller. Das Werk einschließlich aller seiner Teile ist urheberrechtlich
geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung,
Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.
Kommentare und Fragen können Sie gerne an uns richten:
O’Reilly Verlag
Balthasarstr. 81
50670 Köln
E-Mail: [email protected]
Copyright der deutschen Ausgabe:
© 2009 by O’Reilly Verlag GmbH & Co. KG
1. Auflage 2009
Bibliografische Information Der Deutschen Bibliothek
Die Deutsche Bibliothek verzeichnet diese Publikation in der
Deutschen Nationalbibliografie; detaillierte bibliografische Daten
sind im Internet über http://dnb.ddb.de abrufbar.
Lektorat: Christine Haite, Köln
Fachliche Unterstützung: Andreas Bildstein, Stuttgart & Christof Vollrath, Berlin
Korrektorat: Oliver Mosler, Köln
Satz: Tim Mergemeier, Reemers Publishing Services GmbH, Krefeld; www.reemers.de
Umschlaggestaltung: Marcia Friedman, Boston & Michael Oreal, Köln
Produktion: Andrea Miß, Köln
Belichtung, Druck und buchbinderische Verarbeitung:
Druckerei Kösel, Krugzell; www.koeselbuch.de
ISBN 978-3-89721-729-4
Dieses Buch ist auf 100% chlorfrei gebleichtem Papier gedruckt.
Inhalt
Vorwort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . XI
1 Einführung in die Virtualisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.1
1.2
1.3
1.4
1.5
Was ist Virtualisierung? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
Die Geschichte der Virtualisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
Einsatzgebiete und Vorteile. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Virtualisierungsarten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Was ist Xen? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2 Xen installieren und das Hostsystem vorbereiten (Domain-0)
2.1
2.2
2.3
2.4
2.5
2.6
2.7
2.8
2.9
2.10
2.11
2.12
2.13
2.14
2.15
2.16
2.17
22
..............
Xen-Installation auf Basis des Quellcodes. . . . . . . . . . . . . . . . . . . . . . . . . .
Erstellung einer initialen RAM-Disk . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Anpassung des Boot-Managers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Xen unter Ubuntu installieren. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Xen unter Debian installieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Xen unter openSUSE installieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Xen unter Fedora installieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Installation der Binärpakete von xensource.com . . . . . . . . . . . . . . . . . . . .
Die TLS-Bibliothek deaktivieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Starten, Stoppen und Neustarten des Xen-Daemons . . . . . . . . . . . . . . . . .
Deinstallation von Xen unter Debian und Ubuntu . . . . . . . . . . . . . . . . . . .
Deinstallation von Xen unter Fedora . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Deinstallation von Xen unter openSUSE . . . . . . . . . . . . . . . . . . . . . . . . . .
Deinstallation von Xen als Binärpaket . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Deinstallation eines aus den Quellen kompilierten Xen . . . . . . . . . . . . . . .
Xen unter Debian und Ubuntu aktualisieren . . . . . . . . . . . . . . . . . . . . . . .
Xen unter openSUSE aktualisieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
23
27
29
32
35
37
39
41
43
46
48
49
50
51
52
53
54
|
V
2.18
2.19
2.20
2.21
Xen unter Fedora-Linux aktualisieren. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Ein aus den Quellen oder als Binärpaket installiertes Xen aktualisieren. . .
Xend in den Boot-Vorgang einbinden . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Automatisches Starten der Gastsysteme . . . . . . . . . . . . . . . . . . . . . . . . . . .
55
56
57
59
3 Konfiguration des Hostsystems (Domain-0) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
3.1
3.2
3.3
3.4
Konfiguration des Xen-Daemons (xend). . . . . . . . . . . . . . . . . . . . . . . . . . .
Ein Bridging-Netzwerk einrichten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Ein Routing-Netzwerk einrichten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Ein Netzwerk mit Network Address Translation konfigurieren . . . . . . . . .
60
66
73
75
4 Vorbereitung des Systems auf die Gäste (Paravirtualisierung) . . . . . . . . . . . . . . 81
4.1
4.2
4.3
4.4
4.5
4.6
4.7
Speicherplatz auf Basis physikalischer Geräte einrichten . . . . . . . . . . . . . .
Speicherplatz auf Basis physikalischer Geräte mit LVM einrichten . . . . . .
Dateibasierte Geräte als Storage Backend einsetzen . . . . . . . . . . . . . . . . . .
Zugriff auf die root-Partition über NFS. . . . . . . . . . . . . . . . . . . . . . . . . . . .
Erstellung des Dateisystems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Konfiguration des Gastsystems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Booten des Gastsystems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5 Distributionsspezifische Gast-Installation (Paravirtualisierung)
5.1
5.2
5.3
5.4
...........
Gastsysteme mit virt-install unter Fedora installieren. . . . . . . . . . . . . . . .
Gastsysteme mit YaST auf SUSE installieren . . . . . . . . . . . . . . . . . . . . . .
Gastsysteme für Debian und Ubuntu mit Xen-Tools installieren . . . . . . .
Paravirtualisiertes NetBSD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
81
83
89
91
93
94
97
101
101
105
108
110
6 Unmodifizierte Gastsysteme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
6.1 Einführung:
Der Unterschied zwischen Para- und Hardware-Virtualisierung . . . . . . .
6.2 Xen und die x86-Ringe paravirtualisiert . . . . . . . . . . . . . . . . . . . . . . . . . .
6.3 Hardware-Unterstützung prüfen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.4 Konfiguration für unmodifizierte Gastsysteme . . . . . . . . . . . . . . . . . . . . .
6.5 Von einem CD/DVD-Laufwerk booten . . . . . . . . . . . . . . . . . . . . . . . . . .
6.6 Von einer (virtuellen) Festplatte booten . . . . . . . . . . . . . . . . . . . . . . . . . .
6.7 Booten einer Live-CD/DVD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.8 Installation von Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.9 Installation von Windows . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.10 Benutzung der virtuellen Windows-Systeme. . . . . . . . . . . . . . . . . . . . . . .
VI
| Inhalt
115
118
119
122
123
124
125
128
131
135
7 Hardwarezugriff
7.1
7.2
7.3
7.4
7.5
7.6
7.7
.................................................
Hotplugging virtueller Festplatten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Hotplugging virtueller Netzwerkkarten . . . . . . . . . . . . . . . . . . . . . . . . . .
Ein virtuelles Trusted Platform-Module (TPM) nutzen . . . . . . . . . . . . . .
Der virtuelle Framebuffer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
PCI-Karten in einem Gastsystem zugänglich machen. . . . . . . . . . . . . . . .
Eine Backend-Domain konfigurieren . . . . . . . . . . . . . . . . . . . . . . . . . . . .
OpenGL-Hardware-3-D-Beschleunigung für virtuelle Maschinen: VMGL
138
138
140
142
144
146
147
149
8 Automatische Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
8.1
8.2
8.3
8.4
8.5
8.6
8.7
8.8
Einführung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Installation minimaler Linux-Systeme in ein Verzeichnis . . . . . . . . . . . . .
Installation eines minimalen SUSE-Systems für eine virtuelle Maschine .
Installation einer virtuellen Maschine auf Basis einer RPM-basierten
Linux-Distribution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Einsatz vorgefertigter DomUs (paravirtualisiert) . . . . . . . . . . . . . . . . . . .
Austausch der Kernel-Module innerhalb der virtuellen Maschine . . . . . .
Klonen virtueller Maschinen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Vorbereitungen zum Klonen einer hardwarevirtualisierten WindowsDomäne mittels sysprep . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
153
154
158
161
164
166
168
171
9 Backup & Restore . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
9.1
9.2
9.3
9.4
9.5
9.6
Den Zustand einer virtuellen Maschine speichern . . . . . . . . . . . . . . . . . .
Eine virtuelle Maschine anhalten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Backup via FTP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Backup mit rsync. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Backup mit LVM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Xen & RAID: Virtuelle Maschinen auf einem Software-RAID-1 betreiben
173
175
176
178
181
183
10 Migration virtueller Maschinen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
10.1
10.2
10.3
10.4
10.5
10.6
Einführung: Unterschiedliche Migrationskonzepte im Überblick . . . . . .
Physical-to-Virtual-Migration (P2V) mit Hardwarevirtualisierung. . . . . .
P2V-Migration ohne Hardwarevirtualisierung . . . . . . . . . . . . . . . . . . . . .
Ein physikalisches Fedora/Red Hat Enterprise Linux virtualisieren . . . . .
P2V von OpenSUSE/SUSE Linux Enterprise-Servern . . . . . . . . . . . . . . . .
Von VMware zu Xen migrieren. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
189
190
195
199
202
204
Inhalt | VII
11 Live-Migration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208
11.1 Konfiguration des Xen-Relocation-Servers . . . . . . . . . . . . . . . . . . . . . . . . 208
11.2 Live-Migration zwischen verschiedenen Hosts . . . . . . . . . . . . . . . . . . . . . 211
12 Hochverfügbarkeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218
12.1
12.2
12.3
12.4
Verteilte Replikation von Dateisystemen via DRBD . . . . . . . . . . . . . . . . .
Xen-Cluster mit Ganeti verwalten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Hochverfügbarkeitscluster mit Heartbeat einrichten . . . . . . . . . . . . . . . .
Virtuelle Xen-Gäste im Hochverfügbarkeitscluster . . . . . . . . . . . . . . . . . .
220
226
240
244
13 Monitoring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249
13.1
13.2
13.3
13.4
13.5
Einführung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Monitoring mit Xens Bordmitteln. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Virtuelle Maschinen unter Fedora Linux überwachen . . . . . . . . . . . . . . .
Die CPU-Auslastung mit XenStats auswerten. . . . . . . . . . . . . . . . . . . . . .
Monitoring virtueller Maschinen mithilfe von Nagios –
vorbereitende Schritte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
13.6 Monitoring von Domain-0s und ihren virtuellen Maschinen mit Nagios
13.7 Alternative Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
249
250
261
263
267
284
291
14 Virtuelle Maschinen verwalten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
14.1
14.2
14.3
14.4
Textbasierte Verwaltung virtueller Maschinen mit der Xen-Shell. . . . . . .
Webbasierte Verwaltung mit Enomalism . . . . . . . . . . . . . . . . . . . . . . . . .
Grafische Verwaltung virtueller Maschinen mit XenMan . . . . . . . . . . . . .
Grafische Verwaltung virtueller Maschinen mit dem Virtual Machine
Manager (virt-manager). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
296
299
301
303
15 Eigene Anwendungen zum Xen-Management entwickeln . . . . . . . . . . . . . . . . 306
15.1
15.2
15.3
15.4
15.5
15.6
15.7
15.8
15.9
15.10
15.11
VIII |
Inhalt
Einführung: Die libvirt-Bibliothek . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Die libvirt unter Fedora installieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Die libvirt unter openSUSE installieren. . . . . . . . . . . . . . . . . . . . . . . . . . .
Die libvirt unter Debian installieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Die libvirt aus dem Quellcode installieren . . . . . . . . . . . . . . . . . . . . . . . .
Das erste C-Programm mit libvirt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Das erste Python-Programm mit libvirt. . . . . . . . . . . . . . . . . . . . . . . . . . .
Die Fähigkeiten des Hypervisors in C-Programmen anzeigen . . . . . . . . .
Die Fähigkeiten des Hypervisors in Python-Skripten anzeigen . . . . . . . . .
Eine Domäne verwalten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Eine neue Domäne anlegen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
306
308
309
310
311
314
316
317
318
319
321
15.12
15.13
15.14
15.15
15.16
15.17
15.18
Eine Domäne herunterfahren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Eine Domäne »einschlafen« lassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Eine Domäne aufwecken. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Die Gastsysteme in einem C-Programm auflisten. . . . . . . . . . . . . . . . . . .
Die Gastsysteme in einem Python-Skript auflisten . . . . . . . . . . . . . . . . . .
Die Geräte einer Domäne mit einem C-Programm verwalten . . . . . . . . .
Die Geräte einer Domäne mit einem Python-Skript verwalten . . . . . . . . .
322
323
324
325
327
328
329
16 Der XenStore
331
16.1
16.2
16.3
16.4
332
333
334
335
....................................................
Einführung: Aufbau und Navigation der XenStore-Verzeichnisstruktur .
Informationen auslesen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Einträge anlegen und modifizieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Einträge entfernen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
17 Ressourcenkontrolle
17.1
17.2
17.3
17.4
17.5
17.6
17.7
..............................................
Einführung in die Speicherverwaltung . . . . . . . . . . . . . . . . . . . . . . . . . . .
Speicherlimits für virtuelle Maschinen einrichten. . . . . . . . . . . . . . . . . . .
Einführung: CPUs verwalten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Zuordnung zwischen virtuellen CPUs und Gastsystemen . . . . . . . . . . . .
Zuordnung zwischen logischen CPUs und Gastsystemen . . . . . . . . . . . .
Scheduling von CPU-Zyklen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Traffic Shaping mit Xen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
336
336
337
340
340
343
344
346
18 Sicherheit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348
18.1
18.2
18.3
18.4
18.5
18.6
18.7
Einführung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Die Daten virtueller Maschinen verschlüsseln . . . . . . . . . . . . . . . . . . . . .
Vorüberlegungen zum Firewall-Setup unter Xen . . . . . . . . . . . . . . . . . . .
Firewall-Konfiguration in einem Bridge-Setup (Dom0) . . . . . . . . . . . . . .
Firewall-Konfiguration in einem NAT-Setup (Dom0) . . . . . . . . . . . . . . .
Firewall-Konfiguration in einem Routing-Setup (DomU). . . . . . . . . . . . .
Firewall-Setup mit der DTC-Xen-Firewall unter Debian GNU/Linux
oder Ubuntu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
18.8 Mechanismen zur Zugriffskontrolle einrichten. . . . . . . . . . . . . . . . . . . . .
18.9 Xen und Intrusion-Detection-Systeme (IDS). . . . . . . . . . . . . . . . . . . . . . .
348
350
358
359
366
368
371
374
388
19 Troubleshooting. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 391
19.1 Zeitabweichung in der virtuellen Maschine . . . . . . . . . . . . . . . . . . . . . . . 391
19.2 Die Fehlermeldung »Backend Device not found« . . . . . . . . . . . . . . . . . . . 393
19.3 Die Meldung »Is a directory« . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396
Inhalt | IX
19.4 Die Meldung »Error: (22, 'Invalid argument')« . . . . . . . . . . . . . . . . . . . . . 397
19.5 »4gb seg fixup« – eine Fehlermeldung unter Debian . . . . . . . . . . . . . . . . 399
19.6 Einen Bugreport einreichen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 400
20 Erweiterte Netzwerkkonfiguration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 404
20.1
20.2
20.3
20.4
20.5
20.6
Eine VLAN-Umgebung einrichten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Zugriff auf ein VLAN von der Domain-0 einrichten . . . . . . . . . . . . . . . . .
Zugriff auf ein VLAN von einer Domain-U einrichten . . . . . . . . . . . . . . .
Einer virtuellen Maschine den Zugriff auf ein VLAN ermöglichen . . . . . .
Bonding-Unterstützung aktivieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Ein Bonding-Device einsetzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
A Das Programm xm im Überblick
.....................................
Virtuelle Maschinen verwalten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Befehle zur Steuerung der Domain-0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Virtuelle Blockgeräte verwalten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Virtuelle Netzwerkadapter verwalten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Virtuelle TPM-Geräte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Access Control Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
404
406
408
409
410
412
416
417
423
424
426
427
428
B Glossar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 432
C Weiterführende Informationen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 438
Index
X
Literaturhinweise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Mailinglisten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Internet Relay Chat (IRC) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Webseiten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Veranstaltungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
438
439
444
444
446
...............................................................
447
| Inhalt
Vorwort
Nach einem »Dornröschenschlaf« von fast 20 Jahren ist das Thema Virtualisierung nun
wieder in aller Munde. Was unter Mainframes schon ein alter Hut aus den Sechzigerjahren ist, erlebt auf dem PC gerade seine Blütezeit. Das zeigt sich nicht nur an der Fülle
unterschiedlicher Virtualisierungstechnologien im Open Source-Umfeld, sondern auch
an dem reichen Ökosystem an Programmen darum herum. Durch die Vielzahl der zur
Verfügung stehenden Tools und die unterschiedlichen Ausprägungen der einzelnen Distributionen ist es allerdings oftmals nicht leicht, den Wald vor lauter Bäumen noch zu
sehen. Mit diesem Buch soll versucht werden, das Chaos etwas zu ordnen und praxisorientiert typische Aufgabenstellungen rund um die Virtualisierung anzugehen. Wir
konzentrieren uns dabei auf Xen, eine der momentan beliebtesten Virtualisierungsimplementierungen, die unter der GPL steht. Xen wird mittlerweile durch eine Vielzahl
oftmals konkurrierender Unternehmen mit entwickelt, zu denen laut wikipedia.org1 nicht
nur Sun, Intel und AMD, IBM, HP, Red Hat und Novell/SUSE zählen, sondern auch
Microsoft. Zudem unterstützt die »Bill & Melinda Gates Foundation« die Entwicklung
von Xen finanziell.
Zu diesem Buch
Die Idee zu diesem Buch gärt schon länger in meinem Kopf und hat sich dann im Laufe
der Zeit in einem nicht mehr zu bändigenden Papierstapel mit Schnipseln von Konfigurationsdateien, einzeiligen Programmaufrufen und gelben Post-its materialisiert. Da ich
diesen Stapel auch noch auf viele Reisen mitgenommen habe, konnten Eselsohren, fehlende Seiten und Abdrücke von Kaffeetassen nicht lange ausbleiben. Und ständig kamen
neue Ideen und Notizen dazu, die ich im Zuge meiner Präsentationen auf Linux-Konferenzen und Linux-Schulungen in verschiedenen Städten gesammelt habe.
Der Anblick dieses wachsenden chaotischen Papierstapels ist ein gutes Sinnbild für die
Probleme, die sich ergeben, wenn man versucht, eine sich permanent weiterentwickelnde
Software in den langfristigen kommerziellen Einsatz zu nehmen. Was auf einer Distribu1 http://de.wikipedia.org/w/index.php?title=Xen&oldid=52816287
| XI
tion problemlos funktioniert, kann auf einer anderen schon durch das Fehlen der entsprechenden Software-Abhängigkeiten scheitern. Dieses Wirrwarr galt es also zu ordnen,
und ich habe versucht, gerade diese Distributionsabhängigkeit durch explizite distributionsspezifische Hinweise und Rezepte für Debian GNU/Linux (und Ubuntu) sowie
Fedora und openSUSE abzudecken.
Zielgruppe des Buchs
Dieses Buch richtet sich an all diejenigen, die sich – aus welchen Gründen auch immer –
mit dem Thema Virtualisierung durch Xen beschäftigen möchten oder müssen. Hierbei
liegt der Fokus auf einer konkreten problemorientierten Herangehensweise. In einer Vielzahl kurzer Rezepte wird versucht, das komplexe Thema in kleine, der Reihe nach abzuarbeitende Teillösungen herunterzubrechen.
Ein Großteil der aktuellen Literatur zum Thema Virtualisierung im Allgemeinen oder
Xen im Besonderen will erst einmal die Virtualisierungsthematik und die größeren
Zusammenhänge lang und breit erläutern, und am Ende fehlt dann leider oftmals der
Platz, um sich den ganz konkreten Problemen und Nöten eines Sysadmins zu widmen,
dessen System auch im Produktivbetrieb überleben soll. Diesem Trend widersetzt sich
das vorliegende Buch durch seine klassische O’Reilly-Kochbuchstruktur.
Ich gehe also in diesem Buch davon aus, dass Sie weder Laie noch Manager sind, sondern
ein gestandener Systemadministrator, der Lösungen für seine technischen Probleme
sucht und der spätestens nach der Lektüre dieses Vorworts die Ärmel hochkrempeln will.
Wenn Sie sich überhaupt mit einem Vorwort aufhalten ...
Das Buch ist so angelegt, dass es nicht nur für Power-User und Admins kleiner und mittlerer Netzwerke, sondern auch für Betreuer großer Serverparks etwas zu bieten hat. Während wir dem ambitionierten Heimanwender den parallelen Betrieb verschiedener
Betriebssysteme näherbringen, bekommen Administratoren Mittel und Wege aufgezeigt,
in kürzester Zeit mit Hilfe von Xen neue Systeme zur Verfügung zu stellen. Durch die
Abschnitte »Monitoring«, »Hochverfügbarkeit« und die Passagen zur Entwicklung eigener Management- und Automatisierungslösungen finden auch diejenigen, die große
Rechenzentrumsinstallationen verwalten, hilfreiche Rezepte rund um den Einsatz von
Xen.
Voraussetzungen
Dieses Buch hat sein Hauptaugenmerk auf dem Einsatz von Xen unter Linux. Wenn Sie
sich noch nicht mit Linux im Allgemeinen auskennen, sollte dieses Buch frühestens Ihr
zweites oder drittes Buch zum Thema Linux-Administration sein.
In den anfänglichen Kapiteln, die sich mit der Vorbereitung oder der ersten Inbetriebnahme einer virtuellen Maschine auf Basis von Xen beschäftigen, setzen wir lediglich
grundlegende Linux-Kenntnisse voraus, die man sich vermutlich bereits im Zuge einer
ersten Linux-Installation und mit einem Ausflug auf die Kommandozeile angeeignet hat.
XII | Vorwort
Generell versuche ich, für die meisten Befehle die Kommandozeile zu verwenden, wie es
beim Einsatz klassischer Unix-Fernwartungsprogramme üblich ist. Nur in wenigen vereinzelten Rezepten arbeiten wir mit einer grafischen Oberfläche.
Je spezieller die Themen werden, desto mehr Erfahrungen werden vorausgesetzt. So sollten Sie beispielsweise im Kapitel 18, das sich mit Sicherheitsaspekten und einem Xenspezifischen Firewall-Setup beschäftigt, bereits grundlegend mit iptables vertraut sein.
Außerdem gibt es ein Kapitel zur Entwicklung individueller Management-Programme für
Xen-Systeme – auch dort wird davon ausgegangen, dass Sie eine der exemplarisch
erwähnten Programmiersprachen (primär C und Python, aber auch OCaml, Ruby und
Java) kennen.
Für den echten Linux-Guru werden dann noch Konzepte und Möglichkeiten aufgezeigt,
ein Xen-Setup zu überwachen und sehr feingranulare, vor allem für das PerformanceTuning notwendige Details abzufragen.
Hardware-Anforderungen
Prinzipiell sind die Ressourcen CPU, Festplattenspeicher und Memory entscheidend für
den Einsatz von Xen. Mit weniger als 512 MB Hauptspeicher ist es kaum sinnvoll, eine
virtuelle Maschine betreiben zu wollen. Wenn mehrere virtualisierte Betriebssysteme
installiert werden, müssen diese auch gleichzeitig auf dem zur Verfügung stehenden Festplattenspeicher vorrätig gehalten werden können. Sind diese Voraussetzungen erfüllt,
kann Xen vom alten Pentium III über ein handelsübliches Notebook bis zum High-EndServer mit AMD oder Intel-CPU betrieben werden. Wenn Sie den Einsatz eines proprietären Betriebssystems in einer virtualisierten Umgebung ins Auge fassen, werden hierfür
allerdings spezielle Prozessoren mit zusätzlichen Virtualisierungs-Hardwareeigenschaften
benötigt (siehe Kapitel 6, Unmodifizierte Gastsysteme).
Aufbau
Dieses Buch besteht aus 20 Kapitel sowie drei Anhängen, auf die sich die folgenden
Inhalte verteilen:
Kapitel 1, Einführung in die Virtualisierung
Als Erstes wollen wir auf das Thema Virtualisierung im Allgemeinen eingehen und
erklären, was sich hinter dem Begriff verbirgt. Weiterhin gehen wir kurz auf die
Geschichte der Virtualisierung ein, gefolgt von möglichen Anwendungsszenarien
sowie einem Überblick über die verschiedenen Virtualisierungsarten, denen man
heutzutage begegnet.
Kapitel 2, Xen installieren und das Hostsystem vorbereiten (Domain-0)
Als Grundlage für alles Weitere wollen wir Ihnen zeigen, wie Sie Ihr bestehendes
Linux-System auf den Einsatz von Xen vorbereiten.
Vorwort
| XIII
Kapitel 3, Konfiguration des Hostsystems (Domain-0)
Nachdem in Kapitel 2, Xen installieren und das Hostsystem vorbereiten (Domain-0),
die notwendigen Voraussetzungen installiert wurden, macht Sie dieses Kapitel mit
allen Dingen rund um die Konfiguration der Domain-0, dem Hostsystem, vertraut.
Kapitel 4, Vorbereitung des Systems auf die Gäste (Paravirtualisierung)
Jetzt, wo das Hostsystem in der Lage ist, ein Gastsystem zu betreiben, betrachtet
das Kapitel 4, Vorbereitung des Systems auf die Gäste (Paravirtualisierung), die zur
Einrichtung einer virtuellen Maschine notwendigen Schritte. Neben verschiedenen
Möglichkeiten, eine virtuelle Festplatte einzurichten, stehen in diesem Kapitel die
benötigten Anweisungen, um eine virtuelle Maschine unabhängig von einer
bestimmten Linux-Distribution aufzusetzen. Neben der Erstellung einer Konfigurationsdatei und den nötigen Anpassungen der Netzwerkkonfiguration wird beschrieben, wie man sich mit einem Gastsystem über die Kommandozeile und die grafische
Oberfläche verbindet.
Kapitel 5, Distributionsspezifische Gast-Installation (Paravirtualisierung)
Dieses Kapitel beschreibt die distributionsspezifische Installation von Gastsystemen.
Aufgrund der Tatsache, dass von Distribution zu Distribution unterschiedliche »Insellösungen« existieren, wird auf die Installation in folgenden weitverbreiteten Distributionen eingegangen: Debian, Fedora, SUSE und Ubuntu. Am Ende des Kapitels ist
zusätzlich die Installation von NetBSD beschrieben.
Kapitel 6, Unmodifizierte Gastsysteme
In diesem Kapitel, das mit einigen Vorbemerkungen zum Thema Hardware-Virtualisierung beginnt, werden Sie mit den notwendigen Techniken vertraut gemacht, die
es ermöglichen, ein unmodifiziertes Betriebssystem, beispielsweise aus dem Hause
Microsoft, unter Linux in einer Xen-Instanz zu betreiben.
Kapitel 7, Hardwarezugriff
Der Zugriff auf verschiedene Hardware aus einer virtuellen Maschine heraus wird in
diesem Kapitel besprochen. Hierbei betrachten wir sowohl virtuelle Hardware, die
einer unprivilegierten virtuellen Maschine zugewiesen werden kann, als auch den
direkten Zugriff eines Gastsystems auf die Hardware.
Kapitel 8, Automatische Installation
Einen wesentlichen Vorteil der Virtualisierung lernen wir in Kapitel 8, Automatische
Installation, kennen: die Möglichkeit, neue Systeme in kurzer Zeit zur Verfügung zu
stellen. Dies wird vor allem durch die Technik des »Klonens« virtueller Maschinen
möglich, wobei ein System einmalig installiert wird, um daraus anschließend einfach weitere Kopien anzufertigen. Weiterhin beschäftigt sich dieser Teil des Buches
mit Fragen rund um das Thema automatisierte Installation.
Kapitel 9, Backup & Restore
Dieses Kapitel zeigt Ihnen die besonderen Vorteile und Fallstricke, denen man
begegnet, wenn es um die Datensicherung oder das Wiederherstellen eines Xen-Systems geht.
XIV |
Vorwort
Kapitel 10, Migration virtueller Maschinen
Dieses Kapitel beschäftigt sich anfangs mit den Möglichkeiten der Migration von
physikalischen Servern zu virtuellen Maschinen. Im Weiteren wird darauf eingegangen, wie vorhandene Virtualisierungslösungen zu Xen migriert werden können.
Kapitel 11, Live-Migration
Den Vorteil virtueller Maschinen, dass sich das gesamte System mit vergleichsweise
geringem Aufwand auf ein anderes physikalisches System migrieren lässt, betrachten wir in diesem Kapitel, das sich der Live-Migration widmet.
Kapitel 12, Hochverfügbarkeit
Nachdem wir uns in den vorangegangenen zwei Kapiteln mit der Migration vertraut gemacht haben, wollen wir uns diese nun zunutze machen, um Hochverfügbarkeits-Cluster auf Xen-Basis aufzubauen.
Kapitel 13, Monitoring
Dieses Kapitel beschäftigt sich mit dem Warum, Was, Wann, Wo und Wie des
Monitorings, mit den Xen-spezifischen Aspekten, dem Einsatz von Linux-Bordmitteln und auch mit großen Monitoring-Lösungen wie Nagios.
Kapitel 14, Virtuelle Maschinen verwalten
In diesem Kapitel werden einige alternative Lösungen zum zentralen Xen-Verwaltungsprogramm xm vorgestellt. Diese reichen von kommandozeilenbasierten Programmen über Web-Frontends bis hin zu grafischen Oberflächen.
Kapitel 15, Eigene Anwendungen zum Xen-Management entwickeln
In diesem Abschnitt des Xen-Kochbuchs wird erläutert, wie man aus eigenen Programmen heraus auf die Xen-Funktionen zugreifen kann. Dies ist vor allem für
Anwendungsentwickler interessant, die bestehende Anwendungen um Funktionen
zur Verwaltung virtueller Maschinen erweitern oder eine eigene, angepasste
Management-Lösung erstellen wollen.
Kapitel 16, Der XenStore
In diesem Kapitel eignen wir uns Wissen über den XenStore an, eine Technologie,
mit der Informationen zwischen virtuellen Maschinen ausgetauscht oder gespeichert werden und die bei der Fehlersuche oder bei der Entwicklung eigener Treiber
und Programme hilfreich ist.
Kapitel 17, Ressourcenkontrolle
In diesem Kapitel wird beschrieben, wie die Ressourcen Speicher, CPU sowie Netzwerkbandbreite unter den einzelnen Gästen aufgeteilt werden. Weiterhin werden
wir lernen, wie einer Domäne zusätzliche Ressourcen zur Verfügung gestellt werden
können. Obendrein werden Wege aufgezeigt, um zu verhindern, dass eine virtuelle
Maschine bestimmte Ressourcen übermäßig nutzt und dabei andere Gastsysteme
blockiert.
Vorwort |
XV
Kapitel 18, Sicherheit
Dieses Kapitel widmet sich den Sicherheitsaspekten einer Xen-Installation. Hierbei
werden – ausgehend von allgemeinen Hinweisen – folgende Themen behandelt: der
Einsatz verschlüsselter Dateisystemimages, unterschiedliche Firewall-Architekturen, Policies sowie der Einsatz von Intrusion-Detection-Systeme in virtualisierten
Umgebungen.
Kapitel 19, Troubleshooting
Hier finden Sie die fünf häufigsten Probleme, die beim Einsatz von Xen typischerweise auftauchen können – und natürlich die entsprechenden Lösungen. Anschließend gehen wir noch darauf ein, wie man bei den Entwicklern von Xen einen BugReport einreicht.
Kapitel 20, Erweiterte Netzwerkkonfiguration
Dieses Kapitel beschäftigt sich mit fortgeschrittenen Aspekten der Netzwerkkonfiguration in Host und Gast. Neben der Konfiguration eines VLANs wird auf das
Thema Bonding eingegangen.
In den Anhängen zum Buch finden Sie noch eine Reihe von Informationen zum Nachschlagen. Diese werden Ihnen sowohl beim Lesen des Textteils als auch später bei der
täglichen Arbeit hilfreiche Dienste leisten.
Anhang A, Das Programm xm im Überblick
Dieser Anhang enthält eine Zusammenstellung der wichtigsten Befehle rund um das
zentrale Xen-Verwaltungsprogramm xm.
Anhang B, Glossar
In diesem Anhang finden Sie ein Glossar, in dem an zentraler Stelle die wichtigsten
Fachbegriffe erklärt werden, die in diesem Kochbuch verwendet werden.
Anhang C, Weiterführende Informationen
Der letzte Anhang gibt einen Überblick über weiterführende Ressourcen.
Hinweise zur Lektüre
Das ist kein Buch, mit dem man es sich auf dem Sessel im Wohnzimmer gemütlich
macht, um es vom Anfang bis zum Ende durchzulesen (auch wenn natürlich nichts Sie
davon abhalten soll, dies zu tun). Es bietet sich vielmehr an, dass Sie sich – analog zu
einem »echten« Kochbuch oder einer Enzyklopädie – immer das Wissen heraussuchen,
das Sie aktuell benötigen.
In der typischen Struktur der O’Reilly-Kochbücher wird in jedem Rezept ein konkretes
Problem aufgegriffen, das es zu lösen gilt. Nach einer üblicherweise kompakten Problemlösung, die dem geübten Linux-Administrator möglicherweise bereits ausreicht, gibt es
im Anschluss immer auch einen ausführlichen Diskussionsabschnitt. In diesem wird im
Detail auf die gezeigte Lösung und eventuelle Abweichungen, Warnungen oder Hinweise
eingegangen. Als Letztes folgt am Ende eines jeden Rezepts ein Bereich, in dem Hinweise
auf weitere Informationen zu finden sind.
XVI |
Vorwort
Setzt man beispielsweise nur eine einzelne Linux-Distribution wie GNU/Debian oder
Fedora ein, kann man sich die Abhandlungen, die speziell auf openSUSE eingehen, komplett sparen und sich auf die eigenen Fragestellungen konzentrieren.
Wen der kurze Überblick zum geschichtlichen Abriss und über die Virtualisierungstechniken im Allgemeinen nicht interessiert, kann Kapitel 1, Einführung in die Virtualisierung,
getrost überspringen. Ist Ihr System bereits auf den Einsatz von Xen vorbereitet, können
Sie auch direkt Kapitel 5, Distributionsspezifische Gast-Installation (Paravirtualisierung),
aufschlagen. Und wenn Sie einfach nur ein Windows-System auf Ihrem Linux-Desktop
mit Hilfe von Xen installieren wollen, werden Sie in Kapitel 6, Unmodifizierte Gastsysteme, fündig. Müssen Sie bereits eine Xen-Installation administrieren und sind auf der
Fehlersuche, ist Kapitel 19, Troubleshooting ein guter Start. Sollten Sie in C oder Python
programmieren, finden Sie in Kapitel 15, Eigene Anwendungen zum Xen-Management
entwickeln, wertvolle Hinweise, wie Sie tägliche Arbeitsvorgänge rund um Xen in einfachen Programmen automatisieren können.
Typografische Konventionen
Dieses Buch wendet folgende typografische Konventionen an:
Kursivschrift
Für E-Mail-Adressen, Dateinamen, URLs, um neue Begriffe hervorzuheben, wenn
sie erstmalig benutzt werden, und für Kommentare innerhalb von Code-Abschnitten.
Nichtproportionalschrift
Für den Code – um den Inhalt von Dateien oder die Ausgabe von Kommandos zu
zeigen und um Module, Methoden, Anweisungen und Kommandos zu kennzeichnen.
Nichtproportionalschrift, fett
In Code-Abschnitten, um Kommandos oder Text zu kennzeichnen, der von Ihnen
eingegeben werden soll.
Nichtproportionalschrift, kursiv
Um austauschbare Komponenten in Code-Abschnitten zu markieren.
KAPITÄLCHEN
Für Elemente grafischer Oberflächen wie Buttons, Menüs und Schaltflächen aller
Art.
Dieses Icon steht für einen Tipp, einen Vorschlag oder einen allgemeinen
Hinweis.
Dieses Icon steht für eine Warnung.
Vorwort |
XVII
Danksagung
Die Zeit, in der dieses Buch entstanden ist, war eine lange Reise, und das nicht nur im
übertragenen Sinne. Im Jahr 2007 ging es los, mit dem Laptop im Handgepäck. Aus den
von mir zu Beginn veranschlagten sportlichen drei Monaten wurde dann mehr als ein
Jahr. Ein Jahr, in dem ein knappes Manuskript zu einem umfassenden Kochbuch heranwuchs.
Die Reise begann im Rheinland, genauer gesagt in Düsseldorf. Von dort aus setzt sich die
mobile Entstehungsgeschichte fort, quer durch Deutschland, die Schweiz, Frankreich,
die USA, Österreich und Tschechien. Viele Kapitel sind in der Bahn (speziell auf der Strecke Marburg – Stuttgart) oder in Hotels und nur in den seltensten Fällen am heimischen
Schreibtisch entstanden. Hierbei sind zwei Laptops, ein Koffer und ein Auto auf der Strecke geblieben – hinzugewonnen wurden zwei Punkte in Flensburg.
Danken möchte ich allen, die mich auf dieser Reise begleitet haben, ausgehend von meiner Lektorin Christine Haite, die nicht nur zahlreiche Vorschläge und Korrekturen beigesteuert hat, sondern mir auch bei allen Fragen jederzeit mit Rat und Tat beiseite stand.
Weiterhin möchte ich Jürgen »Huega« Falb und Claus Allweil danken, die mich auf dem
ersten Drittel dieser Reise begleitet haben. Jürgen, der mir auch eine Einführung in die
kulinarischen Gepflogenheiten der Region Stuttgart verpasst hat, ist ein Großteil der
Abschnitte zum Thema Installation und Hardware-Virtualisierung sowie etliche Skizzen
in den ersten Kapiteln zu verdanken. Und Claus hat nicht nur meine Fragen zu Spezifika
von SUSE und openSUSE beantwortet, sondern auch das Fundament für das Kapitel
»Hochverfügbarkeit« gelegt.
Mein besonderer Dank gilt meinem Koautor und Reisebegleiter während der Arbeit an
diesem Buch: Sebastian Ott. Sebastian möchte zwar an dieser Stelle nicht erwähnt werden, aber ohne seine Hilfe wäre das Buch nicht zu dem geworden, was es jetzt ist. Er hat
nicht nur an vielen Rezepten mitgearbeitet, sondern auch fast alles, was ich teilweise
leicht übermüdet fabriziert habe, zu lesen bekommen, was bestimmt nicht immer eine
leicht verdauliche Kost war.
Weiterhin gilt mein Dank den beiden Fachgutachtern, die viele Dinge hinterfragt und
somit unschätzbar zur Fehlersuche beigetragen haben. Von ihnen habe ich auch das folgende schwäbische Sprichwort gelernt, aber nicht verinnerlicht: Nicht geschimpft, ist
genug gelobt!
Darüber hinaus möchte ich noch meiner Familie danken, die mich immer das hat
machen lassen, was ich für richtig hielt, sowie der Wirtin des Ochsen in Stuttgart-Heslach
und den Betreibern des Cappuccino in Marburg, die mir oftmals bei einem leeren Kühlschrank in heimischen Gefilden ein rettender Hafen waren.
Die größte Entbehrung musste natürlich meine Freundin Manuela-Madeleine ertragen,
die sowieso schon unter meiner Freude, unterwegs zu sein, leiden muss, sowie unter meinem Talent, die mir zur Verfügung stehende Zeit mehrfach zu verplanen; nun musste sie
auch noch auf viele Stunden der rar gesäten gemeinsamen Zeit verzichten. Ich danke dir
XVIII | Vorwort
für dein Verständnis, die immerwährende gute Laune und deine Unterstützung auch in
Zeiten, in denen mein kreatives Chaos andere schon längst zur Verzweiflung getrieben
hätte ;-)
Die Website zum Buch
Unter der URL http://www.picht.org/xenkochbuch finden Sie weitere Informationen und
Updates rund um das vorliegende Buch. Bitte beachten Sie, dass auf diesem Weg leider
kein kostenloser Support angeboten werden kann.
Anmerkungen, Fehler und Kritik
Auch nach vielen Tests auf diversen Distributionen mit unterschiedlichen Kernel- und
Xen-Versionen hat sich bestimmt dennoch der eine oder andere Fehler in dieses Buch
eingeschlichen. Sollten Sie einen solchen finden, zögern Sie nicht, ihn zu melden, und
zwar per E-Mail an [email protected]
Dasselbe gilt natürlich auch für Anmerkungen, Kritik oder Verbesserungsvorschläge.
Vielleicht haben Sie ja sogar das eine oder andere von mir beschriebene Programm selbst
entwickelt, und ich habe den Funktionsumfang nicht richtig erkannt und die wichtigsten
Parameter unverwendet gelassen. Gerne nehme ich Ihre Hinweise entgegen und ergänze
sie dann auf der Webseite des Buches.
Vorwort |
XIX
KAPITEL 1
Einführung in die Virtualisierung
Laut der Umfrage eines amerikanischen IT-Magazins, das die »IT-Buzzwords« des Jahres
2006 untersucht hat, belegte der Ausdruck Virtualisierung Platz eins, gefolgt von RSS,
SAAS (einer SOA-Komponente),Wiki, Social Bookmarking und Web 2.0.
Nur ein Hype? Nein: In den letzten zwei Jahren hat sich gezeigt, dass wir mit dem Schlagwort keineswegs einem kurzlebigen Trend aufgesessen sind, sondern eine intelligente
Technik an die Hand bekommen haben, die verwendet werden kann, um verschiedenste
Probleme zu lösen.
Vorab seien hier vor allem zwei Stärken genannt: Zum einen lässt sich eine virtuelle
Maschine wesentlich schneller in Betrieb nehmen als ein neuer Server, der erst noch
beschafft werden muss. Zum anderen lassen sich durch die Konsolidierung vereinzelter
physikalischer Server in Form von virtuellen Maschinen immense Kosten sparen.
Diese Einführung beschäftigt sich neben der Frage, warum der Begriff »Virtualisierung«
in aller Munde ist und was er eigentlich bedeutet, mit der Herkunft und dem Nutzen dieser Technik für Administratoren, Anwender und Entwickler. Dieses Kapitel soll erst einmal einen Überblick geben – auf viele Hintergründe werde ich dann später bei den
entsprechenden Fragestellungen eingehen, bei denen ein Thema zum ersten Mal behandelt wird.
1.1
Was ist Virtualisierung?
Virtualisierung ist ein breit gefächerter Ausdruck, der nicht eindeutig definiert ist, aber
unter dem oftmals die Emulation oder die Simulation von Hardware-Ressourcen verstanden werden kann. Dieses Konzept führt zu einer Entkopplung von Hardware und
Betriebssystem und in der Folge zu einem höheren Grad an Flexibilität. Mittels Virtualisierung wird eine zentrale, einheitliche Sicht auf bestimmte Ressourcen erreicht, unabhängig von ihrem physikalischen Ort.
|
1
Entgegen der landläufigen Meinung handelt es sich hierbei keinesfalls um eine neu entwickelte Technologie! Virtualisierung wurde bereits in den sechziger Jahren eingesetzt und
hat ihren Ursprung im Mainframe-Umfeld. Dort wurde sie eingesetzt, um die Auslastung
des sehr mächtigen, gleichzeitig aber auch sehr teuren Mainframe zu verbessern. Einem
User konnte schon damals die Illusion vermittelt werden, auf einer eigenen dedizierten
Maschine zu arbeiten, während er tatsächlich nur einen kleinen Teil der gesamten Hardware zur Verfügung hatte.
Versteckte Virtualisierung im Alltag
Man ist sich dessen kaum bewusst, aber auch in ganz gewöhnlichen PCs sind viele verschiedene Virtualisierungstechniken versteckt. Wenn zum Beispiel eine Swap-Partition
existiert, werden der echte Hauptspeicher und die Kapazität der Swap-Partition zu einem
virtuellen Speicher zusammengefasst.
Auch findet beim gleichzeitigen Ausführen verschiedener Programme eine Virtualisierung
statt. Genauso beim Zugriff auf Hardware: Eingabegeräte wie Maus und Tastatur können
von mehreren Applikationen parallel genutzt werden.
Je nach eingesetztem Festplattenspeichersystem, zum Beispiel LVM oder Raid (siehe Kapitel 2, Xen installieren und das Hostsystem vorbereiten (Domain-0)), kann ein Dateisystem
zudem über mehrere Festplatten verteilt sein und in Form einer virtuellen Festplatte angesprochen werden. Virtualisierung ist also keine Geheimwissenschaft, sondern ein gewöhnlicher Bestandteil unseres IT-Lebens.
Zurzeit ist das Thema von starkem Interesse, weil durch Virtualisierung schneller neue
Systeme bereitgestellt werden können und kurzfristig auf sich ändernde Ressourcenanforderungen reagiert werden kann. Einer virtuellen Maschine mehr Hauptspeicher oder
Festplattenplatz zuzuweisen ist wesentlich einfacher zu realisieren als der Einbau neuer
Hardware-Komponenten: Neue Hardware muss meistens die Prozesse Freigabe, Einkauf,
Anlieferung, Aufbau und Installation durchlaufen, dies kann schon einmal mehrere
Wochen benötigen. Zusätzlich wird Virtualisierung interessanter durch neue Prozessoren, die wesentliche Aufgaben direkt auf dem Prozessor ausführen können, was zu einer
Performance-Steigerung führt.
Virtualisierung außerhalb der Informatik
In der Medientheorie bezeichnet Virtualisierung die Tatsache, dass sich journalistische
Themen vermehrt aus virtuellen Quellen ergeben. Virtuell bedeutet in diesem Zusammenhang, dass es keinen persönlichen Kontakt des Autors zum recherchierten Objekt gibt.
Dies ist zum Beispiel bei Informationen von Nachrichtenagenturen oder von Internetseiten
der Fall.
2 | Kapitel 1: Einführung in die Virtualisierung
1.2
Die Geschichte der Virtualisierung
Im Jahre 1959 stellte Christopher Strachey in seiner Abhandlung »Time Sharing in Large
Fast Computers« das Konzept des Multitasking vor. Statt der bisher üblichen streng
sequenziellen Datenverarbeitung schlägt er vor, eine höhere CPU-Auslastung zu erreichen, indem bei Programmen mit Gerätezugriff ein sogenannter Kontextwechsel der
CPU möglich wird. Statt die CPU warten zu lassen, während ein Programm mit den I/OOperationen auf den angeschlossenen Bändern beschäftigt ist, sollte sich die CPU einer
anderen Aufgabe zuwenden können.
Beim Kontextwechsel, im Englischen als context switch bekannt, wird in einem Betriebssystem der Zustand einer CPU gespeichert (stored) bzw. wiederhergestellt (restored), so
dass ein Prozess mit Unterbrechungen abgearbeitet werden kann und sich folglich
mehrere Prozesse eine einzelne CPU teilen können.
Eine Aufteilung des Hauptspeichers in einzelne Teilbereiche ermöglichte außerdem die
gleichzeitige Bearbeitung mehrerer Bänder.
In den 1960ern beschäftigten sich Gerald Popek und Robert Goldberg mit der Frage, welche Anforderungen notwendig sind, um effektiv zu virtualisieren. Dabei stellten sie folgende Anforderungen an ein System:
• Gleichheit: Jedes Programm, das in einer virtualisierten Umgebung ausgeführt wird,
muss sich genauso verhalten wie auf nativer Hardware.
• Effektivität: Ein Großteil der Instruktionen des virtuellen Prozessors muss direkt
vom realen Prozessor ausgeführt werden können.
• Ressourcenkontrolle: Die Virtualisierungkomponente (Virtual Machine Manager,
VMM) muss die komplette Kontrolle über die Ressourcen erhalten: Hauptspeicher,
Eingabegeräte usw...
Im Jahre 1967 baute IBM den Vorläufer virtueller Maschinen auf Mainframes (siehe
Abbildung 1-1). Der hierfür entwickelte Hypervisor ist eine Technologie, die später auf
dem Mainframe als VM bekannt wurde und heutzutage unter dem Namen z/VM firmiert, mit dessen Hilfe man Linux auf dem Mainframe (Linux on System z) einsetzen
kann.
Ende der Siebzigerjahre des vorigen Jahrhunderts entstand das Konzept, eine virtuelle
Maschine zur Implementierung einer Programmiersprache einzusetzen. 1977 wurde mit
P-Code ein Zwischencode von Pascal verwendet, der in einer virtuellen Maschine lief.
Richtig populär wurde dieses Konzept dann 1991 mit oak, dem Vorläufer der Programmiersprache Java, die ebenfalls eine virtuelle Maschine enthält.
Acht Jahre später beginnt VMWare Inc, erste Virtualisierungsprodukte zu verkaufen.
Das Unternehmen ist aus einem Forschungsprojekt an der Universität von Stanford mit
Mendel Rosenblum und den beiden Informatik-Promotionsstudenten Edouard Bugnion
und Scott Devine hervorgegangen.
1.2 Die Geschichte der Virtualisierung |
3
Virtualisierung aus der Sicht der Mathematik
Da Popek und Goldberg Mathematiker waren (zu dieser Zeit gab es noch keinen eigenständigen Studiengang Informatik), stellten sie sich den Zusammenhang zwischen Gastund Hostsystem als Abbildung (im Fachjargon Isomorphismus genannt) vor:
Cr
Cv
f(Si)
Si
ei(Si)
Sj
S' i
e' i(S' i)
S' j
Der linke Teil des Bildes (Cr) repräsentiert das Hostsystem, während die rechte Seite (Cv)
das virtuelle Gastsystem darstellt. Der von Popek und Goldberg verwendete Bezeichner C
steht hierbei für Computer, während die Indizes zwischen real (r) und virtuell (v) unterscheiden. Weiterhin zeigt die Abbildung zwei Zustände Si und Sj (S für state), in denen sich
das System befinden kann, wobei man von Zustand Si nach Sj kommt, indem die Operation ei(Si) ausgeführt wird. Die Verbindung von der linken zur rechten Bildhälfte f(Si) sorgt
für das Mapping zwischen Host und Gast. Auf Seiten der virtuellen Maschine gibt es zu Si
und Sj korrespondierende Zustände namens S'i und S'j sowie die passende Instruktion
e'i(S'i), um von Zustand S'i nach S'j zu kommen.
Die vollständige Veröffentlichung von Goldberg & Popek zu diesem Thema finden Sie
unter http://doi.acm.org/10.1145/361011.361073.
1999 erblickte das von Jeff Dicke ins Leben gerufene Projekt User Mode Linux, abgekürzt UML, das Licht der Welt. Die Abkürzung UML ist mehrfach belegt und sollte
daher nicht mit der Unified Modeling Language verwechselt werden. UML ist eine eigenständige Prozessor-Architektur innerhalb des Linux-Kernel. Der Kernel des Gastsystems
wird dabei innerhalb des Hostsystems wie eine Anwendung gestartet und läuft als Prozess unter der Kontrolle des Hostsystems. Dieses Programm umschließt das darin laufende Linux und schirmt es ab, so dass die darin ausgeführte Anwendung nicht bemerkt,
dass ihr Kernel selbst eine Applikation ist, die auch auf einem weiteren Kernel aufsetzt.
Im Oktober 2003 wurde Xen 1.0 auf einer Konferenz vorgestellt. Xen wurde ursprünglich
von der »Systems Research Group« an der Universität von Cambridge im Computerlabor
entwickelt, als Teil des Xenoserver-Projekts. Xenoserver hat zum Ziel, eine öffentliche
Infrastruktur für verteilte Computerberechnungen zu starten. Xen wurde entwickelt, weil
4 | Kapitel 1: Einführung in die Virtualisierung
Abbildung 1-1: Bild eines historischen Mainframes1
eine Software benötigt wurde, die es erlaubt, eine einzelne Maschine effizient so aufzuteilen, dass mehrere Kunden unabhängig voneinander Betriebssysteme und Anwendungen
ausführen können.1
Mittlerweile ist aus Xenoserver, einem kleinen Teilforschungsprojekt, ein Unternehmen
namens XenSource Inc. mit Sitz in Cambridge und dem Silicon Valley hervorgegangen,
das Xen unter Beteiligung von Firmen wie AMD, HP, IBM, Intel, Novell und RedHat
weiterentwickelt. Im Jahre 2007 wurde der Mehrheitsanteil an XenSource Inc. vom amerikanischen Software-Hersteller Citrix übernommen.
Siehe auch
• http://publib.boulder.ibm.com/infocenter/eserver/v1r2/topic/eicay/eicay.pdf (Veröffentlichung von IBM aus dem Jahre 2006 zum Thema Virtualisierung).
• Weitere Informationen über historische Betriebssysteme finden Sie in Classic Operating Systems: From Batch Processing to Distributed Systems von Per Brinch Hansen,
Springer Verlag (2001).
• Einen guten Überblick über Virtualisierungskonzepte im Allgemeinen liefert Virtual
Machines – Versatile platforms for systems and processes von James Smith und Ravi
Nair, Morgan Kaufmann Publishers (2005).
1 Quelle: http://upload.wikimedia.org/wikipedia/commons/thumb/a/af/DM_IBM_S360.jpg/800px-DM_IBM_S360.
jpg.
1.2 Die Geschichte der Virtualisierung |
5
Virtualisierung und Abstraktion
Man kann sich dem komplexen Begriff »Virtualisierung« auch nähern, indem man ihn von
ähnlichen in diesem Kontext verwendeten Begriffen abgrenzt. Zum Beispiel fällt im Zusammenhang mit der Virtualisierung oft das Wort »Abstraktion«. Abstraktion sorgt für eine
vereinfachte Darstellung von Ressourcen und reduziert hiermit den Grad der Komplexität.
Dadurch werden viele komplizierte EDV-Vorgänge erst durchführbar. Ein Anwendungsentwickler, der ein Programm schreibt, um eine Datei auf der Festplatte zu speichern, muss
sich aufgrund verschiedener Abstraktionsschichten heutzutage weder direkt mit dem Aufbau des Dateisystems noch mit der Ansteuerung der Hardware beschäftigen.
Während Abstraktion aber eher nur Details versteckt, schafft Virtualisierung umfassende
Illusionen, indem sie durch verschiedene Techniken dafür sorgt, dass sich eine Ressource
genauso verhält wie auf nativer Hardware.
Ein prominentes Beispiel für Virtualisierung in diesem Zusammenhang sind beispielsweise
Storage Area Networks (SAN), die virtuelle Festplatten in unterschiedlichen Servern zur
Verfügung stellen, die alle physikalisch in einer entfernten Komponente verwaltet werden.
Auch beim Surfen im Internet begegnet einem das Phänomen der Virtualisierung. Nicht
jede Webseite, die heutzutage aufgerufen werden kann, benötigt einen einzelnen Server,
was auch nicht sehr ökonomisch wäre. Große Internetprovider stellen heutzutage mehrere
Tausend Webseiten zur Verfügung. Die Seiten laufen alle auf unterschiedlichen Domains
(Apache Virtual Hosts), teilen sich aber CPU, Haupt- und Festplattenspeicher.
Zusammengefasst steckt hinter Virtualisierung die Grundidee, dass sich verschiedene
Betriebssysteme eine Hardware teilen und sich dabei jede Betriebssysteminstanz so verhält
wie auf einem physikalischen Rechner. Dadurch wird also ein gleichzeitiger Betrieb verschiedener Systeme unabhängig voneinander auf Basis derselben Hardware möglich.
Durch verschiedene Software- und/oder Hardware-Techniken, abhängig von der Implementierung, werden dabei Betriebssysteminstanzen voneinander abgeschirmt, um parallel
koexistieren zu können.
1.3
Einsatzgebiete und Vorteile
Es gibt verschiedene Einsatzgebiete für Virtualisierung. Unter anderem wird sie verwendet, um die Auslastung von Servern zu erhöhen bzw. um mehrere physikalische Server
auf einer Hardware-Plattform durch virtuelle Maschinen zu konsolidieren, um etwa
Energie und Ressourcen in Rechenzentren effizienter zu nutzen.
Kosteneffizienz
In großen Serverlandschaften fließen viele Faktoren in die Betriebskosten eines jeden Servers ein. Neben den Anschaffungs- und/oder Leasingkosten sind die Unterhaltskosten
für Strom und Wartung nicht unerheblich. Weiterhin kommt das Problem hinzu, dass
sich in einem Rechenzentrum die Stellfläche für Server kaum beliebig vergrößern lässt.
6 | Kapitel 1: Einführung in die Virtualisierung
Die Zusammenführung von Servern auf virtuellen Maschinen kann also den Total Cost of
Ownership (TCO) senken. Das bedeutet, dass die laufenden Kosten für Software, Reparaturen, Wartung und Hardware gesenkt werden können.
Bei einer solchen Zusammenführung muss jedoch darauf geachtet werden, nicht zu viele
Single Point of Failures (SPF) einzubauen: Wenn in einem Serverpark von zehn Servern
ein Server ausfällt, sind neun weiterhin erreichbar. Werden alle auf derselben physikalischen Hardware betrieben, führt der Ausfall des Hosts allerdings zur Nichterreichbarkeit
all dieser zehn Server!
Harmonisierung
Ein weiterer Vorteil der Einführung von Virtualisierungstechniken wie Xen liegt in der
Möglichkeit, die Systeme nicht nur konsolidieren zu können, sondern sie bei dieser Gelegenheit auch gleichzeitig vom Wildwuchs über die Jahre gewachsener Software- und
Hardware-Strukturen zu befreien und einen einheitlichen Disaster Recovery Plan (DRP)
einzuführen.
Unter dem Begriff DRP versteht man eine Reihe von Maßnahmen, die nach einem
Unglücksfall eingeleitet werden. Diese existieren für Behörden, Regierungen, Industrieanlagen genauso wie für die IT. Im einfachsten Fall bezeichnet der Begriff die Datenwiederherstellung durch Zurückspielen eines Backups, nachdem die Festplatte eines Servers
ausgefallen ist. Oftmals ist ein Disaster Recovery Plan Bestandteil oder Teilaspekt eines
Business Continuity Plan (BCP), der festlegt, wie der Geschäftsbetrieb im Falle eines
Unglücks wieder aufgenommen wird.
Flexibilität
Obendrein ist es mit Virtualisierung möglich, flexibel auf schwankende Ressourcenanforderungen zu reagieren. Eine virtuelle Maschine kann im laufenden Betrieb mehr Hauptoder Festplattenspeicher zugewiesen bekommen – vorausgesetzt, das Hostsystem verfügt
über diese Ressourcen. Außerdem ist es wesentlich schneller, eine zusätzliche virtuelle
Maschine zu erstellen, als einen neuen Server zu besorgen.
Durch Konzepte wie die Live-Migration (siehe Kapitel 11, Live-Migration), die das »Verschieben« virtueller Maschinen zwischen unterschiedlichen Hosts ermöglicht, kann
zudem die Ausfallzeit von Systemen gering gehalten werden, da sich kurzzeitige Unterbrechungen durch Wartungsarbeiten ausfallfrei gestalten lassen, so dass sie vom Benutzer gar nicht mehr wahrgenommen werden.
Sicherheit
Im Sicherheitsumfeld werden virtuelle Maschinen bevorzugt eingesetzt, um nicht vertrauenswürdige Anwendungen in einer beschränkten Umgebung auszuführen. Dazu
zählt eine virtuelle Maschine, die keinen Zugriff auf die kompletten Hardware-Ressour-
1.3 Einsatzgebiete und Vorteile |
7
cen eines PCs hat. Wird eine nicht vertrauenswürdige Anwendung – und dazu kann man
auch einen Webserver mit einer PHP-Anwendung zählen – zu einem Sicherheitsproblem,
so ist davon lediglich die virtuelle Maschine und nicht der komplette Host mit allen
darauf enthaltenen Daten betroffen.
Diese Tatsache haben jedoch auch schon Virenprogrammierer herausgefunden, und es
existieren erste Schadprogramme (Malware), die überprüfen, ob sie in einer virtuellen
Umgebung ausgeführt werden, und sich dann unauffällig verhalten und nur auf echter
Hardware zum Leben erweckt werden. Umgekehrt existieren bereits erste Ansätze, bei
denen sich Viren die Hardware-Virtualisierungsfunktionen moderner Prozessoren
zunutze machen und das laufende Betriebssystem unbemerkt unter die Kontrolle eines
Hypervisors stellen. Das eigentliche Schadprogramm wird als weitere virtuelle Instanz
»neben« dem eigentlichen Betriebssystem ausgeführt und ist so für dieses nicht mehr
erkennbar. Solche Angriffe, zu denen auch Joanna Rutkowskas blue pill zählt, sind
jedoch weitestgehend von wissenschaftlicher Neugier bezüglich der Machbarkeit und
experimentellen Implementierungen geprägt. Im Endeffekt überwiegen im Kontext virtueller Maschinen jedoch eindeutig die Sicherheitsvorteile.
Einsparung von Hardware
Im Schulungsumfeld wird Virtualisierung eingesetzt, um Hardware zu sparen und so beispielsweise in einem Kurs für Linux-Systemadministratoren auch mehrere Server zur Verfügung zu haben, ohne sich im Schulungsraum wie in einem Rechenzentrum zu fühlen.
1.4
Virtualisierungsarten
Es existieren viele verschiedene Virtualisierungstechnologien, die sich in folgende Bereiche einteilen lassen:
• Programmiersprachen
• Interpretation und Simulation
• Systemvirtualisierung
• Prozessvirtualisierung
• Hardware-Virtualisierung/Full Virtualization
• Paravirtualisierung
• Hardware-Virtualisierung durch Partitionierung
Virtualisierung bei Programmiersprachen
Im Umfeld von Programmiersprachen kommt Virtualisierung z.B. bei Java zum Zuge –
und zwar in Form der Java Virtual Machine (JVM), um dadurch Plattformunabhängigkeit zu erreichen (siehe Abbildung 1-2).
8 | Kapitel 1: Einführung in die Virtualisierung
Quellcode
-------------------------------------------------------------
Java Runtime
Byte-Code
------------- ------------------------- ------------------------- -------------
UNIX
PC
Macintosh
...
Abbildung 1-2: Die Java Virtual Machine
Java-Quellcode wird in ein Zwischenformat übersetzt, das Bytecode genannt wird. Auf
jedem Betriebssystem bzw. der entsprechenden Hardware, für die eine Java Virtual
Machine existiert, kann dieser Bytecode dann ausgewertet und die darin hinterlegten
Programminstruktionen ausgeführt werden.
Dadurch ist weder ein erneutes Übersetzen des Quellcodes noch eine Portierung auf eine
andere Hardware-Plattform notwendig, sofern eine Java-Laufzeitumgebung (JRE – Java
Runtime Environment) existiert, welche die virtuelle Maschine enthält.
Andererseits darf allerdings der Code auch keine betriebssystemspezifischen Codefragmente haben. Eine hosts-Datei zur Namensauflösung, die
sich bei Windows unter c:\winnt\system32\drivers\etc\hosts befindet, wird
unter Linux nicht automatisch unter /etc/hosts gesucht.
Interpretation und Simulation/Emulation
Ein weiterer Virtualisierungsansatz besteht in der Simulation eines kompletten Systems.
Hierzu zählen Programme wie das von Fabrice Bellard entwickelte QEMU (http://fabrice.
bellard.free.fr/qemu/) und Bochs (http://bochs.sourceforge.net/), die ein komplettes System
1.4 Virtualisierungsarten |
9
bzw. komplette Instruktionen einer anderen Architektur emulieren und somit auch die
Ausführung von Betriebssystemen ermöglichen, die für eine ganz andere Hardware ausgelegt sind.
Im Zuge der Emulation wird ein System auf einem anderen nachgeahmt, wobei es dieselben Daten verarbeitet und bei Berechnungen zu demselben Ergebnis kommt wie das Original, jedoch in der Regel mit verringerter Geschwindigkeit.
Funktionsweise
Um dieses Konzept einfach verständlich zu machen: Man kann ja bekanntlich ein System
in Hardware- und Software-Komponenten unterteilen. Hierbei zählen zur Software
neben einem Programm ebenfalls die von einer Applikation benötigten Bibliotheken,
genauso wie das Betriebssystem, welches wiederum aus verschiedenen Komponenten
besteht.
Zwischen der Hardware und Software befindet sich die sogenannte Instruction Set
Architecture (ISA). Im Deutschen könnte man hier von der »Befehlssatzarchitektur« sprechen. Hierbei handelt es sich stark vereinfacht um eine Grenze zwischen Hardware und
Software, die gleichzeitig einer Richtlinie über das Verhalten des Prozessors aus Sicht des
Programmierers bzw. des Entwicklers eines Compilers entspricht (siehe Abbildung 1-3).
Das Konzept einer ISA wurde im Zuge der Entwicklung des ersten IBM-Mainframes,
Modell S/360, eingeführt.
Applikationen
Bibliotheken
Gast
Gast-ISA
Betriebssystem
Treiber
Scheduler
Memory
Management
Emulation
Instruction Set Architecture (ISA)
Host-ISA
Hardware
Host
Abbildung 1-3: Emulation von unterschiedlichen Hardware-Umgebungen
Die einfachste Emulationsmethode ist die Interpretation. Hierbei analysiert ein Programm die Instruktionen für die Ziel-ISA, dekodiert diese und emuliert das entsprechende Verhalten, wie in Abbildung 1-4 zu sehen ist. Die Dekodierung wird in der
sogenannten »Dispatch Loop« durchgeführt. Diese kann im einfachsten Fall in Form
10 |
Kapitel 1: Einführung in die Virtualisierung

Documentos relacionados