Virtuelles Netzwerk in einer Qemu-KVM Umgebung einrichten

Aus Bluelupo's Wiki
Wechseln zu: Navigation, Suche


Begriffserklärung


Warum ein virtuelles Netzwerk einrichten

Dieser Artikel behandelt ein fortgeschrittenes Thema der Virtualisierung und baut auf ein gewisses Basiswissen und Erfahrung rund um Qemu-KVM auf. Standardmäßig ist eine virtuelle Maschine vom Wirtsystem (Host) aus Sicherheitsgründen abgeschirmt und somit über die normalen Netzwerkverbindungen, wie ftp, ssh, scp usw. nicht zu erreichen. Unter Umständen ist es für bestimmte Einsatzzwecke nötig das ein gemeinsames Netzwerk von allen virtuellen Gästen, sowie des Wirtsystem nutzen zu können. Qemu-KVM kann mit Hilfe einer Software-Brigde das lokale Netzwerk mit dem virtuellen Netz verbinden.


Installation

Zuerst müssen auf dem Wirtsystem zwei Pakete installert damit man mit den Konfigurationsarbeiten beginnnen kann. Dazu ein die Konsole öffnen und als root einloggen. Danach die Pakete uml-utilities und bridge-utils installieren.

# apt-get install uml-utilities bridge-utils


Damit das ganze überhaupt zum Laufen kommt sind folgende Qemu-KVM Pakete nötig.

  • qemu-kvm
  • qemu-utils

Wenn noch nicht installiert dann ggf. nachholen.

# apt-get install qemu-kvm qemu-utils


Konfiguration

Die Konfiguration gliedert sich in zwei Teile, erstens am Wirtsystem und zum zweiten am Gastsystem(en).

Konfiguration vom Wirtsystem anpassen

Bitte vor dem verändern von wichtigen Konfigurationsdateien die jeweilige Datei an einen sicheren Ort kopieren um für alle Fälle ein Backup zu besitzen.

Gruppenzugehörikeit

Der User der später die virtuellen System starten und nutzen soll muss in der Gruppe kvm sein. Dazu den User modifizieren. Hier im Beispiel den Usernamen michael an eigene Bedürfnisse anpassen.

# usermod -a -G kvm michael


Network-Manager deaktivieren

Bei siduction ist der Network-Manager mittlerweile Standard, aber mit dieser Version des NM ist eine Bridge-Netzwerk-Config nicht erfolgreich zu erstellen (Stand Februar 2015). Hier hilft nur den NM zu deaktivieren und auf das bewährte Verfahren via ifupdown-Netzwerk zurück zu greifen.

Evtl. Configdateien des NM unter /etc/NetworkManager/system-connections sichern.

NM deaktivieren:

# systemctl disable NetworkManager.service

So sollte dann der Status sein:

# systemctl status NetworkManager.service
  NetworkManager.service - Network Manager
  Loaded: loaded (/lib/systemd/system/NetworkManager.service; disabled)
  Active: inactive (dead)

Die vorhandene /etc/network/interfaces ebenfalls sichern.

# mv /etc/network/interfaces /etc/network/interfaces.ORIG

Achtung, wenn man den NM deaktiviert, funktioniert natürlich nicht mehr die GUI des Network-Managers im KDE zur Konfiguration eines Netzwerkes. Ggf. kann man das Miniprogramm des NM aus der KDE-Kontrollleiste entfernen.

Netzwerk anpassen

Zur Netzwerk Konfiguration in /etc/network/interfaces muss diese neu erstellt werden. Das Devive bri0 ist die "Software-Brücke" (Bridge) die das Verbindungsstück zwischen lokalen und virtuellen Netz ist. eth0 ist das reale Neztwerkinterface das im Rechner steckt. Die Bridge wird mit einer festen IP-Adresse konfiguriert. Im Beispiel gehe ich von dem Netz 192.168.178.0 aus, an dem drei Machinen angeschlossen sind, ein Wirtsystem und zwei virtuelle Gäste sowie ein Router (z.B. FritzBox) an dem das Wirtsystem per LAN-Kabel angeschlossen ist.

IP-Adressen:

  • 192.168.178.1 Router zum Anschluss ans Internet
  • 192.168.178.100 Wirtsystem
  • 192.168.178.101 Erstes Gastsystem
  • 192.168.178.102 Zweites Gastsystem


auto lo
iface lo inet loopback
auto eth0
iface eth0 inet manual
auto bri0
iface bri0 inet static
     address 192.168.178.100
     broadcast 192.168.178.255
     gateway 192.168.178.1
     netmask 255.255.255.0
     network 192.168.178.0
     dns-nameservers 192.168.178.1
     dns-search 192.168.178.1
     bridge_ports eth0
     bridge_fd 9
     bridge_hello 2
     bridge_maxage 12
     bridge_stp off
     bridge_maxwait 5

KVM Startscript anpassen

Das KVM-Startscript unter /etc/kvm/kvm-ifup muss unbedingt angepasst werden. Nachfolgend werden die Originalversion und die angepasste Version gezeigt. Wichtig ist hier vorallen die erste Zeile im Script, der sogenannte Shebang . Diese ist leider bei der Linux-Distribution siduction ein Link auf die dash und bei der Ausführung Problem bereitet. Bitte abändern und wie weiter unten aufgelistet, auf die bash linken.

#! /bin/sh
# Script to bring a network (tap) device for qemu-kvm up
# The idea is to add the tap device to the same bridge
# as we have default routing to.

switch=$(ip route ls | \
   awk '/^default / {
         for(i=0;i<NF;i++) { if ($i == "dev") { print $(i+1); exit; } }
        }'
       )
/sbin/ifconfig $1 0.0.0.0 up

# only add the interface to default-route bridge if we
# have such interface (with default route) and if that
# interface is actually a bridge.
if [ -n "$switch" -a -d /sys/class/net/$switch/bridge/. ]; then
  /usr/sbin/brctl addif $switch $1 || :
fi


Hier die angepasste und vereinfachte Version von /etc/kvm/kvm-ifup mit korrekter Shebang.

#!/bin/bash
switch=$(/sbin/ip route list | awk '/^default / { print $NF }')
/usr/bin/sudo /sbin/ifconfig $1 0.0.0.0 up
/usr/bin/sudo /usr/sbin/brctl addif ${switch} $1

sudo anpassen

Um als User die jeweiligen Aktionen wie z.B.Netzwerk starten und stoppen, TUN- und TAP-Devices erzeugen usw durchführen zu können,. sind einige Command -Aliase in der sudo-Konfiguration zu definieren. Der User, der in der Gruppe kvm ist, soll ohne Passwortabfrage die Kommandos tunctl, ifconfig brctl und ip ausführen dürfen.

Dazu als root auf der Konsole das Kommando visudo ausführen und die nachfolgenden Zeilen via Copy&Paste einfügen und abspeichern:

Cmnd_Alias KVM = /usr/sbin/tunctl, /sbin/ifconfig, /usr/sbin/brctl, /sbin/ip
%kvm ALL=(ALL) NOPASSWD: KVM

Als User kann man dies überprüfen, indem man in der Konsole sudo -l ausführt:.

$ sudo -l
Matching Defaults entries for michael on this host:
   env_reset

User michael may run the following commands on this host:
   (ALL) NOPASSWD: /usr/sbin/tunctl, /sbin/ifconfig, /usr/sbin/brctl, /sbin/ip

Konfiguration vom Gastsystem anpassen

Auf den Gastsystemen müssen wir den Netzwerkinterfaces eine feste IP-Adresse zuweisen. Das kann man bei siduction im KDE mit der GUI des Network-Manager erledigen.

IP-Adresse Gast1: 192.168.178.101

IP-Adresse Gast2: 192.168.178.102

Gateway und DNS-Server: 192.168.178.1


Sollte die alte konventionelle Netzwerk-Config (wie am Wirt) erfolgen sind folgende /etc/network/interfacess zu erstellen.

Gast1:

auto lo
iface lo inet loopback
allow-hotplug eth0
iface eth0 inet static
  address 192.168.178.101
  broadcast 192.168.178.255
  gateway 192.168.178.1
  netmask 255.255.255.0
  network 192.168.178.0
  dns-nameservers 192.168.178.1
  dns-search 192.168.178.1


Gast2:

auto lo
iface lo inet loopback
allow-hotplug eth0
iface eth0 inet static
  address 192.168.178.102
  broadcast 192.168.178.255
  gateway 192.168.178.1
  netmask 255.255.255.0
  network 192.168.178.0
  dns-nameservers 192.168.178.1
  dns-search 192.168.178.1

Manuelles Starten der virtuellen Maschinen

Um die nachfolgende Automatisierung zu verstehen, muss man als Grundlage die Netzwerkverbindungen via Bridge erst einmal manuell aufbauen. Die vorangegangen Schritte der Netzwerkkonfiguration sind auf Wirt- und Gastsystem(en) abgeschlossen.

Ein ifconfig am Wirtsystem zeigt die neuen Geräte

$ sudo /sbin/ifconfig
bri0      Link encap:Ethernet  Hardware Adresse 00:01:80:78:82:35  
          inet Adresse:192.168.178.100  Bcast:192.168.178.255  Maske:255.255.255.0
          inet6-Adresse: fe80::201:80ff:fe78:8235/64 Gültigkeitsbereich:Verbindung
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metrik:1
          RX packets:106261 errors:0 dropped:0 overruns:0 frame:0
          TX packets:78679 errors:0 dropped:0 overruns:0 carrier:0
          Kollisionen:0 Sendewarteschlangenlänge:0 
          RX bytes:58928291 (56.1 MiB)  TX bytes:10451558 (9.9 MiB)

eth0      Link encap:Ethernet  Hardware Adresse 00:01:80:78:82:35  
          inet6-Adresse: fe80::201:80ff:fe78:8235/64 Gültigkeitsbereich:Verbindung
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metrik:1
          RX packets:125003 errors:0 dropped:0 overruns:0 frame:0
          TX packets:79224 errors:0 dropped:0 overruns:0 carrier:0
          Kollisionen:0 Sendewarteschlangenlänge:1000 
          RX bytes:67358102 (64.2 MiB)  TX bytes:10473746 (9.9 MiB)
          Interrupt:20 Speicher:fe9c0000-fe9e0000 

lo        Link encap:Lokale Schleife  
          inet Adresse:127.0.0.1  Maske:255.0.0.0
          inet6-Adresse: ::1/128 Gültigkeitsbereich:Maschine
          UP LOOPBACK RUNNING  MTU:16436  Metrik:1
          RX packets:1347 errors:0 dropped:0 overruns:0 frame:0
          TX packets:1347 errors:0 dropped:0 overruns:0 carrier:0
          Kollisionen:0 Sendewarteschlangenlänge:0 
          RX bytes:89892 (87.7 KiB)  TX bytes:89892 (87.7 KiB)


Mit dem Kommando brctl kann man sich den Zustand der Software-Brigde anzeigen lassen. Das Netzwerkdevice eth0 ist virtuell schon an die Bridge angeschlossen:

$ sudo /usr/sbin/brctl show
bridge name     bridge id               STP enabled     interfaces
bri0            8000.000180788235       no              eth0


Nun muss man die TAP-Devices noch an die Bridge binden, damit die Gäste auf das gemeinsame Netzwerk zugreifen können. Mit dem Kommando tunctl erzeugen wir TAP-Device das vom User "michael" (Mitglied der Gruppe kvm) genutzt werden kann.

$ sudo /usr/sbin/tunctl -b -u michael -g kvm
tap0


Die Vorbereitungen sind soweit abgeschlossen und nun kann man mit dem Kommando kvm den virtuellen PC starten. Im nachfolgenden Beispiel wir von einer bestehenden siduction Installation mit dem Imagenamen siduction-virtpc01.img ausgegangen. Des weiteren wird die MAC-Adresse der 12:A1:00:12:34:02 (Parameter macaddr) für die eindeutige Identifikation im Netzwerk benutzt. Das soeben erzeugte TAP-Interface tap0 wird per Parameter ifname übergeben. Der virtuelle Netzwerkkartentyp wird mit der Option model definiert (hier: virtio).

Den nachfolgenden kvm-Befehl als User auf der Kommandozeile absetzen und warten bis die VM (Gast) hochgefahren ist. Am virtuellen System anmelden und eine Konsole starten. Als root einloggen und das Kommando ifconfig absetzen.

Kommando am Wirtsystem:

$ qemu-system-x86_64 -enable-kvm -name sidubox -net nic,vlan=0,macaddr=12:A1:00:12:34:02,model=virtio -net tap,vlan=0,ifname=tap0 -drive if=virtio,file=./siduction.img,media=disk -usb -usbdevice tablet -m 1024 -vga vmware


Am virtuellen System (Gast) anmelden und über die GUI des Network-Managers dem Netzwerk-Interface eth0 eine feste IP-Adresse zuweisen (192.168.178.101). Wenn eth0 die IP-Adresse 192.168.178.101 besitzt, kann also im Netzwerk 192.168.178.0 eine Verbindungen zu anderen Gästen oder dem Wirtsystem aufgebaut werden.

Ebenso wird mit dem zweiten virtuellen Gast verfahren. Hier benutzt man das nächste frei TAP-Device tap1.

$ sudo /usr/sbin/tunctl -b -u michael -g kvm
tap1

Der zweite virtuelle Gast wird gestartet mit MAC-Adresse 12:A1:00:12:34:03, TAP-Device tap1 und dem vorhandenen Imagenamen siduction-virtpc02.img. Alle anderen Parameter sind identisch zur ersten VM.

$ qemu-system-x86_64 -enable-kvm -name sidubox2 -net nic,vlan=0,macaddr=12:A1:00:12:34:03,model=virtio -net tap,vlan=0,ifname=tap1 -drive if=virtio,file=./siduction2.img,media=disk -usb -usbdevice tablet -m 1024 -vga vmware

Die zweite virtuelle Maschine hat die IP-Adresse 192.168.178.102 und ist von allen beteiligten Stationen im Netzwerk erreichbar. In einer Konsole am Wirtsystem sieht man mit dem Kommando brctl, dass beide TAP-Devices und das Netzwerkdevice eth0 des Wirtes an der Brücke angeschlossen sind.

# brctl show
bridge name     bridge id               STP enabled     interfaces
bri0            8000.000180788235       no              eth0
                                                        tap0
                                                        tap1


Nun können wir beide VM's wieder herunterfahren. Zum Löschen der nicht mehr benötigten TAP-Devies setzen wir folgende Befehle in der Konsole ab.

$ sudo /sbin/ifconfig tap0 down
$ /usr/sbin/tunctl -d tap0
$ sudo /sbin/ifconfig tap1 down
$ /usr/sbin/tunctl -d tap1

Automatisiertes Starten der virtuellen Maschinen

Mit einem Shellscript vm.sh kann man sich das Starten der virtuellen Maschinen erheblich vereinfachen. Bitte das unten aufgelistete Script bei der vorbelegten Variable $IMGPATH und $ISOPATH ggf. an eigene Bedürfnisse anpassen. Der Aufruf erfolgt mit zwei Parametern.


Optionen des Shellscriptes

Syntax:

$ ./vm.sh [-h | -i <Imagedateiname> -l <Label der VM> -p [32|64] -s <Hauptspeicher> -t <yes|no> -r ] | -m <ISO-Dateiname>] | -c]

Beispiel:

$ ./vm.sh -i siduction.img -p 64 -g vmware -l virtpc01 -t yes -r 

Starte virtuelle KVM/Qemu Maschine mit folgenden Parametern:

Plattform   --> 64Bit
Qemu-Binary --> qemu-system-x86_64
VM Name     --> virtpc01
Imagedatei  --> ./siduction.img
DiskFree    -->  44G /mnt/vm/normal
Disktyp     --> virtio
NIC Modell  --> virtio
MAC-Adresse --> 12:A1:00:12:12:07
Brigde Name --> bri0
TAP-Device  --> tap0
VLAN-Nr.    --> 0
USB-Device  --> tablet
Grafik-HW   --> vmware
Sound-HW    --> es1370
Host Time   --> -rtc base=localtime,clock=host
RAM Groesse --> 1024
PID Datei   --> /var/tmp/kvm-siduction.img.pid
Aufruf Kommandozeile:
$ qemu-system-x86_64 -enable-kvm -name sidubox -net nic,vlan=0,macaddr=12:A1:00:12:12:07,model=virtio -net tap,vlan=0,ifname=tap0 -drive if=virtio,file=./siduction-14.1.0-kde-amd64.img,media=disk -usb -usbdevice tablet -soundhw es1370 -m 1024 -pidfile /var/tmp/kvm-siduction-14.1.0-kde-amd64.img.pid -vga vmware -rtc base=localtime,clock=host


Das Script erzeugt als User das TAP-Device und bindet es an die Brigde an. Es wird eine zufällige MAC-Adresse erstellt, die zum Starten der VM benutzt wird. Die Hardware-Plattform (32 oder 64 Bit) gibt der Schalter '-p' an.

Die Option '-i' bezeichnet das Image und die zweite Option '-l' das Label der VM. Mit '-t yes' wird Zeit des Wirt für das Gastsystem übernommen.

Die Option '-r' bezeichnet den Run-Modus, d.h. es startet die VM. Wenn der virtuelle PC heruntergefahren wurde, wird das TAP-Device deaktiviert und gelöscht.


Mit der Option '-c' kann man interaktiv die TAP-Devices löschen.

$ ./vm.sh -c


Zu wartungszwecken kann man die VM auch wieder vom ISO-File starten.

$ ./vm.sh -i siduction.img -m siduction.iso


Eine kurze Hilfe zum Script bekommt man mit der Option '-h'.

$ ./vm.sh -h

Syntax:
./vm.sh [-h | -i <Imagedateiname> -l <Label der VM> -p [32|64] -s <Hauptspeicher> -t <yes|no> -r ] | -m <ISO-Dateiname>] | -c]

Beispiele:

Starten der virtuellen 64Bit-Maschine mit dem Namen 'virtpc01' von der (Boot)Festplatte 'siduction.img' mit Hauptspeicher von 2048MB
./vm.sh -i siduction.img -l virtpc01 -p 64 -s 2048 -t no -r

Starten der virtuellen Maschine von der ISO-Datei 'siduction.iso' mit der Festplatte 'siduction.img' zu Wartungszwecken
./vm.sh -i siduction.img -m siduction.iso

Loeschen und Auflisten der TAP-Devices im interaktiven Modus
./vm.sh -c


Optionen:
-h (Help)        :  diese Hilfe anzeigen
-i (Image)       :  Name der Abbilddatei (Imagefile) der virtuellen Maschine
-l (Label)       :  Name der virtuellen Maschine die im Qemu-Fenster angezeigt wird
-p (Platform)    :  Hardwareplattform 32Bit (i386) oder 64Bit (x64_64)
-x (crypt)       :  das Diskimage ist verschluesselt (LUKS/dm-crypt)
-r (Run)         :  startet die virtuelle Maschine (letzte Option)
-s (RAM-Size)    :  Groesse des Hauptspeichers fuer die virtuelle Maschine (Standard 1024 MB)
-g (GraphicCard) :  genutzter Grafikkartentreiber (Standard vmware)
-t (host time)   :  setzt die Zeit des Hostes auch fuer den Gast (Argument yes oder no)
-m (Maintenance) :  startet die virtuelle Maschine mit Hilfe des Boot-ISO
-c (Clean)       :  entfernt alle TAP-Devices (interaktiv)


Listing des Shellscriptes

Hier das Listing des Scriptes vm.sh. Bitte an einen geeignten Ort abspeichern und ausführbar machen für den Benutzer der dieses Script nutzt. Das Script kann weiter unten herunter geladen werden.


  1 #!/bin/bash
  2 #
  3 #####################
  4 # Variablenbelegung #
  5 #####################
  6 
  7 ERRORMESSAGE="$0: -$OPTION ist nicht erlaubt und wird ignoriert"
  8 ISOPATH="/mnt/misc/ISOimage"
  9 IMGPATH="."
 10 IMGFILE=""
 11 VMNAME=""
 12 USERID=`whoami`
 13 BRIGDE=`sudo /sbin/brctl show | egrep ^bri[0-9]|awk '{print $1}'`
 14 START_PARAMETER=$#
 15 VLAN="0"
 16 MACADRESSE="12:A1:00:12:"
 17 MODEL="virtio"
 18 DRIVETYPE="virtio"
 19 #BOOT="on"
 20 MEDIA="disk"
 21 USBDEVICE="tablet"
 22 SOUNDHW="es1370"
 23 VGAHW="vmware"
 24 RAMSIZE="1024"
 25 PIDPATH="/var/tmp"
 26 PIDFILE=""
 27 PLATFORM=""
 28 DISKFREE=`df -h --output=avail,target $IMGPATH | tail -1`
 29 
 30 ##############
 31 # Funktionen #
 32 ##############
 33 
 34 do_option_check()
 35 {
 36 	if [ $START_PARAMETER -eq 0 ]
 37 		then
 38 		echo "Achtung, falscher Aufruf des Sriptes $0"
 39 		usage
 40 		exit 1
 41 	fi
 42 }
 43 
 44 do_init_tapdev()
 45 {
 46 	INTERFACE=`sudo /usr/sbin/tunctl -b -u $USERID -g kvm`
 47 }
 48 
 49 do_create_macadr()
 50 {
 51 for Z in `seq 1 2`
 52 	do
 53 	RND=`echo $((RANDOM % 15))`
 54 	MAC=`echo $RND | awk -v RND="$RND" '{printf("%02d\n",$1)}'`
 55 	if [ $Z -le 1 ]
 56 		then
 57 		TMP=`echo -n $MAC`
 58 		MACADRESSE=`echo $MACADRESSE$TMP":"`
 59 	elif [ $Z -eq 2 ]
 60 		then
 61 		TMP=`echo -n $MAC`
 62 		MACADRESSE=`echo $MACADRESSE$TMP`
 63 		echo ""
 64 	fi
 65 done
 66 }
 67 
 68 do_set_pid()
 69 {
 70 	if [ "$1" = "start" ]
 71 		then
 72 		PIDFILE="$PIDPATH/kvm-$IMGFILE.pid"
 73 	elif [ "$1" = "stop" ]
 74 		then
 75 		if [ -e "$PIDFILE" ]
 76 			then
 77 			rm $PIDFILE
 78 			echo "PID Datei geloescht"
 79 		fi
 80 	fi
 81 }
 82 
 83 do_param_output()
 84 {
 85 	echo "Starte virtuelle KVM/Qemu Maschine mit folgenden Parametern:"
 86 	echo " Plattform   --> "$PLATFORM"Bit"
 87 	echo " Qemu-Binary --> "$QEMU_BINARY
 88 	echo " VM Name     --> "$VMNAME
 89 	echo " Imagedatei  --> "$IMGPATH/$IMGFILE
 90 	echo " DiskFree    --> "$DISKFREE
 91 	echo " Disktyp     --> "$DRIVETYPE 
 92 	echo " NIC Modell  --> "$MODEL
 93 	echo " MAC-Adresse --> "$MACADRESSE
 94 	echo " Brigde Name --> "$BRIGDE
 95 	echo " TAP-Device  --> "$INTERFACE
 96 	echo " VLAN-Nr.    --> "$VLAN
 97 	echo " USB-Device  --> "$USBDEVICE
 98 	echo " Grafik-HW   --> "$VGAHW
 99 	echo " Sound-HW    --> "$SOUNDHW
100 	echo " Host Time   --> "$HOST_TIME
101 	echo " RAM Groesse --> "$RAMSIZE
102 	echo " PID Datei   --> "$PIDFILE
103 	echo ""
104 	echo "Aufruf Kommandozeile:"
105 	echo "$ $QEMU_BINARY -enable-kvm -name $VMNAME -net nic,vlan=$VLAN,macaddr=$MACADRESSE,model=$MODEL -net tap,vlan=$VLAN,ifname=$INTERFACE -drive if=$MODEL,file=$IMGPATH/$IMGFILE,media=$MEDIA -usb -usbdevice $USBDEVICE -soundhw $SOUNDHW -m $RAMSIZE -pidfile $PIDFILE -vga $VGAHW $HOST_TIME"
106 	echo ""
107 }
108 
109 do_set_platform()
110 {
111 	if [ "$PLATFORM" = "32" ]
112 		then
113 		QEMU_BINARY="qemu-system-i386"
114 	elif [ "$PLATFORM" = "64" ]
115 		then
116 		QEMU_BINARY="qemu-system-x86_64"
117 	else
118 		echo "Ungueltige Harwareplattform >$PLATFORM< angegeben, nur der Wert 32 oder 64 ist erlaubt."
119 		exit 5
120 	fi
121 }
122 
123 do_start_vm()
124 {
125 	if [ "$OPTION" = "r" ]
126 		then
127 		$QEMU_BINARY -enable-kvm -name $VMNAME -net nic,vlan=$VLAN,macaddr=$MACADRESSE,model=$MODEL -net tap,vlan=$VLAN,ifname=$INTERFACE -drive if=$DRIVETYPE,file=$IMGPATH/$IMGFILE,media=$MEDIA -usb -usbdevice $USBDEVICE -soundhw $SOUNDHW -m $RAMSIZE -pidfile $PIDFILE -vga $VGAHW $HOST_TIME
128 	elif [ "$OPTION" = "m" ]
129 		then
130 		$QEMU_BINARY -enable-kvm -name Maintenance -hda $IMGPATH/$IMGFILE -cdrom $PATHFILE -boot d -m $RAMSIZE -daemonize -vga $VGAHW
131 	fi
132 }
133 
134 do_exists_file()
135 {
136 	RC=""
137 	FILE=$1
138 	if [ "$OPTION" = "i" ]
139 		then
140 		PATHFILE=`find $IMGPATH/ -name $FILE`
141 	elif [ "$OPTION" = "m" ]
142 		then
143 		PATHFILE=`find $ISOPATH -name $FILE`
144 	fi
145 	if [ "$PATHFILE" ]
146 		then
147 		RC=0
148 	else
149 		RC=1
150 		echo "Script wird abgebrochen, $FILE nicht vorhanden"
151 		exit 10	
152 	fi
153 }
154 
155 do_stop_vm()
156 {
157 	sudo /sbin/ifconfig $INTERFACE down
158 	sudo /usr/sbin/tunctl -d $INTERFACE
159 }
160 
161 do_list_tap()
162 {
163 	TAPDEVPATH="/sys/devices/virtual/net"
164 	TAPFILE_COUNTER=`find $TAPDEVPATH/ -name "tap*" | wc -l`
165 
166 	if [ $TAPFILE_COUNTER -gt 0 ]
167 		then
168 		for I in `ls -1d $TAPDEVPATH/tap*`
169 			do
170 			basename $I
171 		done
172 	elif [ $TAPFILE_COUNTER -eq 0 ]
173 		then
174 		echo ""
175 		echo "Keine TAP-Devices vorhanden"
176 		echo ""
177 	fi
178 }
179 
180 do_delete_tap()
181 {
182 	echo ""
183 	echo "TAP-Devices:"
184 	echo ""
185 	PS3="Bitte gewuenschte Aktion waehlen [1=Loeschen|2=NichtLoeschen|3=Auflisten|4=Abbrechen] "
186 	select SELECTION in Loeschen NichtLoeschen Auflisten Abbrechen 
187 		do
188 		case $SELECTION in
189 			Loeschen)
190 			do_list_tap
191 			if [ $TAPFILE_COUNTER -gt 0 ]
192 				then
193 				for I in `ls -1d $TAPDEVPATH/tap*`
194 					do
195 					sudo /usr/sbin/tunctl -d `basename $I`
196 				done
197 				echo ""
198 				echo "Alle TAP-Devices geloescht"
199 				echo ""
200 			elif [ $TAPFILE_COUNTER -eq 0 ]
201 				then
202 				echo "Fertig"
203 			fi
204 			;;
205 			NichtLoeschen)
206 			echo ""
207 			echo "TAP-Devices werden nicht gelöscht"
208 			echo ""
209 			break
210 			;;
211 			Auflisten)
212 			do_list_tap
213 			echo ""
214 			;;
215 			Abbrechen)
216 			echo "Programmabbruch"
217 			break 2
218 			;;
219 			*)
220 			echo "Eingabe ungueltig!"
221 			;;
222 		esac
223 	done
224 }
225 
226 usage()
227 {
228 	echo ""
229 	echo "Syntax:"
230 	echo " $0 [-h | -i <Imagedateiname> -l <Label der VM> -p [32|64] -s <Hauptspeicher> -t <yes|no> -r ] | -m <ISO-Dateiname>] | -c]"
231 	echo ""
232 	echo "Beispiele:"
233 	echo ""
234 	echo "Starten der virtuellen 64Bit-Maschine mit dem Namen 'virtpc01' von der (Boot)Festplatte 'siduction.img' mit Hauptspeicher von 2048MB"
235 	echo " $0 -i siduction.img -l virtpc01 -p 64 -s 2048 -t no -r"
236 	echo ""
237 	echo "Starten der virtuellen Maschine von der ISO-Datei 'siduction.iso' mit der Festplatte 'siduction.img' zu Wartungszwecken"
238 	echo " $0 -i siduction.img -m siduction.iso"
239 	echo ""
240 	echo "Loeschen und Auflisten der TAP-Devices im interaktiven Modus"
241 	echo " $0 -c"
242 	echo ""
243 	echo ""
244 	echo "Optionen:"
245 	echo " -h (Help)        :  diese Hilfe anzeigen"
246 	echo " -i (Image)       :  Name der Abbilddatei (Imagefile) der virtuellen Maschine"
247 	echo " -l (Label)       :  Name der virtuellen Maschine die im Qemu-Fenster angezeigt wird"
248 	echo " -p (Platform)    :  Hardwareplattform 32Bit (i386) oder 64Bit (x64_64)"
249 	echo " -x (crypt)       :  das Diskimage ist verschluesselt (LUKS/dm-crypt)"
250 	echo " -r (Run)         :  startet die virtuelle Maschine (letzte Option)"
251 	echo " -s (RAM-Size)    :  Groesse des Hauptspeichers fuer die virtuelle Maschine (Standard 1024 MB)"
252 	echo " -g (GraphicCard) :  genutzter Grafikkartentreiber (Standard vmware)"
253 	echo " -t (host time)   :  setzt die Zeit des Hostes auch fuer den Gast (Argument yes oder no)"
254 	echo " -m (Maintenance) :  startet die virtuelle Maschine mit Hilfe des Boot-ISO"
255 	echo " -c (Clean)       :  entfernt alle TAP-Devices (interaktiv)"
256 	echo ""
257 }
258 
259 
260 #################
261 # Hauptprogramm #
262 #################
263 do_option_check
264 
265 while getopts hi:l:p:rm:cs:g:t:x OPTION; do
266 	case $OPTION in
267 		h)
268 		usage
269 		;;
270 		i)
271 		IMGFILE=$OPTARG
272 		do_exists_file $IMGFILE $OPTION
273 		;;
274 		l)
275 		VMNAME=$OPTARG
276 		;;
277 		p)
278 		PLATFORM=$OPTARG
279 		do_set_platform
280 		;;
281 		s)
282 		RAMSIZE=$OPTARG
283 		;;
284 		g)
285 		VGAHW=$OPTARG
286 		;;
287 		t)
288 		RTC=$OPTARG
289 		if [ "$RTC" = "yes" ]
290 			then
291 			HOST_TIME="-rtc base=localtime,clock=host"
292 		elif [ "$RTC" = "no" ]
293 			then
294 			HOST_TIME=""
295 		else
296 			echo "Falsches Argument ($RTC) bei der Option -$OPTION gesetzt (erlaubt: yes/no)"
297 			exit 5
298 		fi
299 		;;
300 		r)
301 		if [ "$IMGFILE" = "" ]
302 			then
303 			echo "Option -i muss gesetzt sein"
304 			exit 2
305 		elif [ "$VMNAME" = "" ]
306 			then
307 			echo "Option -l muss gesetzt sein"
308 			exit 3
309 		elif [ "$PLATFORM" = "" ]
310 			then
311 			echo "Option -p muss gesetzt sein"
312 			exit 4
313 		elif [ "$RTC" = "" ]
314 			then
315 			echo "Option -t <yes|no> muss vor der Option -$OPTION gesetzt sein"
316 			exit 6
317 		else
318 			do_init_tapdev
319 			do_set_pid start
320 			do_create_macadr
321 			do_param_output
322 			do_start_vm $OPTION
323 			do_stop_vm
324 			do_set_pid stop
325 		fi
326 		;;
327 		m)
328 		do_exists_file $OPTARG $OPTION
329 		do_start_vm $OPTION
330 		;;
331 		c)
332 		do_delete_tap
333 		;;
334 		x)
335 		DRIVETYPE="ide"
336 		;;
337 		\?)
338 		echo $ERRORMESSAGE
339 		;;
340 		
341 	esac
342 done
343 shift `expr $OPTIND - 1`
344 exit 0
345 #EOF

Download des Scriptes

  • Textdatei umbenennen
$ mv Vm.bash vm.sh
  • Script ausführbar machen
$ chmod 700 vm.sh
  • Variablen im Shellscript vm.sh an eigene Umgebung anpassen
ISOPATH="/mnt/misc/ISOimage"
IMGPATH="/home/michael/kvm"



Fehlerbehebung

Unter Umständen könnten Nebeneffekte auftreten, z.B. bei dem Systemmonitor conky, wenn dort das Netzwerkinterface eth0 überwacht wird. Es muß dann auf das Device bri0 umkonfiguriert werden. Bei der Netzwerkkonfiguration mit den virtuellen Gästen ist die virtuelle Brücke bri0 das "übergeordnete" Netzwerkinterface.

Vorsicht ist bei der Wahl der MAC-Adressen, wenn die Vorgabe der Variable $MACADRESSE geändert wird. Es gibt durchaus ungültige MAC-Adressen. Das Gastsystem startet Qemu/KVM zwar, aber es wird kein Netzwerkinterface eth0 hochgefahren. In diesem Fall ist am Gastsystem nur das Loopbackdevice lo aktiv.

Eine weitere Fehler kann eine differierende Systemuhr sein die evtl. um 2 Stunden hinterher ist. Dies mit folgenden zwei Kommandos zu lösen.

# apt-get install ntpdate
# ntpdate ptbtime1.ptb.de



Testen der Netzwerkverbindungen

  • Erste VM hochfahren
  • Zweite VM hochfahren
  • SSH-Verbindung von erster VM auf Hostsystem testen
virtpc01-$ ssh 192.168.178.100
  • SSH-Verbindung von zweiter VM auf Hostsystem testen
virtpc02-$ ssh 192.168.178.100
  • SSH-Verbindung von erster auf zweiter VM testen
virtpc01-$ ssh 192.168.178.102
  • SSH-Verbindung von zweiter auf erste VM testen
virtpc02-$ ssh 192.168.178.101
  • SSH-Verbindung vom Wirt auf die beiden VM's testen
hostpc-$ ssh 192.168.178.101
hostpc-$ ssh 192.168.178.102

Wenn diese Test alle erfolgreich abgeschlossen werden konnten, hat man sein virtuelles Netzwerk komplett eingerichtet.

Weiterführende Informationen

Das Online Buch zu qemu-kvm & libvirt

Qemu-Buch: Virtuelle Netzwerke konfigurieren

Qemu-Buch: Startoptionen von QEMU und KVM