Déployer Multus avec Whereabouts sur des clusters de charge de travail

Whereabouts est un plug-in CNI de gestion des adresses IP (IPAM, IP Address Management) qui attribue dynamiquement des adresses IP à des espaces sur tous les nœuds d'un cluster. Par rapport aux autres plug-ins IPAM, tels que host-local qui attribue uniquement des adresses IP à des espaces sur le même nœud, whereabouts attribue des adresses IP à l'échelle du cluster.

Dans cette rubrique, vous allez découvrir comment attacher une interface réseau secondaire à un espace avec l'adresse IP attribuée dans la plage que vous avez spécifiée à l'aide de whereabouts. Par exemple, vous aurez Antrea ou Calico comme CNI principale, une interface secondaire créée à l'aide de macvlan ou ipvlan, et Whereabouts comme CNI IPAM.

Conditions requises

Une machine de démarrage avec les éléments suivants installés :
- Le module Multus CNI pour la prise en charge de plusieurs réseaux. Pour plus d'informations, reportez-vous à Déployer Multus sur des clusters de charge de travail.
- CLI Tanzu, plug-ins de la CLI Tanzu et kubectl, comme décrit dans la section Installer la CLI Tanzu et la CLI Kubernetes à utiliser avec des clusters de gestion autonomes.
- yq v4.5 ou version ultérieure.
Un cluster de gestion Tanzu Kubernetes Grid et un cluster de charge de travail s'exécutant sur vSphere, Amazon Web Services (AWS) ou Azure.
- Whereabouts nécessite des nœuds worker de cluster de charge de travail d'une taille large ou extra-large, comme décrit dans la section Tailles de nœud prédéfinies.

Installer le module Whereabouts

Pour installer le module Whereabouts sur un cluster de charge de travail et configurer le cluster pour l'utiliser :

Configurez et installez Whereabouts.
1. Créez un fichier de configuration qui récupère les paramètres de Whereabouts.
```
tanzu package available get whereabouts.tanzu.vmware.com/PACKAGE-VERSION --default-values-file-output FILE-PATH
```
  Remarque
  l'espace de noms sur lequel déployer les composants whereabouts doit être kube-system. Toute installation d'espace de noms personnalisée échouera.
  
  Où PACKAGE-VERSION est la version du module Whereabouts que souhaitez installer et FILE-PATH est l'emplacement dans lequel vous souhaitez enregistrer le fichier de configuration (par exemple, whereabouts-data-values.yaml). La commande ci-dessus créera un fichier de configuration nommé whereabouts-data-values.yaml contenant les valeurs par défaut.
2. Exécutez la commande tanzu package available list pour répertorier les versions disponibles du module Whereabouts, par exemple :
```
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
```
  Remarque
  assurez-vous que votre registre d'images personnalisé est accessible si vous travaillez dans un environnement restreint au réseau.
3. Exécutez la commande tanzu package available get avec --values-schema pour voir quelles valeurs de champ peuvent être définies :
```
tanzu package available get whereabouts.tanzu.vmware.com/VERSION --values-schema -o FORMAT
```
  Où : - VERSION est une version répertoriée dans la sortie tanzu package available list - FORMAT est yaml ou json
4. Remplissez le fichier de configuration whereabouts-data-values.yaml avec les valeurs de champ souhaitées.
Supprimez tous les commentaires du fichier whereabouts-data-values.yaml :
```
yq -i eval '... comments=""' whereabouts-cni-default-values.yaml
```
Exécutez tanzu package install pour installer le module.
```
tanzu package install whereabouts --package whereabouts.tanzu.vmware.com --version AVAILABLE-PACKAGE-VERSION --values-file whereabouts-data-values.yaml --namespace TARGET-NAMESPACE
```
Où :
- TARGET-NAMESPACE est l'espace de noms dans lequel vous souhaitez installer le module Whereabouts. Par exemple, l'espace de noms my-packages ou tanzu-cli-managed-packages.
  - Si l'indicateur --namespace n'est pas spécifié, la CLI Tanzu installe le module dans l'espace de noms default.
  - L'espace de noms spécifié doit déjà exister, par exemple en exécutant kubectl create namespace my-packages.
- AVAILABLE-PACKAGE-VERSION est la version que vous avez récupérée ci-dessus, par exemple 0.6.1+vmware.2-tkg.1.
Exécutez tanzu package installed get pour vérifier l'état du module installé.
```
tanzu package installed get whereabouts -o <json|yaml|table>
```

Créez une définition de ressource personnalisée (CRD, Custom Resource Definition) pour NetworkAttachmentDefinition qui définit la configuration CNI pour les interfaces réseau à utiliser par Multus CNI avec Whereabouts comme type d'IPAM.

Créez une spécification CRD. Par exemple, ce multus-cni-crd.yaml spécifie un NetworkAttachmentDefinition nommé macvlan-conf qui configure un CNI macvlan et avec whereabouts comme type d'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"
        }
      } ]
    }'

Créez la ressource (par exemple, kubectl create -f multus-cni-crd.yaml).

Créez un espace avec l'annotation k8s.v1.cni.cncf.io/networks pour spécifier le réseau supplémentaire à ajouter.

Créez la spécification de l'espace (par exemple, 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

Créez l'espace. Par exemple, kubectl create -f my-multi-cni-crd.yaml crée l'espace pod0.
Une fois l'espace créé, il disposera de trois interfaces réseau :
- lo, l'interface de bouclage ;
- eth0, le réseau d'espace par défaut géré par la CNI Antrea ou Calico ;
- net1, la nouvelle interface créée via l'annotation k8s.v1.cni.cncf.io/networks: macvlan-conf.
Remarque
le réseau par défaut obtient le nom eth0 et les interfaces d'espace réseau supplémentaires obtiennent le nom net1, net2 et ainsi de suite.

Exécutez kubectl describe pod sur pod0 et vérifiez que l'annotation k8s.v1.cni.cncf.io/network-status répertorie toutes les interfaces réseau.

Par exemple :

$ 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

Exécutez ensuite kubectl exec sample-pod -- ip a show dev net1 pour vérifier si l'interface cible est active et en cours d'exécution avec l'adresse IP répertoriée dans les annotations ci-dessus. Répétez cette étape pour valider la configuration des autres espaces que vous allez créer à l'étape suivante.

Créez deux espaces supplémentaires, pod1 sur le même nœud et pod2 sur un nœud différent. Vous utiliserez ces espaces pour vérifier l'accès réseau dans un nœud unique et les nœuds du cluster.

Valider le trafic réseau entre les espaces du cluster

Vous pouvez désormais vérifier l'accès réseau entre les espaces dans le même nœud et les espaces du cluster.

Vérifiez que l'accès réseau entre des espaces sur le même nœud fonctionne. Par exemple, la commande suivante vérifie que pod0 peut atteindre pod1 via son adresse IP attribuée.

  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

Vérifiez que l'accès réseau entre des espaces sur différents nœuds fonctionne. Par exemple, la commande suivante vérifie que pod0 peut atteindre pod2 via son adresse IP attribuée.

  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