Distribuzione di Multus con Whereabouts nei cluster del carico di lavoro

Whereabouts è un plug-in CNI di Gestione indirizzi IP (IP Address Management, IPAM) che assegna in modo dinamico gli indirizzi IP ai pod in tutti i nodi di un cluster. Rispetto agli altri plug-in IPAM come host-local, che assegna solo gli indirizzi IP ai pod nello stesso nodo, whereabouts assegna indirizzi IP a livello di cluster.

In questo argomento verrà illustrato come collegare un'interfaccia di rete secondaria a un pod con indirizzo IP assegnato nell'intervallo specificato utilizzando whereabouts. Ad esempio, Antrea o Calico sarà l'interfaccia CNI principale, sarà presente un'interfaccia secondaria creata utilizzando macvlan o ipvlan e Whereabouts sarà la CNI di IPAM.

Prerequisiti

Una macchina bootstrap con le seguenti installazioni:
- Pacchetto Multus CNI per supportare più reti. Per ulteriori informazioni, vedere Distribuzione di Multus nei cluster del carico di lavoro.
- CLI di Tanzu, plug-in della CLI di Tanzu e kubectl, come descritto in Installazione della CLI di Tanzu e della CLI di Kubernetes per l'utilizzo con cluster di gestione autonomi.
- yq v4.5 o versione successiva.
Un cluster di gestione Tanzu Kubernetes Grid e un cluster del carico di lavoro in esecuzione in vSphere, Amazon Web Services (AWS) o Azure.
- Whereabouts richiede nodi worker del cluster del carico di lavoro di dimensioni large o extra-large, come descritto in Dimensioni dei nodi predefinite.

Installare il pacchetto Whereabouts

Per installare il pacchetto Whereabouts in un cluster del carico di lavoro e configurare il cluster affinché lo utilizzi:

Configurare e installare Whereabouts.
1. Creare un file di configurazione che recupera i parametri Whereabouts.
```
tanzu package available get whereabouts.tanzu.vmware.com/PACKAGE-VERSION --default-values-file-output FILE-PATH
```
  Nota
  Lo spazio dei nomi in cui distribuire i componenti whereabouts devono essere kube-system. Qualsiasi installazione dello spazio dei nomi personalizzata non riuscirà.
  
  Dove PACKAGE-VERSION è la versione del pacchetto Whereabouts che si desidera installare e FILE-PATH è la posizione in cui si desidera salvare il file di configurazione, ad esempio whereabouts-data-values.yaml. Il comando precedente creerà un file di configurazione denominato whereabouts-data-values.yaml contenente i valori predefiniti.
2. Eseguire il comando tanzu package available list per elencare le versioni disponibili del pacchetto Whereabouts, ad esempio:
```
tanzu package available list whereabouts.tanzu.vmware.com -A
 NAME                           VERSION               RELEASED-AT                     NAMESPACE
 whereabouts.tanzu.vmware.com   0.6.1+vmware.2-tkg.1  2023-30-04 18:00:00 +0000 UTC   tanzu-package-repo-global
```
  Nota
  assicurarsi che il registro immagini personalizzato possa essere raggiunto se si opera in un ambiente con restrizioni di rete.
3. Eseguire il comando tanzu package available getcon --values-schema per verificare quali valori dei campi possono essere impostati:
```
tanzu package available get whereabouts.tanzu.vmware.com/VERSION --values-schema -o FORMAT
```
  In cui: - VERSION è una versione elencata nell'output tanzu package available list - FORMAT è yaml oppure json
4. Compilare il file di configurazione whereabouts-data-values.yaml con i valori del campo desiderato.

Rimuovere tutti i commenti dal file whereabouts-data-values.yaml:

yq -i eval '... comments=""' whereabouts-cni-default-values.yaml

Eseguire tanzu package install per installare il pacchetto.
```
tanzu package install whereabouts --package whereabouts.tanzu.vmware.com --version AVAILABLE-PACKAGE-VERSION --values-file whereabouts-data-values.yaml --namespace TARGET-NAMESPACE
```
In cui:
- TARGET-NAMESPACE è lo spazio dei nomi in cui si desidera installare il pacchetto Whereabouts. Ad esempio, lo spazio dei nomi my-packages o tanzu-cli-managed-packages.
  - Se il flag --namespace non viene specificato, la CLI di Tanzu installa il pacchetto nello spazio dei nomi default.
  - Lo spazio dei nomi specificato deve essere già stato creato, ad esempio eseguendo kubectl create namespace my-packages.
- AVAILABLE-PACKAGE-VERSION è la versione recuperata in precedenza, ad esempio 0.6.1+vmware.2-tkg.1.
Eseguire tanzu package installed get per verificare lo stato del pacchetto installato.
```
tanzu package installed get whereabouts -o <json|yaml|table>
```

Creare una definizione di risorsa personalizzata (Custom Resource Definition, CRD) per NetworkAttachmentDefinition che definisca la configurazione CNI per le interfacce di rete che devono essere utilizzate da Multus CNI con Whereabouts come tipo IPAM.

Creare una specifica CRD. Ad esempio, questo multus-cni-crd.yaml specifica una NetworkAttachmentDefinition denominata macvlan-conf che configura un CNI macvlan e ha whereabouts come tipo IPAM:

---
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"
        }
      } ]
    }'

Creare la risorsa; ad esempio kubectl create -f multus-cni-crd.yaml

Creare un pod con l'annotazione k8s.v1.cni.cncf.io/networks per specificare la rete aggiuntiva da aggiungere.

Creare la specifica del pod, ad esempio 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

Creare il pod. Ad esempio, kubectl create -f my-multi-cni-crd.yaml crea il pod pod0.
Una volta creato, il pod avrà tre interfacce di rete:
- lo l'interfaccia di loopback
- eth0 la rete pod predefinita gestita da Antrea o Calico CNI
- net1 la nuova interfaccia creata tramite l'annotazione k8s.v1.cni.cncf.io/networks: macvlan-conf.
Nota
La rete predefinita ottiene il nome eth0 mentre altre interfacce del pod di rete ottengono il nome net1, net2 e così via.

Eseguire kubectl describe pod su pod0 e confermare che l'annotazione k8s.v1.cni.cncf.io/network-status elenchi tutte le interfacce di rete.

Ad esempio:

$ 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

Eseguire quindi kubectl exec sample-pod -- ip a show dev net1 per verificare che l'interfaccia di destinazione sia attiva e funzionante con l'IP elencato nelle annotazioni precedenti. Ripetere questo passaggio per convalidare la configurazione per gli altri pod che verranno creati nel passaggio successivo.

Creare due pod aggiuntivi, pod1 nello stesso nodo e pod2 in un nodo diverso. Questi pod verranno utilizzati per verificare l'accesso alla rete all'interno di un singolo nodo e di tutti i nodi del cluster.

Convalidare il traffico di rete tra pod nel cluster

Ora è possibile verificare l'accesso alla rete tra i pod nello stesso nodo e i pod nel cluster.

Verificare che l'accesso alla rete tra pod nello stesso nodo funzioni. Ad esempio, il comando seguente verifica che pod0 possa raggiungere pod1 tramite il relativo indirizzo IP assegnato.

  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

Verificare che l'accesso alla rete tra pod in un nodo diverso funzioni. Ad esempio, il comando seguente verifica che pod0 possa raggiungere pod2 tramite il relativo indirizzo IP assegnato.

  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