Verschachtelte VMs erstellen

Linux

Verschachtelte Virtualisierung ist standardmäßig zulässig. Wenn Sie also die Einschränkung für verschachtelte Virtualisierung nicht ändern, müssen Sie keine Änderungen vornehmen, bevor Sie verschachtelte VMs in einer Organisation, einem Ordner oder einem Projekt erstellen. Wenn Ihr Projekt nicht zu einer Organisation gehört, ist die verschachtelte Virtualisierung standardmäßig erlaubt und Sie können die Einschränkung nicht ändern. Informationen zum Ändern der Einschränkung, die bestimmt, ob Sie verschachtelte VMs erstellen können, finden Sie unter Einschränkung der verschachtelten Virtualisierung verwalten.

In diesem Dokument wird beschrieben, wie Sie verschiedene Arten von VM-Instanzen der Ebene 2 (L2) erstellen. Bevor Sie eine verschachtelte VM erstellen, müssen Sie eine L1-VM erstellen, für die die verschachtelte Virtualisierung aktiviert ist. Eine Beschreibung der L1- und L2-VMs finden Sie in der Übersicht zur verschachtelten Virtualisierung.

Nach dem Erstellen einer L1-VM, für die die verschachtelte Virtualisierung aktiviert ist, haben Sie folgende Möglichkeiten:

L2-VM mit externem Netzwerkzugriff erstellen
L2-VM mit einer privaten Netzwerk-Bridge zur L1-VM erstellen
L2-VM mit Netzwerkzugriff von außerhalb der L1-VM erstellen

Hinweise

Richten Sie die Authentifizierung ein, falls Sie dies noch nicht getan haben. Bei der Authentifizierung wird Ihre Identität für den Zugriff auf Google Cloud-Dienste und APIs überprüft. Zur Ausführung von Code oder Beispielen aus einer lokalen Entwicklungsumgebung können Sie sich bei Compute Engine authentifizieren.

Wählen Sie den Tab für die Verwendung der Beispiele auf dieser Seite aus:
gcloud
1. Installieren Sie die Google Cloud CLI und initialisieren Sie sie mit folgendem Befehl:
```
gcloud init
```
  Hinweis: Wenn Sie die gcloud CLI zuvor installiert haben, prüfen Sie, ob Sie die neueste Version haben, indem Sie gcloud components update ausführen.
2. Legen Sie eine Standardregion und -zone fest.
REST

Verwenden Sie die von der gcloud CLI bereitgestellten Anmeldedaten, um die REST API-Beispiele auf dieser Seite in einer lokalen Entwicklungsumgebung zu verwenden.

L2-VM mit externem Netzwerkzugriff erstellen

Mit dem folgenden Verfahren erstellen Sie eine L2-VM mit externem Netzwerkzugriff. Bei diesem Verfahren wird qemu-system-x86_64 verwendet, um die L2-VM zu starten. Wenn Sie ein anderes Verfahren zum Erstellen einer L2-VM verwenden und Probleme auftreten, reproduzieren Sie das Problem mit diesem Verfahren, bevor Sie sich an den Support wenden.

L1-VM erstellen, auf der die verschachtelte Virtualisierung aktiviert ist
Stellen Sie mit dem Befehl gcloud compute ssh eine Verbindung zur VM her:
```
gcloud compute ssh VM_NAME
```
Ersetzen Sie dabei VM_NAME durch den Namen der VM, zu der eine Verbindung hergestellt werden soll.

Installieren Sie das neueste qemu-kvm-Paket:

sudo apt update && sudo apt install qemu-kvm -y

Laden Sie ein QEMU-kompatibles Betriebssystem-Image für die L2-VM herunter.
Starten Sie die L2-VM mit dem folgenden Befehl. Melden Sie sich bei entsprechender Aufforderung mit user: root, password: root an.
```
sudo qemu-system-x86_64 -enable-kvm -hda IMAGE_NAME -m 512 -curses
```
Ersetzen Sie IMAGE_NAME durch den Namen des QEMU-kompatiblen Betriebssystem-Images, das für die L2-VM verwendet werden soll.
Testen Sie, ob Ihre L2-VM externen Zugriff hat:
```
user@nested-vm:~$ host google.com
```

L2-VM mit einer privaten Netzwerk-Bridge zur L1-VM erstellen

Mit dem folgenden Verfahren erstellen Sie eine L2-VM mit einer privaten Netzwerk-Bridge zur zuvor erstellten L1-VM. Informationen zum Ändern der standardmäßigen maximalen Übertragungseinheit (MTU) für Ihr VPC-Netzwerk finden Sie unter Maximale Übertragungseinheit – Übersicht.

L1-VM erstellen, auf der die verschachtelte Virtualisierung aktiviert ist
Stellen Sie mit dem Befehl gcloud compute ssh eine Verbindung zur VM her:
```
gcloud compute ssh VM_NAME
```
Ersetzen Sie dabei VM_NAME durch den Namen der VM, zu der eine Verbindung hergestellt werden soll.

Installieren Sie die Pakete, die zum Erstellen der privaten Bridge erforderlich sind:

sudo apt update && sudo apt install uml-utilities qemu-kvm bridge-utils virtinst libvirt-daemon-system libvirt-clients -y

Starten Sie das Standardnetzwerk, das im Paket libvirt enthalten ist:
```
sudo virsh net-start default
```
Führen Sie den folgenden Befehl aus, um zu prüfen, ob Sie die virbr0-Bridge haben:
```
ip addr
```

Die Ausgabe sieht etwa so aus:

1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
    inet6 ::1/128 scope host
       valid_lft forever preferred_lft forever
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1460 qdisc pfifo_fast state UP group default qlen 1000
    link/ether 42:01:0a:80:00:15 brd ff:ff:ff:ff:ff:ff
    inet 10.128.0.21/32 brd 10.128.0.21 scope global eth0
       valid_lft forever preferred_lft forever
    inet6 fe80::4001:aff:fe80:15/64 scope link
       valid_lft forever preferred_lft forever
3: virbr0: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc noqueue state DOWN group default qlen 1000
    link/ether 52:54:00:8c:a6:a1 brd ff:ff:ff:ff:ff:ff
    inet 192.168.122.1/24 brd 192.168.122.255 scope global virbr0
       valid_lft forever preferred_lft forever
4: virbr0-nic: <BROADCAST,MULTICAST> mtu 1500 qdisc pfifo_fast master virbr0 state DOWN group default qlen 1000
    link/ether 52:54:00:8c:a6:a1 brd ff:ff:ff:ff:ff:ff

Erstellen Sie eine tap-Schnittstelle, um von der L1-VM zur L2-VM zu wechseln:
```
sudo tunctl -t tap0
sudo ifconfig tap0 up
```
Verbinden Sie die Schnittstelle tap mit der privaten Bridge:
```
sudo brctl addif virbr0 tap0
```
Führen Sie den folgenden Befehl aus, um die Einrichtung des Bridge-Netzwerks zu prüfen:
```
sudo brctl show
```

Die Ausgabe sieht etwa so aus:

bridge name     bridge id               STP enabled     interfaces
virbr0          8000.5254008ca6a1       yes             tap0
                                                        virbr0-nic

Laden Sie ein QEMU-kompatibles Betriebssystem-Image für die L2-VM herunter.
Führen Sie screen aus und drücken Sie die Eingabetaste bei der Begrüßungsaufforderung:
```
screen
```
Starten Sie die L2-VM mit dem folgenden Befehl. Melden Sie sich bei Aufforderung mit user: root, password: root an.
```
sudo qemu-system-x86_64 -enable-kvm -hda IMAGE_NAME -m 512 -net nic -net tap,ifname=tap0,script=no -curses
```
Ersetzen Sie IMAGE_NAME durch den Namen des QEMU-kompatiblen Betriebssystem-Images, das für die L2-VM verwendet werden soll.
Führen Sie auf der L2-VM ip addr show aus, um zu bestätigen, dass die VM im Bereich virbr0 eine Adresse hat, z. B. 192.168.122.89:
```
user@nested-vm:~$ ip addr
```
Starten Sie einen Platzhalter-Webserver an Port 8000:
```
user@nested-vm:~$ python -m http.server
```
Trennen Sie die Sitzung von screen mit Ctrl+A, Ctrl+D.
Testen Sie, ob Ihre L1-VM die L2-VM anpingen kann. Ersetzen Sie dabei die folgende IP-Adresse durch die IP-Adresse der L2-VM:
```
curl 192.168.122.89:8000
```

Die Ausgabe sieht etwa so aus:

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2 Final//EN"><html>
<title>Directory listing for /</title>
<body>
<h2>Directory listing for /</h2>
<hr>
<ol>
<li><a href=".aptitude/">.aptitude/</a>
<li><a href=".bashrc">.bashrc</a>
<li><a href=".profile">.profile</a>
</ol>
<hr>
</body>
</html>

L2-VM mit Netzwerkzugriff von außerhalb der L1-VM erstellen

Erforderliche Berechtigungen für diese Aufgabe

Zum Ausführen dieser Aufgabe benötigen Sie die folgenden Berechtigungen:

compute.instances.create-Berechtigungen für das Projekt, den Ordner oder die Organisation

Sie können eine L2-VM mit einer Alias-IP-Adresse einrichten, sodass VMs außerhalb der L1-VM auf die L2-VM zugreifen können. Gehen Sie folgendermaßen vor, um eine L2-VM mit Netzwerkzugriff über eine Alias-IP-Adresse von außerhalb der zuvor erstellten L1-VM zu erstellen. Informationen zum Erstellen von Alias-IP-Adressen finden Sie unter Alias-IP-Bereiche konfigurieren.

Bei der folgenden Vorgehensweise wird von einem zuvor erstellten Subnetz namens subnet1 ausgegangen. Wenn Sie bereits ein Subnetz mit einem anderen Namen haben, ersetzen Sie subnet1 durch den Namen Ihres Subnetzes oder erstellen Sie ein neues Subnetz mit dem Namen subnet1.

Erstellen Sie eine L1-VM mit aktivierter verschachtelter Virtualisierung. Fügen Sie einen Alias-IP-Bereich und Unterstützung für HTTP-/HTTPS-Traffic hinzu:

gcloud

gcloud compute instances create VM_NAME --enable-nested-virtualization \
    --tags http-server,https-server --can-ip-forward \
    --min-cpu-platform "Intel Haswell" \
    --network-interface subnet=subnet1,aliases=/30

Ersetzen Sie VM_NAME durch den Namen der L1-VM.

REST

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances

{
  ...
  "name": VM_NAME,
  "tags": {
    "items": [
      http-server,https-server
    ],
  },
  "canIpForward": true,
  "networkInterfaces": [
    {
      "subnetwork": "subnet1",
      "aliasIpRanges": [
        {
          "ipCidrRange": "/30"
        }
      ],
    }
  ],
  "minCpuPlatform": "Intel Haswell",
  "advancedMachineFeatures": {
    "enableNestedVirtualization": true
  },
  ...
}

Ersetzen Sie Folgendes:

PROJECT_ID: die Projekt-ID
ZONE ist die Zone, in der die VM erstellt werden soll.
VM_NAME: Der Name der VM

Verwenden Sie den Befehl gcloud compute ssh, um eine Verbindung zur VM herzustellen. Wenn Sie Probleme beim Herstellen einer Verbindung zur VM haben, versuchen Sie, die VM zurückzusetzen oder die Firewallregeln zu ändern.
```
gcloud compute ssh VM_NAME
```
Ersetzen Sie dabei VM_NAME durch den Namen der VM, zu der eine Verbindung hergestellt werden soll.

Aktualisieren Sie die VM und installieren Sie die erforderlichen Pakete:

sudo apt update && sudo apt install uml-utilities qemu-kvm bridge-utils virtinst libvirt-daemon-system libvirt-clients -y

Starten Sie das Standardnetzwerk, das im Paket libvirt enthalten ist:
```
sudo virsh net-start default
```
Führen Sie den folgenden Befehl aus, um zu prüfen, ob Sie die virbr0-Bridge haben:
```
user@nested-vm:~$ ip addr
```

Die Ausgabe sollte in etwa so aussehen:

1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
    inet6 ::1/128 scope host
       valid_lft forever preferred_lft forever
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1460 qdisc pfifo_fast state UP group default qlen 1000
    link/ether 42:01:0a:80:00:15 brd ff:ff:ff:ff:ff:ff
    inet 10.128.0.21/32 brd 10.128.0.21 scope global eth0
       valid_lft forever preferred_lft forever
    inet6 fe80::4001:aff:fe80:15/64 scope link
       valid_lft forever preferred_lft forever
3: virbr0: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc noqueue state DOWN group default qlen 1000
    link/ether 52:54:00:8c:a6:a1 brd ff:ff:ff:ff:ff:ff
    inet 192.168.122.1/24 brd 192.168.122.255 scope global virbr0
       valid_lft forever preferred_lft forever
4: virbr0-nic: <BROADCAST,MULTICAST> mtu 1500 qdisc pfifo_fast master virbr0 state DOWN group default qlen 1000
    link/ether 52:54:00:8c:a6:a1 brd ff:ff:ff:ff:ff:ff

Erstellen Sie eine tap-Schnittstelle, um von der L1-VM zur L2-VM zu wechseln:
```
sudo tunctl -t tap0
sudo ifconfig tap0 up
```
Verbinden Sie die Schnittstelle tap mit der privaten Bridge:
```
sudo brctl addif virbr0 tap0
```
Führen Sie den folgenden Befehl aus, um die Einrichtung des Bridge-Netzwerks zu prüfen:
```
sudo brctl show
```

Die Ausgabe sollte in etwa so aussehen:

bridge name     bridge id               STP enabled     interfaces
virbr0          8000.5254008ca6a1       yes             tap0
                                                        virbr0-nic

Laden Sie ein QEMU-kompatibles Betriebssystem-Image für die L2-VM herunter.
Führen Sie screen aus und drücken Sie die Eingabetaste bei der Begrüßungsaufforderung:
```
screen
```
Verwenden Sie den folgenden Befehl, um die verschachtelte VM zu starten. Melden Sie sich bei Aufforderung mit user: root, password: root an.
```
sudo qemu-system-x86_64 -enable-kvm -hda IMAGE_NAME -m 512 -net nic -net tap,ifname=tap0,script=no -curses
```
Ersetzen Sie IMAGE_NAME durch den Namen des QEMU-kompatiblen Betriebssystem-Images, das für die L2-VM verwendet werden soll.
Führen Sie auf der L2-VM ip addr aus, um zu bestätigen, dass die L2-VM eine Adresse im virbr0-Bereich hat, z. B. 192.168.122.89:
```
user@nested-vm:~$ ip addr
```
Starten Sie einen Platzhalter-Webserver an Port 8000:
```
user@nested-vm:~$ python -m http.server
```
Trennen Sie die Sitzung von screen mit Ctrl+A, Ctrl+D.
Testen Sie, ob Ihre L1-VM die L2-VM anpingen kann. Ersetzen Sie dabei die IP-Adresse unten durch die IP-Adresse der L2-VM:
```
curl 192.168.122.89:8000
```

Überprüfen Sie, ob die Antwort der L2-VM etwa so aussieht:

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2 Final//EN"><html>
<title>Directory listing for /</title>
<body>
<h2>Directory listing for /</h2>
<hr>
<ol>
<li><a href=".aptitude/">.aptitude/</a>
<li><a href=".bashrc">.bashrc</a>
<li><a href=".profile">.profile</a>
</ol>
<hr>
</body>
</html>

Richten Sie auf der L1-VM iptables ein, um das Weiterleiten von der L1-VM an die L2-VM zuzulassen. Für das in dieser Anleitung verwendete L2-Betriebssystem-Image müssen Sie die IP-Tabellen leeren:
```
sudo iptables -F
```
Bestimmen Sie die Alias-IP-Adresse der L1-VM:
```
ip route show table local
```

Überprüfen Sie, ob die Ausgabe in etwa so aussieht. In diesem Beispiel sind dem Ethernet-Gerät eth0 der L2-VM zwei IP-Adressen zugeordnet. Die erste, 10.128.0.2, ist die primäre IP-Adresse der L2-VM, die von sudo ifconfig -a zurückgegeben wird. Die zweite, 10.128.0.13, ist die Alias-IP-Adresse der L2-VM.

local 10.128.0.2 dev eth0 proto kernel scope host src 10.128.0.2
broadcast 10.128.0.2 dev eth0 proto kernel scope link src 10.128.0.2
local 10.128.0.13/30 dev eth0 proto 66 scope host
broadcast 127.0.0.0 dev lo proto kernel scope link src 127.0.0.1
local 127.0.0.0/8 dev lo proto kernel scope host src 127.0.0.1
local 127.0.0.1 dev lo proto kernel scope host src 127.0.0.1
broadcast 127.255.255.255 dev lo proto kernel scope link src 127.0.0.1
broadcast 192.168.122.0 dev virbr0 proto kernel scope link src
192.168.122.1 linkdown
local 192.168.122.1 dev virbr0 proto kernel scope host src 192.168.122.1
broadcast 192.168.122.255 dev virbr0 proto kernel scope link src
192.168.122.1 linkdown

Führen Sie die folgenden Befehle aus, um Traffic von der Beispiel-IP-Adresse 10.128.0.13 an die Beispiel-IP-Adresse 192.168.122.89 für die L2-VM weiterzuleiten.

echo 1 | sudo tee /proc/sys/net/ipv4/ip_forward
sudo iptables -t nat -A PREROUTING -d 10.128.0.13 -j DNAT --to-destination 192.168.122.89
sudo iptables -t nat -A POSTROUTING -s 192.168.122.89 -j MASQUERADE
sudo iptables -A INPUT -p udp -j ACCEPT
sudo iptables -A FORWARD -p tcp -j ACCEPT
sudo iptables -A OUTPUT -p tcp -j ACCEPT
sudo iptables -A OUTPUT -p udp -j ACCEPT

Informationen zur Fehlerbehebung für iptables finden Sie unter iptables leiten keinen Traffic weiter:

Prüfen Sie den Zugriff auf L2-VMs von außerhalb der L1-VM. Melden Sie sich dazu bei einer anderen VM an, die sich im selben Netzwerk wie die L1-VM befindet, und stellen Sie eine curl-Anfrage an die Alias-IP-Adresse. Ersetzen Sie dabei die IP-Adresse unten durch die Alias-IP-Adresse der L2-VM:
```
user@another-vm:~$ curl 10.128.0.13:8000
```

Überprüfen Sie, ob die curl-Antwort in etwa so aussieht:

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2 Final//EN"><html>
<title>Directory listing for /</title>
<body>
<h2>Directory listing for /</h2>
<hr>
<ol>
<li><a href=".aptitude/">.aptitude/</a>
<li><a href=".bashrc">.bashrc</a>
<li><a href=".profile">.profile</a>
</ol>
<hr>
</body>
</html>

Nächste Schritte

Fehlerbehebung bei verschachtelter Virtualisierung