Clusters à nœud unique sur vSphere (version d'évaluation technique)

Tanzu Kubernetes Grid (TKG) prend en charge les clusters à nœud unique. Les clusters à nœud unique sont des clusters de charge de travail sur lesquels les charges de travail hébergées s'exécutent parallèlement à l'infrastructure de plan de contrôle sur un hôte ESXi unique.

Pour réduire davantage l'encombrement d'un cluster à nœud unique, vous pouvez le créer à partir d'une version tiny de Tanzu Kubernetes (TKr), qui dispose d'un fichier OVA Photon ou Ubuntu Tiny pour son système d'exploitation de base. Ces clusters sont appelés clusters minimaux à nœud unique.

Les clusters à nœud unique sont des clusters de charge de travail basés sur une classe qui s'exécutent sur vSphere 8 et sont déployés par des clusters de gestion autonomes.

Remarque

Cette fonctionnalité est dans l'état Version d'évaluation technique non pris en charge. Reportez-vous à la section États des fonctionnalités TKG.

Les clusters à nœud unique ne sont pas compatibles avec NSX Advanced Load Balancer.

TKG ne prend pas en charge la mise à niveau des clusters exécutant des versions précédentes de la TKr tiny. Pour mettre à jour un cluster à nœud unique minimal vers la dernière version de TKr tiny, vous devez supprimer l'ancien cluster, puis en recréer un.

Les cas d'utilisation incluent les éléments suivants :

Clusters à nœud unique
- Environnements expérimentaux de développement et de test
Clusters à nœud unique minimaux
- Environnements d'hôtes limités en ressources, tels que les sites de cellules en périphérie lointaine et d'autres emplacements en périphérie

Conditions requises

Un compte vSphere 8
Un cluster de gestion autonome TKG exécutant TKG v2.2.x sur vSphere 8
Une machine de démarrage sur laquelle les éléments suivants sont installés, comme décrit dans la section Installer la CLI Tanzu et d'autres outils à utiliser avec des clusters de gestion autonomes :
- CLI Tanzu
- kubectl
- imgpkg
- (Facultatif) yq 4.11.2

Le paramètre single-node-clusters activé dans la CLI Tanzu :

tanzu config set features.cluster.single-node-clusters true

Créer un cluster à nœud unique

Pour créer un cluster de charge de travail à nœud unique sur vSphere qui utilise une version TKr Photon ou Ubuntu standard :

Créez un fichier de configuration plat pour le cluster de charge de travail, comme décrit dans la section Fichiers de configuration de vSphere avec un cluster de gestion autonome.
Exécutez tanzu cluster create avec l'indicateur --dry-run pour convertir le fichier de configuration plat en une spécification d'objet Cluster de style Kubernetes, comme décrit dans la section Créer une spécification d'objet.
Modifiez la spécification d'objet Cluster pour inclure les paramètres suivants :
- Sous topology.controlPlane :
```
replicas: 1
```
- Aucun bloc topology.workers ; s'il en existe un, supprimez-le.
- Sous topology.variables :
```
- name: controlPlaneTaint
  value: false
```
Exécutez tanzu cluster create avec la spécification d'objet Cluster modifiée, comme décrit dans la section Créer un cluster basé sur une classe à partir de la spécification d'objet.

Créer un cluster à nœud unique minimal

Pour créer un cluster de charge de travail à nœud unique sur vSphere qui utilise une version tiny de Tanzu Kubernetes (TKr) afin de réduire l'encombrement :

Corrigez la définition ClusterClass de vSphere pour empêcher le cluster de gestion d'utiliser les versions tiny de Tanzu Kubernetes lorsqu'il crée des clusters standard qui ne sont pas à nœud unique :
```
kubectl annotate --overwrite clusterclass tkg-vsphere-default-v1.0.0 run.tanzu.vmware.com/resolve-tkr='!tkr.tanzu.vmware.com/tiny'
```

Installez la version tiny de Tanzu Kubernetes dans le cluster de gestion :

Définissez le contexte de kubectl sur votre cluster de gestion :
```
kubectl config use-context MY-MGMT-CLUSTER-admin@MY-MGMT-CLUSTER
```
Où MY-MGMT-CLUSTER est le nom de votre cluster de gestion.
Créez le fichier de définition ConfigMap tiny-tkr-cm.yaml pour la version tiny de Tanzu Kubernetes avec le code suivant :
```
apiVersion: v1
data:
  tkrVersions: '["v1.25.7+vmware.1-tiny.2-tkg.1"]'
kind: ConfigMap
metadata:
  name: tkg-compatibility-versions-v1.25.7---vmware.1-tiny.2-tkg.1
  namespace: tkg-system
  labels:
    run.tanzu.vmware.com/additional-compatible-tkrs: ""
```
Pour les versions autres que TKG v2.2.0, remplacez les versions de Kubernetes v1.25.7 ici et ci-dessous : TKr v1.25.7+vmware.1-tiny.2-tkg.1, OVA v1.25.7 Tiny OVA et nom ConfigMap, ainsi que d'autres chaînes modifiées de la même manière avec la version de Kubernetes appropriée.
Appliquez la TKr ConfigMap :
```
kubectl apply -f tiny-tkr-cm.yaml
```

Téléchargez le manifeste et les métadonnées du module TKr dans un répertoire /tmp/ :

imgpkg pull -b projects.registry.vmware.com/tkg/tkr-repository-vsphere-edge:v1.25.7_vmware.1-tiny.2-tkg.1 -o /tmp/tkr-repository-vsphere-edge

Dans le manifeste du module TKr, modifiez le paramètre metadata.namespace sur "tkg-system" de l'une des manières suivantes :
- Exécutez la commande yq suivante :
```
yq  -i e '.metadata.namespace = "tkg-system"' /tmp/tkr-repository-vsphere-edge/packages/tkr-vsphere-edge.tanzu.vmware.com/1.25.7+vmware.1-tiny.2-tkg.1.yml
```
- Modifiez le manifeste pour ajouter le paramètre namespace: "tkg-system" sous metadata :
```
metadata:
  [...]
  namespace: "tkg-system"
```

Appliquez le manifeste TKr :

kubectl apply -f /tmp/tkr-repository-vsphere-edge/packages/tkr-vsphere-edge.tanzu.vmware.com/1.25.7+vmware.1-tiny.2-tkg.1.yml

Après quelques minutes, exécutez kubectl get pour vérifier que la TKr tiny, le modèle de démarrage de cluster et les objets d'image du système d'exploitation ont tous été créés. Par exemple :

kubectl get tkr,cbt,osimage -A | grep -i tiny

Le résultat doit ressembler à ceci :

v1.25.7---vmware.1-tiny.2-tkg.1   v1.25.7+vmware.1-tiny.2-tkg.1   True    True         16m
tkg-system   v1.25.7---vmware.1-tiny.2-tkg.1   antrea.tanzu.vmware.com.1.9.0+vmware.1-tkg.1-advanced        vsphere-csi.tanzu.vmware.com.2.7.1+vmware.2-tkg.1        vsphere-cpi.tanzu.vmware.com.1.25.1+vmware.2-tkg.1        kapp-controller.tanzu.vmware.com.0.41.7+vmware.1-tkg.1
v1.25.7---vmware.1-tiny.2-  1.b3                       v1.25.7+vmware.1-tiny.2   ubuntu    2004         amd64   ova                 16m
v1.25.7---vmware.1-tiny.2-tkg.1-ac20b3                       v1.25.7+vmware.1-tiny.2   photon    3            amd64   ova                 16m

Préparer le fichier OVA :
1. Accédez à la page de téléchargements de Tanzu Kubernetes Grid et connectez-vous à Customer Connect.
2. Dans la ligne VMware Tanzu Kubernetes Grid, cliquez sur Accéder aux téléchargements (Go to Downloads).
3. Sélectionnez la version 2.x et cliquez sur VMware Tanzu Kubernetes Grid > ACCÉDER AUX TÉLÉCHARGEMENTS (GO TO DOWNLOADS).
4. Sous Fichiers OVA TKG Tiny (version d'évaluation technique) (Tiny TKG OVAs [Technical Preview]), téléchargez le fichier OVA Tiny à utiliser pour votre cluster à nœud unique :
  - Fichier OVA Tiny Photon v3 Kubernetes v1.25.7 (version d'évaluation technique)
  - Fichier OVA Tiny Ubuntu 2004 Kubernetes v1.25.7 (version d'évaluation technique)
5. Importez le fichier OVA tiny dans votre environnement vSphere et convertissez-le en modèle de machine virtuelle, comme décrit dans la section Importer le modèle d'image de base dans vSphere.

Créez le cluster de charge de travail à nœud unique.

Remarque
Pour les clusters à nœud unique, la commande tanzu cluster create ne peut pas encore convertir les fichiers de configuration de cluster plats en spécifications d'objet de style Kubernetes, comme décrit dans Créer des clusters de charge de travail.

Définissez les variables d'environnement comme définies dans cet exemple :

export CLUSTER_NAME='workload-snc'
export CLUSTER_NAMESPACE='default'
export CLUSTER_CIDR='100.96.0.0/11'
export SERVICE_CIDR='100.64.0.0/13'
export VSPHERE_CONTROL_PLANE_ENDPOINT=10.185.11.134
export VSPHERE_SERVER=10.185.12.154
export VSPHERE_USERNAME='[email protected]'
export VSPHERE_PASSWORD=<encoded:QWRtaW4hMjM=>
export VSPHERE_DATACENTER='/dc0'
export VSPHERE_DATASTORE='/dc0/datastore/sharedVmfs-0'
export VSPHERE_FOLDER='/dc0/vm'
export VSPHERE_NETWORK='/dc0/network/VM Network'
export VSPHERE_RESOURCE_POOL='/dc0/host/cluster0/Resources'
export VSPHERE_SSH_AUTHORIZED_KEY=ssh-rsa AAAAB3[...]tyaw== [email protected]
export VSPHERE_TLS_THUMBPRINT=47:F5:83:8E:5D:36:[...]:72:5A:89:7D:29:E5:DA
export VSPHERE_CONTROL_PLANE_NUM_CPUS='4'
export VSPHERE_CONTROL_PLANE_MEM_MIB='4096'
export VSPHERE_CONTROL_PLANE_DISK_GIB='20'
export TKG_CUSTOM_IMAGE_REPOSITORY='projects.registry.vmware.com/tkg'
export OS_NAME='photon'
export TKG_CUSTOM_IMAGE_REPOSITORY_CA_CERTIFICATE="LS0tL[...]0tLQo="

Créez un manifeste vsphere-snc.yaml avec les spécifications d'objets Cluster et Secret faisant référence aux variables ci-dessus :

apiVersion: cluster.x-k8s.io/v1beta1
kind: Cluster
metadata:
  annotations:
    tkg.tanzu.vmware.com/cluster-controlplane-endpoint: ${VSPHERE_CONTROL_PLANE_ENDPOINT}
    run.tanzu.vmware.com/resolve-tkr: 'tkr.tanzu.vmware.com/tiny'
  labels:
    tkg.tanzu.vmware.com/cluster-name: ${CLUSTER_NAME}
  name: ${CLUSTER_NAME}
  namespace: ${CLUSTER_NAMESPACE}
spec:
  clusterNetwork:
    pods:
      cidrBlocks:
      - ${CLUSTER_CIDR}
    services:
      cidrBlocks:
      - ${SERVICE_CIDR}
  topology:
    class: tkg-vsphere-default-v1.0.0
    controlPlane:
      metadata:
        annotations:
          run.tanzu.vmware.com/resolve-os-image: image-type=ova,os-name=${OS_NAME}
      replicas: 1
    variables:
    - name: controlPlaneTaint
      value: false
    - name: auditLogging
      value:
        enabled: false
    - name: apiServerEndpoint
      value: ${VSPHERE_CONTROL_PLANE_ENDPOINT}
    - name: aviAPIServerHAProvider
      value: false
    - name: imageRepository
      value:
        host: ${TKG_CUSTOM_IMAGE_REPOSITORY}
    - name: trust
      value:
        additionalTrustedCAs:
        - data: ${TKG_CUSTOM_IMAGE_REPOSITORY_CA_CERTIFICATE}
          name: imageRepository
    - name: vcenter
      value:
        cloneMode: fullClone
        datacenter: ${VSPHERE_DATACENTER}
        datastore: ${VSPHERE_DATASTORE}
        folder: ${VSPHERE_FOLDER}
        network: ${VSPHERE_NETWORK}
        resourcePool: ${VSPHERE_RESOURCE_POOL}
        server: ${VSPHERE_SERVER}
        storagePolicyID: ""
        tlsThumbprint: ${VSPHERE_TLS_THUMBPRINT}
    - name: user
      value:
        sshAuthorizedKeys:
        - ${VSPHERE_SSH_AUTHORIZED_KEY}
    - name: controlPlane
      value:
        machine:
          diskGiB: ${VSPHERE_CONTROL_PLANE_DISK_GIB}
          memoryMiB: ${VSPHERE_CONTROL_PLANE_MEM_MIB}
          numCPUs: ${VSPHERE_CONTROL_PLANE_NUM_CPUS}
    version: v1.25.7+vmware.1-tiny.2
---
apiVersion: v1
kind: Secret
metadata:
  name: ${CLUSTER_NAME}
  namespace: ${CLUSTER_NAMESPACE}
stringData:
  password: ${VSPHERE_PASSWORD}
  username: ${VSPHERE_USERNAME}
EOF

Notez les points suivants :

Paramètre metadata.annotations pour run.tanzu.vmware.com/resolve-tkr
Paramètre topology.variables pour controlPlaneTaint
Il n'y a pas de bloc topology.workers, uniquement topology.controlPlane
Pour les versions antérieures de TKG, la valeur topology.version doit être v1.24.10+vmware.1-tiny.1 pour v2.1.1 et v1.24.9+vmware.1-tiny.2 pour v2.1.0.

(Facultatif) Pour configurer le cluster afin qu'il utilise Calico comme CNI, plutôt que la CNI Antrea par défaut, suivez les instructions pour les clusters à nœud unique dans la section CNI Calico pour les clusters de charge de travail superviseurs ou basés sur une classe à nœud unique.

Appliquez le manifeste d'objet Cluster :

tanzu cluster create -f vsphere-snc.yaml