Cluster a nodo singolo in vSphere (Anteprima tecnica)

Tanzu Kubernetes Grid (TKG) supporta cluster a nodo singolo. I cluster a nodo singolo sono cluster del carico di lavoro in cui i carichi di lavoro ospitati vengono eseguiti insieme all'infrastruttura del piano di controllo in un singolo host ESXi.

Per ridurre ulteriormente il footprint di un cluster a singolo nodo, è possibile crearlo da una tiny versione di Tanzu Kubernetes (TKr), che ha come sistema operativo di base un OVA di Photon o Ubuntu Tiny. Tali cluster sono chiamati cluster minimi a nodo singolo.

I cluster a nodo singolo sono cluster del carico di lavoro basati sulla classe eseguiti in vSphere 8 e vengono distribuiti da cluster di gestione autonomi.

Nota
Lo stato di questa funzionalità è Anteprima tecnica e non è quindi supportata. Vedere Stati delle funzionalità di TKG.

I casi d'uso includono:

Cluster con un nodo singolo
- Ambienti di sviluppo e test sperimentali
Cluster a nodo singolo minimi
- Ambienti host con vincoli di risorse come i siti delle celle edge e altre posizioni dell'Edge

Prerequisiti

Un account vSphere 8
Un cluster di gestione autonomo di TKG che esegue TKG v2.1.x in vSphere 8
Una macchina di bootstrap con installato quanto segue, come descritto in Installazione della CLI di Tanzu e altri strumenti per l'utilizzo con i cluster di gestione autonomi:
- CLI di Tanzu
- kubectl
- imgpkg
- (Facoltativo) yq v4.11.2

Impostazione single-node-clusters abilitata nella CLI di Tanzu:

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

Creare un cluster a nodo singolo

Per creare un cluster del carico di lavoro con un nodo singolo in vSphere che utilizza un Photon standard o Ubuntu TKr:

Creare un file di configurazione piatto per il cluster del carico di lavoro come descritto in vSphere con i file di configurazione del cluster di gestione autonomo.
Eseguire tanzu cluster create con il flag --dry-run per convertire il file di configurazione piatto in una specifica di oggetto del Cluster di tipo Kubernetes, come descritto in Creazione di una specifica di oggetto.
Modificare la specifica dell'oggetto Cluster in modo che includa le seguenti impostazioni:
- In topology.controlPlane
```
replicas: 1
```
- Nessun blocco topology.workers; se presente, eliminarlo.
- In topology.variables
```
- name: controlPlaneTaint
  value: false
```
Eseguire tanzu cluster create con la specifica dell'oggetto Cluster modificata come descritto in Creazione di un cluster basato sulla classe dalla specifica di un oggetto.

Creazione di un cluster minimo a nodo singolo

Per creare un cluster di carichi di lavoro a singolo nodo su vSphere che utilizza una tiny versione di Tanzu Kubernetes release (TKr) per ridurre al minimo la footprint:

Applicare una patch alla definizione di vSphere ClusterClass per impedire al cluster di gestione di utilizzare tiny TKrs quando crea cluster standard non a singolo nodo:
```
kubectl annotate --overwrite clusterclass tkg-vsphere-default-v1.0.0 run.tanzu.vmware.com/resolve-tkr='!tkr.tanzu.vmware.com/tiny'
```

Installare tiny TKr nel cluster di gestione:

Impostare il contesto di kubectl sul cluster di gestione:
```
kubectl config use-context MY-MGMT-CLUSTER-admin@MY-MGMT-CLUSTER
```
In cui MY-MGMT-CLUSTER è il nome del cluster di gestione.
Creare il file di definizione ConfigMap tiny-tkr-cm.yaml per tiny TKr con il codice seguente:
```
apiVersion: v1
data:
  tkrVersions: '["v1.24.10+vmware.1-tiny.1-tkg.1"]'
kind: ConfigMap
metadata:
  name: tkg-compatibility-versions-v1.24.10---vmware.1-tiny.1-tkg.1
  namespace: tkg-system
  labels:
    run.tanzu.vmware.com/additional-compatible-tkrs: ""
```
Per TKG v2.1.0 sostituire le versioni Kubernetes v1.24.9 qui e di seguito: TKr v1.24.9+vmware.1-tiny.2-tkg.1, OVA v1.24.9 Tiny OVA e il nome della ConfigMap e altre stringhe sono state modificate in modo simile.
Applicare la ConfigMap TKr:
```
kubectl apply -f tiny-tkr-cm.yaml
```

Scaricare il manifesto e i metadati del pacchetto TKr in una directory /tmp/:

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

Nel manifesto del pacchetto TKr modificare l'impostazione metadata.namespace in "tkg-system" in uno dei seguenti modi:
- Eseguire il comando yq seguente:
```
yq  -i e '.metadata.namespace = "tkg-system"' /tmp/tkr-repository-vsphere-edge/packages/tkr-vsphere-edge.tanzu.vmware.com/1.24.10+vmware.1-tiny.1-tkg.1.yml
```
- Modificare il manifesto per aggiungere l'impostazione namespace: "tkg-system" in metadata:
```
metadata:
  [...]
  namespace: "tkg-system"
```

Applicare il manifesto TKr:

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

Dopo alcuni minuti, eseguire kubectl get per verificare che i tiny oggetti TKr, il modello di bootstrap del cluster e l'immagine del sistema operativo siano stati creati. Ad esempio:

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

L'output deve avere un aspetto simile al seguente:

v1.24.10---vmware.1-tiny.1-tkg.1   v1.24.10+vmware.1-tiny.1-tkg.1   True    True         16m
tkg-system   v1.24.10---vmware.1-tiny.1-tkg.1   antrea.tanzu.vmware.com.1.7.2+vmware.1-tkg.1-advanced        vsphere-csi.tanzu.vmware.com.2.6.2+vmware.2-tkg.1        vsphere-cpi.tanzu.vmware.com.1.24.3+vmware.1-tkg.1        kapp-controller.tanzu.vmware.com.0.41.5+vmware.1-tkg.1
v1.24.10---vmware.1-tiny.1-  1.b3                       v1.24.10+vmware.1-tiny.1   ubuntu    2004         amd64   ova                 16m
v1.24.10---vmware.1-tiny.1-tkg.1-ac20b3                       v1.24.10+vmware.1-tiny.1   photon    3            amd64   ova                 16m

Preparare l'OVA:
1. Passare alla pagina Download di Tanzu Kubernetes Grid e accedere a Customer Connect.
2. Nella riga VMware Tanzu Kubernetes Grid fare clic su Vai ai download (Go to Downloads).
3. Selezionare la versione 2.x e fare clic su VMware Tanzu Kubernetes Grid > VAI AI DOWNLOAD (GO TO DOWNLOADS).
4. In piccolo OVA TKG (anteprima tecnica) (Tiny TKG OVAs (Technical Preview)), scaricare il file OVA di piccole dimensioni da utilizzare per il cluster con un nodo singolo:
  - Photon v3 Kubernetes v1.24.10 Tiny OVA (anteprima tecnica)
  - Ubuntu 2004 Kubernetes v1.24.10 Tiny OVA (anteprima tecnica)
5. Importare il file OVA di piccole dimensioni nell'ambiente vSphere e convertirlo in Importazione del modello dell'immagine di base in vSphere.

Creare il cluster del carico di lavoro a nodo singolo.

Nota
Per i cluster a nodo singolo tanzu cluster create non è ancora in grado di convertire i file di configurazione dei cluster piatti in specifiche di oggetti di tipo Kubernetes, come descritto in Creazione di cluster di carichi di lavoro.

Impostare le variabili di ambiente come impostate in questo esempio:

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="

Creare un manifesto vsphere-snc.yaml con Cluster e specifiche di oggetti Secret che fanno riferimento alle variabili precedenti:

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.24.10+vmware.1-tiny.1
---
apiVersion: v1
kind: Secret
metadata:
  name: ${CLUSTER_NAME}
  namespace: ${CLUSTER_NAMESPACE}
stringData:
  password: ${VSPHERE_PASSWORD}
  username: ${VSPHERE_USERNAME}
EOF

Si tenga presente quanto segue:

Impostazione metadata.annotations per run.tanzu.vmware.com/resolve-tkr
Impostazione topology.variables per controlPlaneTaint
Non è presente alcun blocco topology.workers ma solo topology.controlPlane
Per TKG v2.1.0, topology.version deve essere v1.24.9+vmware.1-tiny.2

(Facoltativo) Per configurare il cluster in modo che usi Calico come CNI invece della CNI predefinita di Antrea, seguire le istruzioni per i cluster a nodo singolo in CNI Calico per supervisore o cluster di carichi di lavoro basati su classi a nodo singolo.
Applicare il manifesto dell'oggetto Cluster:
```
tanzu cluster create -f vsphere-snc.yaml
```
(Solo TKG v2.1.0, facoltativo) Per eseguire il provisioning dei volumi persistenti (PV) per il cluster, creare un oggetto vSphere StorageClass.

Nota
Questi passaggi non sono necessari con TKG v2.1.1 e versioni successive.
1. Creare un manifesto vspherestorageclass.yaml:
```
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  annotations:
    storageclass.kubernetes.io/is-default-class: "true"
  name: default
provisioner: csi.vsphere.vmware.com
reclaimPolicy: Delete
volumeBindingMode: Immediate
allowVolumeExpansion: true
```
2. Applicare il manifesto StorageClass:
```
kubectl apply -f vspherestorageclass.yaml --kubeconfig=KUBECONFIG
```
  Dove KUBECONFIG è kubeconfig per il cluster a nodo singolo.