© bruzzomont, photocase.com

Eine Virtualbox-Installation fährt Schnappschüsse virtueller Maschinen in Sekundenschnelle von der Kommandozeile hoch und hilft dem vorsichtigen Nutzer, beim Browsen die Privatsphäre zu wahren und Perl-Module durch einen Smoketest zu schicken.

Wer ständig neue Linux-Distributionen ausprobiert, der bedient Virtualisierer wie VMware, KVM, Xen oder Virtualbox wahrscheinlich im Schlaf. Auch Programmierer, die Code für unterschiedliche Linux-Versionen oder – Gott bewahre! – Microsoft Windows entwickeln, schätzen lokal verfügbare virtuelle Maschinen für schnelle Tests. Das Virtualisierungspaket Virtualbox [2] ist einfach mittels eines ansprechenden GUI (Abbildung 1) zu bedienen und bequem als Ubuntu-Paket unter der GPLv2-Lizenz verfügbar.

Abbildung 1: Virtualbox mit einigen Ubuntu- und Windows-Versionen als Gastsysteme.

Gästeliste

Mit Hilfe von Installations-CDs, DVDs oder ISO-Dateien legt der User im Virtualisierer schnell eine Handvoll Gastsysteme an, die auf Knopfdruck in eigenen Fenstern hochfahren.

Die Steuerung der Maus im Gastsystem bedarf einer kurzen Gewöhnungsphase, denn hat das Gastsystem einmal den Mausfokus, gibt es ihn nicht mehr her, der Mauszeiger eckt an den Grenzen des Gastsystemfensters an. Um den Fokus des virtuellen Systems zu verlassen, drückt der User eine bestimmte Taste (voreingestellt ist die rechte [Alt]-Taste), woraufhin der Mauszeiger wieder auf dem heimischen Desktop weilt.

Dank der effizienten Technik für Schnappschüsse frieren virtuelle Maschinen Zustände rasch ein und stellen sie später in wenigen Sekunden wieder her. So können Websurfer eine frisch erzeugte Ubuntu-Installation mit offenem Browser für peinliche Webrecherchen nutzen: Was Google über seine Nutzer weiß, kommt immer dann erschreckend zutage, wenn der User einen Suchbegriff eingibt und die Autocomplete-Funktion Vervollständigungen vornimmt (Abbildung 2). Niemand möchte daran erinnert werden, dass er vor einigen Tagen etwa nach “Fußpilz” gesucht hat, ganz zu schweigen vom Einfluss des Suchbegriffs auf das Langzeit-Targeting von Googles personalisierter Werbemaschine.

Abbildung 2: Diesen peinlichen Suchbegriff vergisst der Browser beim nächsten Hochfahren der VM.

Der paranoide Pinguinfreund möchte weder die ausgestellten Cookies länger als nötig behalten noch irgendwelche Spuren in der Browserhistory hinterlassen. Da er nicht genau weiß, was der Browser hinter seinem Rücken alles an Caching und sonstiger Datenspeicherei betreibt, liegt es nahe, für sensitive Suchanfragen blitzschnell eine virtuelle Maschine mit eingabebereitem Browser hochzufahren, die Suche durchzuführen und gleich darauf die VM wieder in ihren Ausgangszustand zurückzuversetzen.

Das Verfahren ist zwar nicht hundertprozentig wasserdicht, James Bond könnte auf meiner virtuellen Festplatte wohl noch Datenschnipsel finden und auch die IP-Adresse des verwendeten Routers taucht in den Google-Logs auf, aber es legt die Latte merklich höher. Wer mehr Privatsphäre wünscht, sollte Tor bemühen und die VM-Festplatte nach Gebrauch mit »shred« zerstören.

Kurz nach der Linux-Installation von der DVD öffnet der auf seine Privatsphäre bedachte User also im nagelneuen Gastsystem den Firefox-Browser und zieht vom aktuellen Zustand der VM einen Snapshot (Abbildung 3). Nach Abschluss der geheimen Mission fährt er die VM mit »stop« im »poweroff« -Modus herunter und stellt via Restore-Funktion des Virtualbox-Snapshot-Menüs den ursprünglichen Zustand wieder her. Beim nächsten Hochfahren steht wieder ein offener Browser bereit, der sich an nichts mehr erinnert, ganz so, als wäre ein Zeitsprung in die Vergangenheit erfolgt.

Abbildung 3: Im neuen Gastsystem zieht der User einen Schnappschuss per Klick ins Menü.

Automatisch als Kommando

Statt für jede Recherche das Virtualbox-GUI hochzufahren und in dessen Menüs herumzuklicken, bietet sich ein Perl-Skript an, das selbstständig die VM auswählt und hochfährt. Nach getaner Arbeit drückt der User im Skript die [Enter]-Taste, die VM fährt herunter und der Startzustand ist wiederhergestellt. Mit dem Programm »VBoxManage« liefert Virtualbox eine Komplettsteuerung von der Kommandozeile.

Listing 1 zeigt das Perl-Skript, das die VM namens »Ubuntu 10.04« und deren vorher manuell angelegten Snapshot »Browse« auswählt. Mit Hilfe des »tap« -Kommandos aus dem CPAN-Modul Sysadm::Install setzt es die Shellbefehle ab.

01 #!/usr/local/bin/perl -w
02 use strict;
03 use Sysadm::Install qw(:all);
04 use Log::Log4perl qw(:easy);
05
06 Log::Log4perl->easy_init($DEBUG);
07
08 my $vbm = "VBoxManage";
09 my $vm = "Ubuntu 10.04";
10
11 tap $vbm, "snapshot", $vm, "restore", "Browse";
12 tap $vbm, "startvm", $vm;
13
14 print "Press Enter for shutdown";
15 <STDIN>;
16
17 tap $vbm, "controlvm", $vm, "poweroff";
18 tap $vbm, "snapshot", $vm, "restore", "Browse";

Das Skript ließe sich wohl noch einfacher als Shellskript implementieren, aber erfahrene Perl-Programmierer wissen, dass es nur eine Frage der Zeit ist, bis ein Shellskript im Funktionsumfang so unüberschaubar anwächst, dass man es doch in Perl reimplementiert, weil es sonst nicht mehr zu warten ist.

Das Skript nutzt die beiden Unterkommandos »startvm« und »ctrlvm poweroff« von »VBoxManage« , um die VM herauf- und später auch wieder herunter zu fahren. Den Snapshot restauriert es sowohl am Anfang als auch am Ende des Skripts, um sicherzustellen, dass die virtuelle Maschine auch dann verlässlich im Initialzustand hochfährt, wenn jemand inzwischen in dem Snapshot-Menü des Virtualbox-GUI herumgefuhrwerkt hat.

Beschränkt vernetzt

Virtualbox-VMs lassen sich aber auch im Headless-Modus ganz ohne Bildschirmausgabe steuern. Ein unsichtbar im laufenden Gastsystem installierter SSH-Daemon erlaubt dem Hostsystem, dort Befehle auszuführen oder mit dem Gastsystem Dateien auszutauschen.

Virtualbox fährt Gastsysteme aber von Haus aus im NAT-Modus (Network Address-Translation) hoch, weist ihnen eine Adresse im virtuellen 10.x.x.x-Netz zu und kommuniziert mit dem lokalen Netz des Hosts über eine Adressenumwandlung, ähnlich wie die meisten Router in Privathaushalten lokale Geräte mit ihren 192.168.x.x-Adressen mit dem Internet verbinden. Dies funktioniert aus der VM ins lokale Netz ohne Probleme, nur dürfen Host oder Geräte im lokalen Netz keine Verbindung mit der VM aufnehmen. Dies lässt sich über den Dialog »Network Adapters« ändern, der sich hinter zwei symbolisierten Terminals am rechten unteren Rand der VM verbirgt.

Brücke öffnet Firewall

Ändert man die Einstellung von »NAT« in »Bridged Mode« , holt die VM eine IP-Adresse im lokalen Netz vom DHCP-Server ab (etwa 192.168.0.135) und wandelt sich zum gleichberechtigten Kommunikationspartner. Ein in der VM installierter SSH-Daemon (»sudo apt-get install openssh-server« ) gewährt dann Clients auf dem Host oder im lokalen Netz, die sich mit »ssh 192.168.0.135« in der VM mit ihrer User-ID anmelden, anstandslos Zugriff. Kopiert der User auch noch seinen SSH-Public-Key (etwa »~/.ssh/id_rsa.pub« ) in die Datei »~/.ssh/authorized_keys« in der VM, geht es sogar ohne Passwort, was für automatisch ablaufende Skripte wichtig ist – wenn der zugehörige Private Key ohne Passphrase angelegt wurde.

Knifflig ist es herauszufinden, welche IP sich eine VM beim Hochfahren geangelt hat. Virtualbox bietet eine Methode über die Guest Properties, eine Erweiterung, die über den Menü-Eintrag »Devices/Install Guest Additions« einer laufenden VM zu installieren ist. Dann lädt die VM eine ISO-Datei vom Web, mountet sie als CD-Drive und führt ein auf der CD liegendes Shellskript aus, das anfängt wild Kernelmodule zu kompilieren.

Bei meiner Virtualbox-Version 3.1.6 funktionierte das Verfahren aber nicht, ich musste zuerst »VBoxGuestAdditions _3.1.6.iso« manuell in die VM herunterladen, über »mount -o loop« mounten, das Ubuntu-Paket »dkms« installieren und dann das Shellskript »VBoxLinuxAdditions-x86.run« ausführen (Abbildung 4). Zu beachten ist, dass dies nicht mit Ubuntu 11 als Gastsystem funktioniert, wenn auf dem Host Ubuntu 10.04 läuft. Nach einem Neustart der VM kann der Host den Befehl »VBoxManage guestproperty enumerate “Ubuntu 10.04″« absetzen und erhält in einem Wust von weiteren Informationen auch die Zeile:

Abbildung 4: Die Installation der »Guest Additions« erfordert einige Handarbeit.

"Name: /VirtualBox/GuestInfo/Net/0/V4/IP, value: 192.168.0.135"

Sie zeigt ihm die von der virtuellen Maschine verwendete IP. Wer statt »enumerate« ein »get« auf den Guestinfo-Pfad absetzt, bekommt die IP der laufenden VM direkt übermittelt (Abbildung 5).

Abbildung 5: Die Guest Properties zeigen, welche IP sich eine virtuelle Maschine geholt hat.

Schornstein raucht

Falls CPAN-Module ihre Abhängigkeiten zu weiteren Modulen ordnungsgemäß angeben, erledigt eine CPAN-Shell die Installation ohne viel Federlesen. Leider vergessen Autoren manchmal Module anzugeben, die sich auf ihrem Entwicklungsrechner befinden, aber blanken Perl-Installationen nicht beiliegen. Anwenderfrust ist die Folge, falls nicht einer der heutzutage automatisch aktivierten Smoketests das Problem erkennt und den Autor benachrichtigt.

Abhilfe schafft eine als VM-Snapshot festgehaltene frische Perl-Installation, die der Modul-Autor mit Hilfe des Skripts »cpan-smoke« in Listing 2 hochfährt, ihr einen gerade erzeugten CPAN-Distributions-Tarball übergibt und dort eine CPAN-Shell testen lässt, ob die neue Version auf einem jungfräulichen System mit CPAN-Anschluss installierbar ist. Läuft die dem Modul beiliegende Testsuite ohne Fehler, gilt der so genannte Smoke-Test als bestanden, die Chancen stehen gut, dass sich das Modul auf ähnlichen Systemen installieren lässt.

#!/usr/local/bin/perl -w
02 use strict;
03 use Sysadm::Install qw(:all);
04 use Proc::Simple;
05 use Net::Ping;
06 use Log::Log4perl qw(:easy);
07
08 my( $tarball) = @ARGV;
09
10 die "usage: $0 tarball" if
11 !defined $tarball;
12
13 Log::Log4perl->easy_init($ERROR);
14
15 my $vbm = "VBoxManage";
16 my $vbh = "VBoxHeadless";
17 my $vm = "Ubuntu 10.04";
18 my $ippath =
19 "/VirtualBox/GuestInfo/Net/0/V4/IP";
20 my $snap = "CPAN Smoke";
21
22 # in case it's up in foreground
23 tap $vbm, "controlvm", $vm, "poweroff";
24 tap $vbm, "snapshot",
25 $vm, "restore", $snap;
26
27 my $proc = Proc::Simple->new();
28 $proc->start("$vbh --startvm '$vm'");
29 END {
30 $proc->kill();
31 }
32
33 INFO "Waiting for VM to come up";
34
35 while( !$proc->poll() ) {
36 DEBUG "Waiting for VM process";
37 sleep 1;
38 }
39
40 my $ip;
41
42 while( !defined($ip = ip()) ) {
43 DEBUG "Waiting for IP";
44 sleep 1;
45 }
46
47 my $ping = Net::Ping->new();
48 while( !$ping->ping($ip) ) {
49 DEBUG "Waiting for Ping";
50 sleep 1;
51 }
52
53 INFO "VM is up: $ip";
54
55 tap "scp", $tarball, "$ip:/tmp/$tarball";
56 sysrun "ssh", $ip,
57 qq{eval \$(/usr/bin/perl -Mlocal::lib);
58 cpanm /tmp/$tarball};
59
60 tap $vbm, "controlvm", $vm, "poweroff";
61 tap $vbm, "snapshot",
62 $vm, "restore", $snap;
63
64 ###########################################
65 sub ip {
66 ###########################################
67 my($stdout) = tap $vbm, "guestproperty",
68 "get", $vm, $ippath;
69
70 if( $stdout =~ /Value: (.*)/ ) {
71 return $1;
72 }
73
74 return undef;
75 }

Zweige im Snapshot-Baum

Hierzu konfiguriert der Entwickler in einer virtuellen Maschine mit den nachträglich installierten »Guest Additions« eine CPAN-Shell, zieht davon einen Snapshot und nennt ihn »CPAN Smoke« . Abbildung 6 zeigt, dass es im Snapshot-Baum der virtuellen Maschine »Ubuntu 10.04« nun zwei Zweige gibt. Der anfangs erzeugte Snapshot »Browse« baut auf einer frischen Installation auf und existiert unabhängig von eventuellen weiteren »CPAN Smoke« -Snapshots.

Abbildung 6: Ein neuer Snapshot »CPAN Smoke« baut auf den »Guest Additions« auf und verfügt über eine konfigurierte CPAN-Shell.

Damit die Installation auch mit der Mini-CPAN-Shell »cpanm« im lokalen Verzeichnis klappt, hat der Snapshot »CPAN Smoke« das CPAN-Modul »clocal::lib« installiert. In einem Ubuntu-System gelangt es am besten über das Kommando

sudo apt-get install liblocal-lib-perl

durch den Package-Manager in die virtuelle Maschine. Das Kommando

$ eval $(/usr/bin/perl -Mlocal::lib)

in der Shell setzt dann die notwendigen Shellvariablen für die Installation weiterer Module im lokalen Verzeichnis. So installiert sich auch die Mini-Shell lokal mit Hilfe der großen CPAN-Shell:

cpan App::cpanminus

Anschließend steht das Kommando »cpanm« zur Installation weiterer Module im »$PATH« zur Verfügung:

$ cpanm --version
cpanm (App::cpanminus) version 1.4008

Wer genau mitverfolgen möchte, wie die Installation von App::cpanminus in einer frisch angelegten Ubuntu-Installation abläuft, kann sich dies im Screencast zum Perl-Snapshot ansehen (siehe Kasten “Online PLUS”).

An dieser Stelle wird dann der Snapshot gezogen und als »CPAN Smoke« benannt. Ruft man auf dem Host dann »cpan-smoke« mit einem Tarball eines mit »make tardist« erzeugten CPAN-Tarballs als Argument auf, restauriert das Skript den Snapshot, fährt die virtuelle Maschine hoch und wartet, bis deren Netzwerk-Konfiguration abgeschlossen ist und sie auf ein »ping« reagiert.

Die Funktion »ip()« ab Zeile 65 von Listing 2 sucht die IP-Adresse der verwendeten virtuellen Maschine mit Hilfe der »guestproperty« -Anfrage an Virtualbox. Ein regulärer Ausdruck greift sich aus der wortreichen Ausgabe die relevante IP-Nummer.

Der »VBoxHeadless« -Befehl »–startvm« in Zeile 28 startet die virtuelle Maschine ohne jede GUI-Ausgabe und wartet im Vordergrund, bis der User das Programm mit [Ctrl]+[C] abschießt. Das CPAN-Modul Proc::Simple schickt er deshalb in den Hintergrund und merkt sich die PID, damit das am Ende des Skripts ausgelöste »END« -Snippet ab Zeile 29 seinen »kill()« -Befehl an das richtige Programm schickt und die kopflose virtuelle Maschine herunterfährt.

Steigt Rauch auf?

Dann kopiert Zeile 55 den Tarball in das »/tmp« -Verzeichnis der virtuellen Maschine und die Zeilen 56 bis 58 starten dort das Kommando »cpanm [Tarball]« , das sich den Tarball schnappt, ihn entpackt und »make« -Kommandos zum Testen und zur Installation ausführt. Stößt »cpanm« auf CPAN-Module, von denen das Modul laut dessen Angaben abhängt, lädt es diese vom CPAN und installiert sie ebenfalls.

Damit die Shell in der VM das Kommando »cpanm« findet, nach installierten Modulen im lokalen Pfad »~/perl5« sucht und dort neue Module installiert, erteilt der »ssh« -Befehl in Zeile 56 vor dem eigentlichen »cpanm« -Kommando noch den weiter oben gezeigten »eval« -Befehl, der die nötigen Shellvariablen setzt.

Die Ausgabe des Installationsskripts »cpanm« landet dank der »sysrun« -Funktion des Moduls Sysadm::Install auf der Standardausgabe des rufenden Skripts »cpan-smoke« , wo der Entwickler ablesen kann, wie seine neueste Kreation sich in einer fremden Umgebung schlägt. Falls dann dunkler Rauch aufsteigt, stimmen wohl die definierten Abhängigkeiten zu anderen CPAN-Modulen nicht.

Auch im Cloudzeitalter, in dem virtuelle Maschinen wie Amazons EC2 im Internet zum Spartarif zur Verfügung stehen, bleibt eine lokale Virtualisierungslösung wie Virtualbox attraktiv. Eine detaillierte Bedienungsanweisung für Neulinge – gegenüber den oft wenig strukturierten Internetinhalten – bietet [3], allerdings beschreibt sie die fast schon veraltete Version Virtualbox 3.1.