Anthos-Cluster auf Bare Metal sind jetzt Google Distributed Cloud (nur Software) für Bare Metal. Weitere Informationen finden Sie in der Produktübersicht.

NUMA-fähige VMs konfigurieren

In diesem Dokument wird beschrieben, wie Sie Cluster und VMs so konfigurieren, dass Arbeitslasten mit hoher Leistung und niedriger Latenz mit der Computing-Effizienz des nicht einheitlichen Speicherzugriffs (NUMA) unterstützt werden. Es gibt eine Anleitung zum Optimieren der Kubernetes-Einstellungen für Clusterknoten. Außerdem enthält dieses Dokument eine Anleitung zum Konfigurieren virtueller Maschinen (VMs) mit NUMA-Affinität, damit sie geplant werden und die NUMA-Knoten nutzen können.

Bei einer NUMA-kompatiblen VM erfolgt die gesamte Kommunikation innerhalb der VM lokal für den NUMA-Knoten. Die NUMA-kompatible VM vermeidet Datentransaktionen zu und von Remote-Ressourcen, die die VM-Leistung beeinträchtigen können.

Knoten für die Verwendung von NUMA konfigurieren

In den folgenden Abschnitten wird beschrieben, wie Sie die wichtigen Kubernetes-Komponenten konfigurieren, um den Knoten zu optimieren und dafür zu sorgen, dass NUMA-kompatible Container geplant werden können. Diese NUMA-Knoten sind so abgestimmt, dass die CPU- und Arbeitsspeicherleistung optimiert wird. Folgen Sie der Anleitung für jeden Knoten, auf dem Sie NUMA-kompatible VMs ausführen möchten.

Kubelet-Konfiguration aktualisieren

Im Rahmen der Knotenkonfiguration müssen Sie die folgenden Änderungen an der kubelet-Konfiguration vornehmen, um die NUMA-Knotenaffinität zu unterstützen:

CPU-Manager mit einer static-Richtlinie aktivieren
Arbeitsspeichermanager mit einer Static-Richtlinie aktivieren
Topologiemanager mit restricted-Topologie aktivieren

So konfigurieren Sie kubelet auf Ihrem Worker-Knoten:

Suchen Sie auf Ihrem Worker-Knoten nach der Datei kubelet und öffnen Sie sie zur Bearbeitung:
```
edit /etc/default/kubelet
```
Wenn die Datei kubelet nicht angezeigt wird, erstellen Sie sie mit dem folgenden Befehl:
```
echo "KUBELET_EXTRA_ARGS=\"\"" >> /etc/default/kubelet
```
Mit diesem Befehl wird die kubelet-Datei mit einem leeren KUBELET_EXTRA_ARGS=""-Abschnitt erstellt.
Wenn Sie den CPU-Manager mit einer static-Richtlinie aktivieren möchten, fügen Sie dem Abschnitt KUBELET_EXTRA_ARGS="" der Datei das Flag --cpu-manager-policy=static hinzu:
```
KUBELET_EXTRA_ARGS="--cpu-manager-policy=static"
```
Wenn Sie den Speichermanager mit einer Static-Richtlinie aktivieren möchten, fügen Sie dem Abschnitt KUBELET_EXTRA_ARGS="" der Datei das Flag --memory-manager-policy=Static hinzu:
```
KUBELET_EXTRA_ARGS="--cpu-manager-policy=static --memory-manager-policy=Static"
```
Wenn Sie den Topology Manager mit einer restricted-Richtlinie aktivieren möchten, fügen Sie dem Abschnitt KUBELET_EXTRA_ARGS="" der Datei das Flag --topology-manager-policy=restricted hinzu:
```
KUBELET_EXTRA_ARGS="--cpu-manager-policy=static --memory-manager-policy=Static --topology-manager-policy=restricted"
```

So prüfen Sie, wie viel Arbeitsspeicher derzeit von Google Distributed Cloud reserviert ist:

cat /var/lib/kubelet/kubeadm-flags.env

Die Ausgabe sollte so aussehen:

KUBELET_KUBEADM_ARGS="--anonymous-auth=false --authentication-token-webhook=true --authorization-mode=Webhook --container-runtime=remote --container-runtime-endpoint=unix:///run/containerd/containerd.sock --feature-gates=SeccompDefault=true --kube-reserved=cpu=100m,memory=3470Mi --max-pods=110 --node-ip=192.168.1.190 --node-labels=baremetal.cluster.gke.io/k8s-ip=192.168.1.190,baremetal.cluster.gke.io/namespace=cluster-user001,baremetal.cluster.gke.io/node-pool=node-pool-1,cloud.google.com/gke-nodepool=node-pool-1 --pod-infra-container-image=gcr.io/anthos-baremetal-release/pause-amd64:3.1-gke.5 --provider-id=baremetal://192.168.1.190 --read-only-port=10255 --rotate-server-certificates=true --seccomp-default=true"

Die Einstellung --kube-reserved=cpu=100m,memory=3470Mi gibt an,dass Google Distributed Cloud 3.470 Mebibyte Arbeitsspeicher auf dem Knoten reserviert hat.

Legen Sie das --reserved-memory-Flag im Abschnitt KUBELET_EXTRA_ARGS der Datei kubelet auf 100 Mebibyte höher als den aktuellen reservierten Arbeitsspeicher fest, um den Auslagerungsgrenzwert zu berücksichtigen. Wenn kein reservierter Arbeitsspeicher vorhanden ist, können Sie diesen Schritt überspringen.

Wenn Sie beispielsweise mit dem reservierten Arbeitsspeicher von 3470Mi aus dem Beispiel im vorherigen Schritt 3570Mi Arbeitsspeicher in der Datei kubelet reservieren, sieht das so aus:
```
KUBELET_EXTRA_ARGS="--cpu-manager-policy=static --memory-manager-policy=Static --topology-manager-policy=restricted --reserved-memory=0:memory=3570Mi"
```
Entfernen Sie die Dateien zum CPU- und Arbeitsspeicherstatus aus dem Verzeichnis /var/lib:
```
rm /var/lib/cpu_manager_state
rm /var/lib/memory_manager_state
```
Starten Sie das Kubelet neu:
```
systemctl start kubelet
```

Weitere Informationen zu diesen Richtlinieneinstellungen finden Sie in der folgenden Kubernetes-Dokumentation:

Knoten für die Verwendung von Hugepages konfigurieren

Nachdem Sie den Arbeitsspeichermanager mit der Static-Richtlinie aktiviert haben, können Sie Hugepages hinzufügen, um die Leistung der Containerarbeitslast auf Ihren NUMA-Knoten weiter zu verbessern. Wie der Name schon sagt, können Sie mit Hugepages Arbeitsspeicherseiten angeben, die größer als die Standardgröße von 4 Kibibyte (KiB) sind. VM Runtime on GDC unterstützt Hugepages mit 2 Mebibyte (MiB) und 1 Gibibyte (GiB). Sie können Hugepages für einen Knoten zur Laufzeit oder beim Starten des Knotens festlegen. Wir empfehlen, Hugepages auf jedem Knoten zu konfigurieren, auf dem NUMA-kompatible VMs ausgeführt werden sollen.

Verwenden Sie den folgenden Befehl, um die Anzahl der Hugepages einer bestimmten Größe auf Ihrem NUMA-Knoten zur Laufzeit zu konfigurieren:
```
echo HUGEPAGE_QTY > \
    /sys/devices/system/node/NUMA_NODE/hugepages/hugepages-HUGEPAGE_SIZEkB/nr_hugepages
```
Ersetzen Sie Folgendes:
- HUGEPAGE_QTY: die Anzahl der Hugepages, die der angegebenen Größe zugewiesen werden sollen.
- NUMA_NODE: NUMA-Knoten, z. B. node0, dem Sie Hugepages zuweisen.
- HUGEPAGE_SIZE: die Größe der Hugepages in Kibibyte, 2048 (2 MiB) oder 1048576 (1 GiB).

VM für die Verwendung des NUMA-Knotens konfigurieren

Sobald Ihre Clusterknoten für NUMA optimiert sind, können Sie NUMA-kompatible VMs erstellen. NUMA-kompatible VMs werden auf NUMA-Knoten geplant.

So erstellen Sie eine NUMA-kompatible VM:

Folgen Sie der Anleitung unter VM aus einem Manifest erstellen.

Verwenden Sie die folgenden compute-Einstellungen, um Ihre VM NUMA-fähig zu konfigurieren:
- spec.compute.guaranteed: Setzen Sie guaranteed auf true. Mit dieser Einstellung wird der virt-launcher-Pod so konfiguriert, dass er in der Kubernetes-Klasse für die garantierte Dienstqualität (Quality of Service, QoS) platziert wird.
- spec.compute.advancedCompute:
  - dedicatedCPUPlacement: Setzen Sie dedicatedCPUPlacement auf true. Dadurch werden virtuelle CPUs den physischen CPUs des Knotens zugewiesen.
  - hugePageSize: Legen Sie hugePageSize auf 2Mi oder 1Gi fest, um die Größe der Hugepages für Ihre VM anzugeben, 2 Mebibyte oder 1 Gigabyte.
  - numaGuestMappingPassthrough: Fügen Sie für diese Einstellung eine leere Struktur ({}) ein. Mit dieser Einstellung wird eine NUMA-Affinität festgelegt, sodass Ihre VM nur auf NUMA-Knoten geplant wird.
Das folgende Beispielmanifest für eine virtuelle Maschine zeigt, wie eine NUMA-kompatible VM-Konfiguration aussehen könnte:
```
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: vm1
spec:
  compute:
    cpu:
      vcpus: 2
    guaranteed: true
    advancedCompute:
      dedicatedCPUPlacement: true
      hugePageSize: 2Mi
      numaGuestMappingPassthrough: {}
    memory:
      capacity: 256Mi
  interfaces:
  - name: eth0
    networkName: pod-network
    default: true
  disks:
  - virtualMachineDiskName: disk-from-gcs
    boot: true
    readOnly: true
```