Version 1.14. This version is no longer supported. For information about how to upgrade to version 1.15, see Upgrading Anthos on bare metal in the 1.15 documentation. For more information about supported and unsupported versions, see the Version history page in the latest documentation.

Verbindung zu VMs herstellen, die die VM-Laufzeit in Google Distributed Cloud nutzen

Dieses Dokument richtet sich an Inhaber von Anwendungen, die GKE on Bare Metal ausführen. In diesem Dokument erfahren Sie, wie Sie eine Verbindung zu virtuellen Maschinen (VMs) herstellen, die die VM-Laufzeit in Google Distributed Cloud verwenden. Sie können Verbindungen zu VMs direkt über eine IP-Adresse herstellen oder integrierte Tools für den SSH- oder Console-Zugriff verwenden.

Hinweise

Um dieses Dokument abzuschließen, benötigen Sie Zugriff auf die folgenden Ressourcen:

Eine VM, die in einem Ihrer Cluster ausgeführt wird. Erstellen Sie bei Bedarf eine VM in GKE on Bare Metal.
Das virtctl-Clienttool, das als Plug-in für kubectl installiert wurde. Installieren Sie bei Bedarf das virtctl-Clienttool.

Passwortlosen SSH-Zugriff auf VMs konfigurieren

Der direkte, passwortlose SSH-Zugriff auf Ihre VM wird durch einen Gast-Agent ermöglicht, der über die VM-Laufzeit in Google Distributed Cloud installiert wird. Der Gast-Agent installiert und läuft unter anderem SSH-Schlüssel ab. Diese Funktion aktiviert einen SSH-Tunnel für den Zugriff auf Ihre VM von Clients außerhalb des Clusternetzwerks.

Gast-Agent aktivieren

So aktivieren Sie den Gast-Agent:

Prüfen Sie, ob die benutzerdefinierte Ressource VirtualMachine für die Aktivierung des Gast-Agents konfiguriert ist:
```
kubectl get gvm VM_NAME -o yaml --kubeconfig KUBECONFIG
```
Das Feld spec.osType sollte auf das Betriebssystem Ihrer VM, Linux oder Windows, festgelegt werden. Der Abschnitt spec.guestEnvironment darf nicht explizit als leer konfiguriert werden. Ist der Abschnitt leer (guestEnvironment: {}), können Sie ihn vollständig entfernen, um den Gast-Agent zu aktivieren.

Ihre benutzerdefinierte VirtualMachine-Ressource für die VM, auf die Sie zugreifen möchten, sollte so aussehen:
```
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: sample-vm
spec:
  compute:
    cpu:
      vcpus: 2
    memory:
      capacity: 4Gi
...
  osType: Linux
...
```
Verwenden Sie bei Bedarf kubectl edit, um die benutzerdefinierte Ressource VirtualMachine zu aktualisieren.

Prüfen Sie den status in Ihrer benutzerdefinierten VM-Ressource, um zu prüfen, ob der Gast-Agent funktioniert:

kubectl get gvm VM_NAME --kubeconfig KUBECONFIG

Wenn der Gast-Agent funktioniert, wird für die Bedingungen GuestEnvironmentEnabled und GuestEnvironmentDataSynced status: "True" angezeigt.

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  ...
  name: vm-sample-01
  ...
status:
  conditions:
  - lastTransitionTime: "2022-10-05T22:40:26Z"
    message: ""
    observedGeneration: 1
    reason: UserConfiguration
    status: "True"
    type: GuestEnvironmentEnabled
  - lastTransitionTime: "2022-10-06T21:55:57Z"
    message: ""
    observedGeneration: 1
    reason: GuestEnvironmentDataSynced
    status: "True"
    type: GuestEnvironmentSynced
  ...

Passwortlosen SSH-Zugriff aktivieren

So aktivieren Sie den passwortlosen SSH-Zugriff für die VM:

Erstellen Sie im Editor Ihrer Wahl eine VirtualMachineAccessRequest-Manifestdatei, z. B. vm-access-request.yaml:
```
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineAccessRequest
metadata:
  name: VMAR_NAME
  namespace: VM_NAMESPACE
spec:
  vm: VM_NAME
  user: USERNAME
  ssh:
    key: PUBLIC_SSH_KEY
    ttl: EXPIRATION_TIME
```
Ersetzen Sie Folgendes:
- VMAR_NAME: der Name der Ressource für die Zugriffsanfrage.
- VM_NAMESPACE: der Namespace für die VM, auf die Sie zugreifen möchten.
- VM_NAME: der Name der VM, auf die Sie zugreifen möchten.
- USERNAME: der Nutzername für den Nutzer, der auf die VM zugreift.
- PUBLIC_SSH_KEY: Der öffentliche Schlüssel für den SSH-Zugriff. In der Regel ist dies der Inhalt der id_rsa.pub-Datei.
- EXPIRATION_TIME: Das Feld ttl (Gültigkeitsdauer) gibt an, wie lange der SSH-Schlüssel gültig ist.
  
  Beispiel: Wenn Sie 30m angeben, läuft der SSH-Schlüssel nach 30 Minuten ab.
  
  Dieses Flag verwendet die folgenden Einheiten:
  - s für Sekunden
  - m für Minuten
  - h für Stunden
  - d für Tage
Verwende kubectl apply, um VirtualMachineAccessRequest aus der Manifestdatei zu erstellen. Wenn Sie Ihre Manifestdatei beispielsweise vm-access-request.yaml genannt haben,
```
kubectl apply -f MANIFEST --kubeconfig KUBECONFIG
```
Ersetzen Sie Folgendes:
- MANIFEST: der Name der Manifestdatei der Zugriffsanfrage. Beispiel: vm-access-request.yaml.
- KUBECONFIG: der Pfad zur kubeconfig-Datei des Clusters, der die VM hostet, auf die Sie zugreifen.

Prüfen Sie den Status von VirtualMachineAccessRequest, um zu prüfen, ob die Konfiguration der Zugriffsanfrage erfolgreich war:

kubectl get vmar VMAR_NAME -o yaml --kubeconfig KUBECONFIG

Wenn die Konfiguration erfolgreich ist, enthält der Abschnitt status state: configured:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineAccessRequest
metadata:
  ...
  annotations:
    kubectl.kubernetes.io/last-applied-configuration: |
      {"apiVersion":"vm.cluster.gke.io/v1","kind":"VirtualMachineAccessRequest",
      "metadata":{"annotations":{},"name":"vmar-sample","namespace":"default"},
      "spec":{"ssh":{"key":"ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQ...jMLHFc=
          sample-user@sample-host","ttl":"5h"},"user":"sample-user","vm":"vm-sample-01"}}
  creationTimestamp: "2022-10-06T21:55:57Z"
  finalizers:
  - vm.cluster.gke.io/vmar-finalizer
  generation: 2
  name: vmar-sample
  namespace: default
  resourceVersion: "13033921"
  uid: 282d72ad-f48d-4e89-af22-336940ac9f58
spec:
  ssh:
    key: ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQ...jMLHFc= sample-user@sample-host
    ttl: 5m0s
  user: sample-user
  vm: vm-sample-01
status:
  processedAt: "2022-10-06T21:55:57Z"
  state: configured

Gast-Agent deaktivieren

Wenn Sie eine neue VM erstellen und das Feld osType festlegen, wird der Gast-Agent aktiviert. Solange sich dieses Feature in der Vorschau befindet, können Sie es durch Bearbeiten der benutzerdefinierten Ressource VirtualMachine deaktivieren. Wenn Sie den Gast-Agent deaktivieren, wird auch der passwortlose SSH-Zugriff auf Ihre VM deaktiviert.

So deaktivieren Sie den Gast-Agent:

Verwenden Sie kubectl, um Ihre VM zu beenden, bevor Sie Änderungen an der Konfiguration vornehmen:
```
kubectl virt stop VM_NAME --kubeconfig KUBECONFIG
```

Bearbeiten Sie Ihre VM-Ressource:

kubectl edit gvm VM_NAME --kubeconfig KUBECONFIG

Aktualisieren Sie die VirtualMachine-Konfiguration, um explizit ein leeres spec.guestEnvironment hinzuzufügen:

apiVersion: vm.cluster.gke.io/v1alpha1
kind: VirtualMachine
metadata:
  name: vm-example
  namespace: default
spec:
  compute:
  ...
  osType: Linux
  guestEnvironment: {}

Speichern und schließen Sie das aktualisierte VM-Manifest in Ihrem Editor.

Starten Sie die VM mit kubectl:

kubectl virt start VM_NAME --kubeconfig KUBECONFIG

Verbindung über eine IP-Adresse herstellen

Wenn Ihre VM über eine zugängliche IP-Adresse verfügt und Sie bereits die Anmeldedaten für den Zugriff auf die VM haben, können Sie eine Verbindung über ein Protokoll wie SSH, VNC oder RDP herstellen.

Verbindung über IP-Adresse herstellen

Wenn Sie eine direkte Verbindung zur IP-Adresse Ihrer VM herstellen können, verwenden Sie eine der folgenden Methoden:

SSH

Rufen Sie die Details Ihrer VM ab, um deren IP-Adresse aufzurufen:
```
kubectl get gvm VM_NAME --namespace VM_NAMESPACE --kubeconfig KUBECONFIG
```
Ersetzen Sie die folgenden Werte:
- VM_NAME: der Name Ihrer VM.
- VM_NAMESPACE: der Namespace für Ihre VM.
Die folgende Beispielausgabe enthält die VM-Informationen und die IP-Adresse:
```
NAME   STATUS    AGE   IP
vm1    Running   7m    10.200.0.21
```
Stellen Sie über einen SSH-Client eine Verbindung zur VM her:
```
ssh USERNAME@IP_ADDRESS -i PATH_TO_KEY
```
Ersetzen Sie die folgenden Werte:
- USERNAME: der Nutzername für ein Konto auf Ihrer VM.
- IP_ADDRESS: die im vorherigen Schritt abgerufene IP-Adresse Ihrer VM.
- PATH_TO_KEY: der Pfad zum privaten SSH-Schlüssel.

VNC oder RDP

Mit Virtual Network Computing (VNC) und Remote Desktop Protocol (RDP) können Sie über die grafische Konsole auf Ihre VM zugreifen. Wenn Sie eine IP-Adresse verwenden, müssen Sie VNC oder RDP im Gastbetriebssystem aktivieren, bevor Sie mit beiden eine Verbindung zur VM herstellen können. Informationen zum Aktivieren und Verwenden von VNC oder RDP finden Sie in der Dokumentation Ihres Gastbetriebssystems.

Sie benötigen außerdem vorhandene Anmeldedaten, um sich bei der VM anzumelden. Dazu gehören beispielsweise Anmeldedaten, die Sie beim Erstellen einer VM zum Erstellen der ersten Nutzeranmeldedaten definieren.

Rufen Sie die Details Ihrer VM ab, um deren IP-Adresse aufzurufen:
```
kubectl get gvm VM_NAME --namespace VM_NAMESPACE --kubeconfig KUBECONFIG
```
Ersetzen Sie die folgenden Werte:
- VM_NAME: der Name Ihrer VM.
- VM_NAMESPACE: der Namespace für Ihre VM.
Die folgende Beispielausgabe enthält die VM-Informationen und die IP-Adresse:
```
NAME   STATUS    AGE   IP
vm1    Running   7m    10.200.0.21
```
Stellen Sie mit einem Clienttool und dem entsprechenden Port wie VNC-Port 5900 oder RDP-Port 3389 eine Verbindung zur IP-Adresse Ihrer VM her, die Sie im vorherigen Schritt abgerufen haben.

Verbindung über einen Dienst herstellen

Wenn die VM eine Verbindung zum Standard-pod-network herstellt und Sie nicht direkt mit der IP-Adresse der VM kommunizieren können, stellen Sie die VM hinter einem Load-Balancer-Service bereit.

Erstellen Sie in einem Editor Ihrer Wahl ein Service-Manifest wie my-service-load-balancer.yaml.
```
nano my-service-load-balancer.yaml
```
Kopieren Sie das folgende YAML-Manifest und fügen Sie es ein:
```
apiVersion: v1
kind: Service
metadata:
  name: VM_NAME-service
spec:
  selector:
    kubevirt/vm: VM_NAME
  ports:
  - name: PORT_NAME
    protocol: PROTOCOL_TYPE
    port: EXTERNAL_PORT
    targetPort: TARGET_PORT
  type: LoadBalancer
```
Ersetzen Sie in diesem Manifesttyp Service die folgenden Werte:
- VM_NAME: der Name Ihrer VM, der für den Remotezugriff freigegeben werden soll.
- PORT_NAME: der Name Ihres Protokolls, z. B. ssh, vnc oder rdp.
- PROTOCOL_TYPE: der Protokolltyp, z. B. tcp für SSH und RDP oder udp für VNC.
- EXTERNAL_PORT: die externe Portnummer, die bereitgestellt werden soll und zu der Sie eine Verbindung herstellen.
- TARGET_PORT: der Zielport, z. B. 22 für SSH.
Speichern und schließen Sie das Manifest Service in Ihrem Editor.

Erstellen Sie Service mit kubectl:

kubectl apply -f my-service-load-balancer.yaml  --kubeconfig KUBECONFIG

Rufen Sie die EXTERNAL-IP-Adresse des Load-Balancer-Dienstes ab:

kubectl get service VM_NAME-service --kubeconfig KUBECONFIG

Die IP-Adresse des Load-Balancers wird angezeigt, wie in der folgenden Beispielausgabe gezeigt:

NAME          TYPE           CLUSTER-IP       EXTERNAL-IP   PORT(S)        AGE
vm1-service   LoadBalancer   172.26.232.167   10.200.0.51   22:31141/TCP   6d20h

Stellen Sie eine Verbindung zur EXTERNAL-IP-Adresse des Load-Balancers mit einem Standardprotokoll her, z. B. mit einem SSH-Client:
```
ssh USERNAME@LOAD_BALANCER_IP_ADDRESS  -i PATH_TO_KEY
```
Ersetzen Sie die folgenden Werte:
- USERNAME: der Nutzername für ein Konto auf Ihrer VM.
- LOAD_BALANCER_IP_ADDRESS ist die IP-Adresse Ihres Load-Balancers.
- PATH_TO_KEY: der Pfad zum privaten SSH-Schlüssel.

Direkt über SSH verbinden

Wenn Ihr Client mit demselben physischen Netzwerk wie Ihr Anthos Clusters on Bare Metal-Knoten verbunden ist und Sie keine SSH-Tunnel zur Verbindung mit dem Cluster verwenden müssen, können Sie eine Verbindung über kubectl virt ssh herstellen.

So stellen Sie mit einer Linux-VM über die Console SSH mit dem Add-on virtctl bereit:
```
kubectl virt ssh USERNAME@VM_NAME --namespace VM_NAMESPACE --kubeconfig KUBECONFIG
```
Ersetzen Sie die folgenden Werte:
- USERNAME: der Nutzername für den Zugriff auf Ihre VM. Dieses Konto wird erstellt, wenn es nicht auf der VM vorhanden ist.
- VM_NAME ist der Name Ihrer VM.
Nachdem Sie die Verbindung zur VM über SSH erfolgreich hergestellt haben und die Verbindung nicht mehr benötigen, beenden Sie die SSH-Sitzung:
```
exit
```

Direkte Verbindung über die Console herstellen

Wenn Sie keine direkte Netzwerkverbindung zu Ihrer Linux-VM für den SSH-Zugriff haben, stellen Sie über die VM-Laufzeit in der Google Distributed Cloud Console eine Verbindung zur Konsole der VM her. Mit dieser Methode wird eine serielle Konsole geöffnet. Nach dem Verbindungsaufbau erhalten Sie eine Eingabeaufforderung anstelle einer grafischen Konsole.

Verwenden Sie das Add-on virtctl, um von der Konsole aus auf eine Linux-VM zuzugreifen:
```
kubectl virt console VM_NAME --kubeconfig KUBECONFIG
```
Ersetzen Sie VM_NAME durch den Namen Ihrer VM.

Geben Sie bei entsprechender Aufforderung die Nutzeranmeldedaten für Ihre VM ein. Diese Anmeldedaten müssen auf der VM vorhanden sein oder beim Erstellen der VM angewendet werden. Weitere Informationen finden Sie im folgenden Abschnitt, um beim Erstellen einer VM die ersten Nutzeranmeldedaten zu erstellen.
Nachdem Sie erfolgreich eine Verbindung zur Konsole der VM hergestellt haben und die Verbindung nicht mehr benötigen, beenden Sie die VM-Sitzung und die Console:
```
Ctrl + ]
```

Direkte Verbindung über VNC

Mit dem Befehl kubectl virt vnc können Sie die grafische Konsole von Virtual Network Computing (VNC) öffnen und auf Ihre VMs zugreifen. Diese Methode funktioniert für VMs, auf denen entweder ein Windows- oder ein Linux-Gastbetriebssystem ausgeführt wird. Wenn Sie den Befehl kubectl virt vnc verwenden, öffnet VM Runtime in Google Distributed Cloud VNC für Sie, sodass Sie VNC im Gastbetriebssystem nicht aktivieren müssen.

Sie benötigen vorhandene Anmeldedaten, um sich bei der VM anzumelden. Dazu gehören beispielsweise Anmeldedaten, die Sie beim Erstellen einer VM zum Erstellen der ersten Nutzeranmeldedaten definieren.

Für den Zugriff auf eine VM mit VNC verwenden Sie das Add-on virtctl:
```
kubectl virt vnc VM_NAME --kubeconfig KUBECONFIG
```
Ersetzen Sie VM_NAME durch den Namen Ihrer VM.

Geben Sie bei entsprechender Aufforderung die Nutzeranmeldedaten für Ihre VM ein.
Nachdem Sie erfolgreich eine Verbindung zur VNC-Sitzung der VM hergestellt haben und die Verbindung nicht mehr benötigen, melden Sie sich von der VM ab, um die VNC-Verbindung zu schließen.

Erste Nutzeranmeldedaten erstellen

Wenn Sie über die Console eine Verbindung zu Ihrer VM herstellen, müssen Sie Nutzeranmeldedaten angeben. Das Verfahren zum Erstellen der ersten Nutzeranmeldedaten unterscheidet sich bei Linux- und Windows-Gastbetriebssystemen.

Linux-Gastbetriebssystem

Bei Linux-VMs können Nutzeranmeldedaten in Ihre benutzerdefinierten Images eingebunden oder beim Erstellen einer VM angegeben werden.

Verwenden Sie den Parameter --configure-initial-password mit dem Befehl kubectl virt create:
```
kubectl virt create vm VM_NAME \
    --image ubuntu20.04 \
    --os-type Linux \
    --configure-initial-password USERNAME:PASSWORD \
    --kubeconfig KUBECONFIG
```
Ersetzen Sie die folgenden Werte:
- VM_NAME: der Name Ihrer VM.
- USERNAME ist der Nutzername für das Konto, das auf der VM erstellt werden soll.
- PASSWORD: Passwort für das Nutzerkonto.
Mit diesem Beispielbefehl wird eine Linux-VM erstellt, auf der Ubuntu 20.04 ausgeführt wird. Es empfiehlt sich, die anfänglichen Anmeldedaten nach der ersten Anmeldung bei der VM zu ändern.

Windows-Gastbetriebssystem

Führen Sie die folgenden Schritte aus, um ein Passwort für einen vorhandenen Nutzer zurückzusetzen oder das Anfangspasswort für einen neuen Nutzer zu erstellen:

Aktivieren Sie den Gast-Agent auf Ihrer Windows-VM:
1. Konfigurieren Sie die VM so, dass der Gast-Agent aktiviert wird.
2. Stellen Sie über VNC oder RDP eine Verbindung zur VM her.
3. Rufen Sie in der VM das Laufwerk guest agent auf. In den meisten Fällen ist dies Laufwerk E:.
4. Führen Sie mit PowerShell install.ps1 aus.
  
  Dadurch wird der Gast-Agent installiert und gestartet. Bei nachfolgenden VM-Neustarts wird der Gast-Agent automatisch gestartet.
5. Schließen Sie die Remotesitzung.
Verwenden Sie auf Ihrer Administrator-Workstation den folgenden Befehl, um das Windows-VM-Passwort zurückzusetzen (oder festzulegen, wenn Sie einen neuen Nutzernamen verwenden):
```
kubectl virt reset-windows-password VM_NAME \
    --user=USERNAME \
    --namespace=VM_NAMESPACE
```
Ersetzen Sie Folgendes:
- VM_NAME: der Name der VM.
- USERNAME: Nutzername, für den Sie das Passwort zurücksetzen (oder festlegen) möchten. Wenn der Nutzername neu ist, erstellt der Befehl ein neues Windows-Konto und legt das vorläufige Passwort fest.
- VM_NAMESPACE (optional): Der Namespace der VM. Dieses Flag ist optional. Wenn nicht angegeben, wird der Standard-Namespace default verwendet.
Wenn Sie das Passwort ohne Bestätigungsaufforderung zurücksetzen oder festlegen möchten, verwenden Sie das optionale Flag --force. Wenn Sie das Flag --force verwenden, werden Sie in der Eingabeaufforderung auf die Konsequenzen hingewiesen, wenn das Passwort für ein vorhandenes Konto zurückgesetzt wird. Ohne das Flag --force werden Sie vom Befehl mit dem folgenden Text aufgefordert, das Zurücksetzen des Passworts zu bestätigen:
```
This command creates an account and sets an initial password for the
user USERNAME if the account does not already exist.
If the account already exists, resetting the password can cause the
LOSS OF ENCRYPTED DATA secured with the current password, including
files and stored passwords.

Would you like to set or reset the password for USERNAME (Y/n)?
```
Nachdem Sie das Zurücksetzen des Passworts bestätigt oder erzwungen haben, gibt der Befehl das neue Passwort für die angegebene VM und den angegebenen Nutzernamen zurück:
```
Resetting and retrieving password for USERNAME on VM_NAME

vm_name:    VM_NAME
username:   USERNAME
password:   PASSWORD
```