Bereitstellen von Multus mit Whereabouts in Arbeitslastclustern

Whereabouts ist ein IPAM-CNI-Plug-In (IP Address Management) für die knotenübergreifende dynamische Zuweisung von IP-Adressen zu Pods. Verglichen mit anderen IPAM-Plug-Ins, wie z. B. host-local, das IP-Adressen ausschließlich zu Pods auf demselben Knoten zuweist, weist whereabouts IP-Adressen clusterweit zu.

In diesem Thema erhalten Sie Informationen zum Anhängen einer sekundären Netzwerkschnittstelle an einen Pod mit einer IP-Adresse, die in dem von Ihnen mithilfe von whereabouts angegebenen Bereich zugewiesen wurde. Sie verfügen beispielsweise über Antrea oder Calico als primäre CNI, eine sekundäre mithilfe von macvlan oder ipvlan erstellte Schnittstelle, und Whereabouts als IPAM-CNI.

Voraussetzungen

Eine Bootstrap-Maschine, auf der Folgendes installiert ist:
- Multus-CNI-Paket zur Unterstützung mehrerer Netzwerke. Weitere Informationen finden Sie unter Bereitstellen von Multus in Arbeitslastclustern.
- Tanzu CLI, Tanzu CLI-Plug-Ins und kubectl (siehe Beschreibung unter Installieren der Tanzu CLI und anderer Tools).
- Carvel-Tools (siehe Beschreibung unter Installieren der Carvel-Tools).
- yq v4.5 oder höher.
Ein Tanzu Kubernetes Grid-Verwaltungscluster und ein Arbeitslastcluster, der auf vSphere, Amazon Web Services (AWS) oder Azure ausgeführt werden.
- Whereabouts benötigt Worker-Knoten des Arbeitslastclusters der Größe large oder extra-large (siehe Beschreibung unter Vordefinierte Knotengrößen).

Installieren des Whereabouts-Pakets

So installieren Sie das Whereabouts-Paket in einem Arbeitslastcluster und konfigurieren den Cluster zu Verwendungszwecken:

Konfigurieren und installieren Sie Whereabouts.
1. Erstellen Sie eine Konfigurationsdatei, die die Whereabouts-Parameter abruft.
```
tanzu package available get whereabouts.tanzu.vmware.com/PACKAGE-VERSION --default-values-file-output FILE-PATH
```
  Hinweis
  Als Namespace, in dem whereabouts-Komponenten bereitgestellt werden sollen, muss kube-system verwendet werden. Jede benutzerdefinierte Namespace-Installation schlägt fehl.
  
  Dabei ist PACKAGE-VERSION die Version des Whereabouts-Pakets, das Sie installieren möchten, und FILE-PATH der Speicherort, an dem Sie die Konfigurationsdatei speichern möchten, z. B. whereabouts-data-values.yaml. Mit obigem Befehl wird eine Konfigurationsdatei namens whereabouts-data-values.yaml mit den Standardwerten erstellt.
2. Führen Sie den Befehl tanzu package available list aus, um die verfügbaren Versionen des Whereabouts-Pakets aufzulisten, wie z. B.:
```
tanzu package available list whereabouts.tanzu.vmware.com -A
 NAME                           VERSION               RELEASED-AT                     NAMESPACE
 whereabouts.tanzu.vmware.com   0.5.1+vmware.2-tkg.1  2022-30-04 18:00:00 +0000 UTC   tanzu-package-repo-global
```
  Hinweis
  Stellen Sie sicher, dass Ihre benutzerdefinierte Image-Registrierung erreichbar ist, wenn Sie in einer Umgebung mit eingeschränktem Netzwerk arbeiten.
3. Führen Sie den Befehl tanzu package available get mit --values-schema aus, um die festzulegenden Feldwerte anzuzeigen:
```
tanzu package available get whereabouts.tanzu.vmware.com/VERSION --values-schema -o FORMAT
```
  Dabei gilt: – VERSION ist eine Version, die in der Ausgabe tanzu package available list aufgelistet wird – FORMAT ist entweder yaml oder json
4. Befüllen Sie die Konfigurationsdatei whereabouts-data-values.yaml mit den gewünschten Feldwerten.
Entfernen Sie alle Kommentare aus der Datei whereabouts-data-values.yaml:
```
yq -i eval '... comments=""' whereabouts-cni-default-values.yaml
```
Führen Sie tanzu package install aus, um das Paket zu installieren.
```
tanzu package install whereabouts --package whereabouts.tanzu.vmware.com --version AVAILABLE-PACKAGE-VERSION --values-file whereabouts-data-values.yaml --namespace TARGET-NAMESPACE
```
Dabei gilt:
- TARGET-NAMESPACE ist der Namespace, in dem das Whereabouts-Paket installiert werden soll. Beispielsweise der Namespace my-packages oder tanzu-cli-managed-packages.
  - Wenn das Flag --namespace nicht angegeben ist, installiert die Tanzu CLI das Paket im Namespace default.
  - Der angegebene Namespace muss bereits vorhanden sein, wie z. B. durch die Ausführung von kubectl create namespace my-packages.
- AVAILABLE-PACKAGE-VERSION ist die Version, die Sie oben abgerufen haben, z. B. 0.5.1+vmware.2-tkg.1.
Führen Sie tanzu package installed get aus, um den Status des installierten Pakets zu überprüfen.
```
tanzu package installed get whereabouts -o <json|yaml|table>
```
Erstellen Sie eine benutzerdefinierte Ressourcendefinition (CRD) für NetworkAttachmentDefinition, in der die CNI-Konfiguration für Netzwerkschnittstellen definiert wird, die von der Multus-CNI mit Whereabouts als IPAM-Typ verwendet werden sollen.
1. Erstellen Sie eine CRD-Spezifikation. Beispiel: Diese multus-cni-crd.yaml gibt eine NetworkAttachmentDefinition mit dem Namen macvlan-conf an, die eine macvlan-CNI konfiguriert und whereabouts als IPAM-Typ verwendet:
```
---
apiVersion: "k8s.cni.cncf.io/v1"
kind: NetworkAttachmentDefinition
metadata:
  name: macvlan-conf
spec:
  config: '{
    "cniVersion": "0.3.1",
    "plugins": [
      {
      "type": "macvlan",
      "capabilities": { "ips": true },
      "master": "eth0",
      "mode": "bridge",
      "ipam": {
        "type": "whereabouts",
        "range": "192.168.20.0/24",
        "range_start": "192.168.20.10",
        "range_end": "192.168.20.100",
        "gateway": "192.168.20.1"
        }
      } ]
    }'
```
2. Erstellen Sie die Ressource, wie z. B. kubectl create -f multus-cni-crd.yaml.
Erstellen Sie einen Pod mit der Anmerkung k8s.v1.cni.cncf.io/networks, um das zusätzliche Netzwerk anzugeben, das hinzugefügt werden soll.
1. Erstellen Sie die Pod-Spezifikation. Beispiel: my-multi-cni-pod.yaml:
```
apiVersion: v1
kind: Pod
metadata:
  name: pod0
  annotations:
    k8s.v1.cni.cncf.io/networks: macvlan-conf
spec:
  containers:
  - name: pod0
    command: ["/bin/ash", "-c", "trap : TERM INT; sleep infinity & wait"]
    image: docker.io/kserving/tools:latest
```
2. Erstellen Sie den Pod. Beispiel: kubectl create -f my-multi-cni-crd.yaml erstellt den Pod pod0.
3. Nach der Erstellung des Pods verfügt dieser über drei Netzwerkschnittstellen:
  - lo: die Loopback-Schnittstelle
  - eth0: das von der Antrea- oder Calico-CNI verwaltete Standard-Pod-Netzwerk
  - net1: die über die Anmerkung k8s.v1.cni.cncf.io/networks: macvlan-conf erstellte neue Schnittstelle.
  Hinweis
  Das Standardnetzwerk erhält den Namen eth0, und zusätzliche Netzwerk-Pod-Schnittstellen erhalten den Namen net1, net2 usw.
4. Führen Sie kubectl describe pod auf pod0 aus und bestätigen Sie, dass in der Anmerkung k8s.v1.cni.cncf.io/network-status alle Netzwerkschnittstellen aufgelistet werden.
  
  Beispiel:
```
$ kubectl describe pod pod0

Name:         pod0
Namespace:    default
Priority:     0
Node:         tcecluster-md-0-6476897f75-rl9vt/10.170.109.225
Start Time:   Thu, 25 August 2022 15:31:20 +0000
Labels:       <none>
Annotations:  k8s.v1.cni.cncf.io/network-status:
               [{
                   "name": "",
                   "interface": "eth0",
                   "ips": [
                       "100.96.1.80"
                   ],
                   "mac": "66:39:dc:63:50:a3",
                   "default": true,
                   "dns": {}
               },{
                   "name": "default/macvlan-conf",
                   "interface": "net1",
                   "ips": [
                       "192.168.20.11"
                   ],
                   "mac": "02:77:cb:a0:60:e3",
                   "dns": {}
               }]
             k8s.v1.cni.cncf.io/networks: macvlan-conf
```
  Führen Sie anschließend kubectl exec sample-pod -- ip a show dev net1 aus, um sicherzustellen, dass die Zielschnittstelle aktiv ist und mit der in den obigen Anmerkungen aufgelisteten IP-Adresse ausgeführt wird. Wiederholen Sie diesen Schritt zum Validieren der Konfiguration für andere Pods, die Sie im nächsten Schritt erstellen.
Erstellen Sie zwei zusätzliche Pods: pod1 auf demselben Knoten und pod2 auf einem anderen Knoten. Sie verwenden diese Pods, um den Netzwerkzugriff innerhalb eines Einzelknotens und innerhalb der Knoten im Cluster zu überprüfen.

Validieren des Netzwerkdatenverkehrs zwischen Pods im Cluster

Sie können jetzt den Netzwerkzugriff zwischen Pods im selben Knoten und Pods im Cluster überprüfen.

Stellen Sie sicher, dass der Netzwerkzugriff zwischen Pods auf demselben Knoten funktioniert. Mit dem folgenden Befehl wird beispielsweise überprüft, ob pod0 pod1 über die zugewiesene IP-Adresse erreichen kann.

  kubectl exec -it pod0 -- ping -c 3 192.168.20.12
  PING 192.168.20.12 (192.168.20.12) 56(84) bytes of data.
  64 bytes from 192.168.20.12: icmp_seq=1 ttl=64 time=0.237 ms
  64 bytes from 192.168.20.12: icmp_seq=2 ttl=64 time=0.215 ms
  64 bytes from 192.168.20.12: icmp_seq=3 ttl=64 time=0.156 ms

--- 192.168.20.12 ping statistics ---
3 packets transmitted, 3 received, 0% packet loss, time 2030ms
rtt min/avg/max/mdev = 0.156/0.202/0.237/0.037 ms

Stellen Sie sicher, dass der Netzwerkzugriff zwischen Pods auf verschiedenen Knoten funktioniert. Mit dem folgenden Befehl wird beispielsweise überprüft, ob pod0 pod2 über die zugewiesene IP-Adresse erreichen kann.

  kubectl exec -it pod0 -- ping -c 3 <192.168.20.13
  PING 192.168.20.13 (192.168.20.13) 56(84) bytes of data.
  64 bytes from 192.168.20.13: icmp_seq=1 ttl=64 time=0.799 ms
  64 bytes from 192.168.20.13: icmp_seq=2 ttl=64 time=0.626 ms
  64 bytes from 192.168.20.13: icmp_seq=3 ttl=64 time=0.655 ms

--- 192.168.20.13 ping statistics ---
3 packets transmitted, 3 received, 0% packet loss, time 2030ms
rtt min/avg/max/mdev = 0.626/0.693/0.799/0.078 ms