Clústeres de nodo único en vSphere (vista previa técnica)

Tanzu Kubernetes Grid (TKG) admite clústeres de nodo único. Los clústeres de nodo único son clústeres de carga de trabajo en los que las cargas de trabajo alojadas se ejecutan junto con la infraestructura del plano de control en un único host ESXi.

Para minimizar aún más el espacio de un clúster de nodo único, puede crearlo a partir de una versión tiny de Tanzu Kubernetes (TKr), que tiene un OVA muy pequeño de Ubuntu o Photon para su sistema operativo base. Estos clústeres se denominan clústeres de un solo único mínimos.

Los clústeres de nodo único son clústeres de carga de trabajo basados en clases que se ejecutan en vSphere 8 y se implementan mediante clústeres de administración independientes.

Nota
Esta función se encuentra en el estado de vista previa técnica no compatible; consulte Estados de funciones de TKG.

Los casos prácticos incluyen:

Clústeres de nodo único
- Entornos experimentales de prueba y desarrollo
Clústeres de nodo único mínimos
- Entornos de host con limitaciones de recursos, como sitios de celdas de Edge y otras ubicaciones de Edge

Requisitos previos

Una cuenta de vSphere 8
Un clúster de administración independiente de TKG que ejecuta TKG v2.1.x en vSphere 8
Una máquina de arranque con lo siguiente instalado, como se describe en Instalar CLI de Tanzu y otras herramientas para su uso con clústeres de administración independientes:
- CLI de Tanzu
- kubectl
- imgpkg
- (Opcional) yq v4.11.2

La opción single-node-clusters habilitada en CLI de Tanzu:

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

Crear un clúster de nodo único

Para crear un clúster de carga de trabajo de nodo único en vSphere que utilice un TKr de Ubuntu o Photon estándar:

Cree un archivo de configuración plano para el clúster de carga de trabajo como se describe en Archivos de configuración de vSphere con clúster de administración independiente.
Ejecute tanzu cluster create con la marca --dry-run para convertir el archivo de configuración plano en una especificación de objeto Cluster estilo Kubernetes, como se describe en Crear una especificación de objeto.
Edite la especificación del objeto Cluster para incluir la siguiente configuración:
- En topology.controlPlane
```
replicas: 1
```
- Sin bloqueo de topology.workers; si está presente, elimínelo.
- En topology.variables
```
- name: controlPlaneTaint
  value: false
```
Ejecute tanzu cluster create con la especificación del objeto Cluster modificada como se describe en Crear un clúster basado en clases desde la especificación del objeto.

Crear un clúster de nodo único mínimo

Para crear un clúster de carga de trabajo de nodo único en vSphere que utilice una versión tiny de Tanzu Kubernetes (TKr) para minimizar su espacio:

Aplique una revisión en la definición de ClusterClass de vSphere para evitar que el clúster de administración utilice TKr tiny cuando cree clústeres estándar que no sean de nodo único:
```
kubectl annotate --overwrite clusterclass tkg-vsphere-default-v1.0.0 run.tanzu.vmware.com/resolve-tkr='!tkr.tanzu.vmware.com/tiny'
```

Instalar TKr tiny en el clúster de administración:

Establezca el contexto de kubectl en su clúster de administración:
```
kubectl config use-context MY-MGMT-CLUSTER-admin@MY-MGMT-CLUSTER
```
Donde MY-MGMT-CLUSTER es el nombre del clúster de administración.
Cree el archivo de definición ConfigMap tiny-tkr-cm.yaml para el TKr tiny con el siguiente código:
```
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: ""
```
Para TKG v2.1.0, sustituya las versiones de Kubernetes v1.24.9 aquí y a continuación: TKr v1.24.9+vmware.1-tiny.2-tkg.1, OVA v1.24.9 Tiny OVA y el nombre ConfigMap y otras cadenas cambiaron de forma similar.
Aplique la TKr ConfigMap:
```
kubectl apply -f tiny-tkr-cm.yaml
```

Descargue el manifiesto del paquete de TKr y los metadatos en un directorio /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

En el manifiesto del paquete de TKr, cambie la opción metadata.namespace a "tkg-system" de una de las siguientes maneras:
- Ejecute el siguiente comando yq:
```
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
```
- Edite el manifiesto para agregar el ajuste namespace: "tkg-system" en metadata:
```
metadata:
  [...]
  namespace: "tkg-system"
```

Aplique el manifiesto de 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

Después de unos minutos, ejecute kubectl get para comprobar que se crearon TKr tiny, la plantilla de arranque del clúster y los objetos de imagen del sistema operativo. Por ejemplo:

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

El resultado debe ser similar al siguiente:

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

Prepare el archivo OVA:
1. Vaya a la página de descargas de Tanzu Kubernetes Grid e inicie sesión en Customer Connect.
2. En la fila VMware Tanzu Kubernetes Grid, haga clic en Ir a descargas (Go to Downloads).
3. Seleccione la versión 2.x y haga clic en VMware Tanzu Kubernetes Grid > IR A DESCARGAS.
4. En Archivos OVA de TKG Tiny (vista previa técnica) , descargue el archivo OVA Tiny que se utilizará en el clúster de nodo único:
  - Archivo OVA de Photon v3 Kubernetes v1.24.10 Tiny (vista previa técnica)
  - Archivo OVA de Ubuntu 2004 Kubernetes v1.24.10 (vista previa técnica)
5. Importe el archivo OVA Tiny en el entorno de vSphere y conviértalo en una plantilla de máquina virtual como se describe en Importar la plantilla de imagen base en vSphere.

Cree el clúster de carga de trabajo de nodo único.

Nota
Para los clústeres de nodo único, tanzu cluster create aún no puede convertir los archivos de configuración de clúster plano en especificaciones de objetos tipo Kubernetes, como se describe en Crear clústeres de carga de trabajo:.

Establezca las variables de entorno como se establece en este ejemplo:

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

Cree un manifiesto vsphere-snc.yaml con especificaciones del objeto Cluster y Secret que hagan referencia a las variables anteriores:

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

Tenga en cuenta lo siguiente:

El ajuste metadata.annotations para run.tanzu.vmware.com/resolve-tkr
El ajuste topology.variables para controlPlaneTaint
No hay ningún bloqueo topology.workers, solo topology.controlPlane
Para TKG v2.1.0, topology.version debe ser v1.24.9+vmware.1-tiny.2

(Opcional) Para configurar el clúster de modo que use Calico como CNI en lugar de la CNI de Antrea predeterminada, siga las instrucciones para clústeres de nodo único en CNI de Calico para clústeres de carga de trabajo basados en clases de nodo único o supervisor.

Aplique el manifiesto de objeto Cluster:

tanzu cluster create -f vsphere-snc.yaml

(Solo la versión 2.1.0 de TKG, opcional) Para aprovisionar volúmenes persistentes (PV) para el clúster, cree un objeto StorageClass de vSphere.

Nota
Estos pasos no son necesarios con TKG v2.1.1 y versiones posteriores.
1. Cree un manifiesto 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. Aplique el manifiesto StorageClass:
```
kubectl apply -f vspherestorageclass.yaml --kubeconfig=KUBECONFIG
```
  Donde KUBECONFIG es el kubeconfig para el clúster de nodo único.