Einzelknotencluster auf vSphere (Tech Preview)

Tanzu Kubernetes Grid (TKG) unterstützt Einzelknotencluster. Einzelknotencluster sind Arbeitslastcluster, auf denen gehostete Arbeitslasten neben der Steuerungsebenen-Infrastruktur auf einem einzelnen ESXi-Host ausgeführt werden.

Um die Stellfläche eines Einzelknotenclusters weiter zu minimieren, können Sie ihn aus einem tiny Tanzu Kubernetes-Release (TKr) erstellen, das über eine Photon oder Ubuntu Tiny OVA für sein Basisbetriebssystem verfügt. Solche Cluster werden minimale Einzelknotencluster genannt.

Einzelknotencluster sind klassenbasierte Arbeitslastcluster, die auf vSphere 8 ausgeführt werden und von eigenständigen Verwaltungsclustern bereitgestellt werden.

Hinweis

Diese Funktion befindet sich im nicht unterstützten Tech Preview-Zustand. Weitere Informationen finden Sie unter TKG-Funktionsstatus.

Einzelknotencluster sind nicht mit NSX Advanced Load Balancer kompatibel.

TKG bietet keine Unterstützung für das Upgrade von Clustern, auf denen frühere Versionen des tiny TKr ausgeführt werden. Zum Aktualisieren eines kleinen Einzelknoten-Clusters auf die aktuelle tiny TKr-Version müssen Sie den alten Cluster löschen und einen neuen erstellen.

Anwendungsbeispiele:

Einzelknotencluster
- Experimentelle Entwicklungs- und Testumgebungen
Minimale Einzelknotencluster
- Ressourcenbeschränkte Hostumgebungen wie weit entfernte Edge-Zellen-Sites und andere Edge-Standorte

Voraussetzungen

Ein vSphere 8-Konto
Ein eigenständiger TKG-Verwaltungscluster, auf dem TKG v2.2.x auf vSphere 8 ausgeführt wird
Eine Bootstrap-Maschine, auf der Folgendes installiert ist, wie unter Installieren der Tanzu CLI und anderer Tools für die Verwendung mit eigenständigen Verwaltungsclustern beschrieben:
- Tanzu CLI
- kubectl
- imgpkg
- (Optional) yq v4.11.2
Die Einstellung single-node-clusters in der Tanzu CLI aktiviert:
```
tanzu config set features.cluster.single-node-clusters true
```

Erstellen eines Einzelknotenclusters

So erstellen Sie einen Arbeitslastcluster mit einem Knoten auf vSphere, der eine Standard-Photon oder -Ubuntu-TKr verwendet:

Erstellen Sie eine flache Konfigurationsdatei für den Arbeitslastcluster, wie unter vSphere mit Konfigurationsdateien für eigenständige Verwaltungscluster beschrieben.
Führen Sie tanzu cluster create mit dem Flag --dry-run aus, um die flache Konfigurationsdatei in eine Cluster-Objektspezifikation im Kubernetes-Stil zu konvertieren, wie unter Erstellen einer Objektspezifikation beschrieben.
Bearbeiten Sie die Cluster-Objektspezifikation, um die folgenden Einstellungen einzubeziehen:
- Unter topology.controlPlane:
```
replicas: 1
```
- Kein topology.workers-Block, Falls vorhanden, löschen.
- Unter topology.variables:
```
- name: controlPlaneTaint
  value: false
```
Führen Sie tanzu cluster create mit der geänderten Cluster-Objektspezifikation aus, wie unter Erstellen eines klassenbasierten Clusters anhand der Objektspezifikation beschrieben.

Erstellen eines minimalen Einzelknotenclusters

So erstellen Sie einen Arbeitslastcluster mit einem Knoten auf vSphere, der ein tiny Tanzu Kubernetes-Release (TKr) verwendet, um seine Stellfläche zu minimieren:

Patchen Sie die vSphere-ClusterClass-Definition, um zu verhindern, dass der Verwaltungscluster tiny TKrs verwendet, wenn er standardmäßige Cluster, d. h. keine Einzelknotencluster, erstellt:
```
kubectl annotate --overwrite clusterclass tkg-vsphere-default-v1.0.0 run.tanzu.vmware.com/resolve-tkr='!tkr.tanzu.vmware.com/tiny'
```

Installieren Sie das tiny TKr im Verwaltungscluster:

Legen Sie den Kontext von kubectl auf Ihren Verwaltungscluster fest:
```
kubectl config use-context MY-MGMT-CLUSTER-admin@MY-MGMT-CLUSTER
```
Dabei ist MY-MGMT-CLUSTER der Name Ihres Verwaltungsclusters.
Erstellen Sie die ConfigMap-Definitionsdatei tiny-tkr-cm.yaml für das tiny TKr mit dem folgenden Code:
```
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: ""
```
Ersetzen Sie an dieser Stelle und weiter unten für andere Versionen als TKG v2.2.0 die Kubernetes-Versionen v1.25.7: TKr v1.25.7+vmware.1-tiny.2-tkg.1, OVA v1.25.7 Tiny OVA und ConfigMap-Name sowie andere Zeichenfolgen wurden ebenfalls mit der entsprechenden Kubernetes-Version geändert.
Wenden Sie das TKr ConfigMap an:
```
kubectl apply -f tiny-tkr-cm.yaml
```

Laden Sie das TKr-Paketmanifest und die Metadaten in das Verzeichnis /tmp/ herunter:

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

Ändern Sie im TKr-Paketmanifest die Einstellung metadata.namespace in "tkg-system" auf eine der beiden folgenden Arten:
- Führen Sie den folgenden yq-Befehl aus:
```
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
```
- Bearbeiten Sie das Manifest, um die Einstellung namespace: "tkg-system" unter metadata hinzuzufügen:
```
metadata:
  [...]
  namespace: "tkg-system"
```

Wenden Sie das TKr-Manifest an:

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

Führen Sie nach einigen Minuten kubectl get aus, um sicherzustellen, dass das tiny TKr, die Cluster-Bootstrap-Vorlage und Betriebssystem-Image-Objekte erstellt wurden. Beispiel:

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

Die Ausgabe sollte etwa wie folgt aussehen:

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

Bereiten Sie die OVA vor:
1. Navigieren Sie zur Download-Seite von Tanzu Kubernetes Grid und melden Sie sich bei Customer Connect an.
2. Klicken Sie in der Zeile VMware Tanzu Kubernetes Grid auf Zu den Downloads (Go to Downloads).
3. Wählen Sie die Version 2.x aus und klicken Sie auf VMware Tanzu Kubernetes Grid > ZU DEN DOWNLOADS (GO TO DOWNLOADS).
4. Laden Sie unter Tiny TKG OVAs (Tech Preview) die Tiny OVA herunter, die für Ihren Einzelknotencluster verwendet werden soll:
  - Photon v3 Kubernetes v1.25.7 Tiny OVA (Tech Preview)
  - Ubuntu 2004 Kubernetes v1.25.7 Tiny OVA (Tech Preview)
5. Importieren Sie die Tiny OVA in Ihre vSphere-Umgebung und konvertieren Sie sie in eine VM-Vorlage, wie unter Importieren der Basisimage-Vorlage in vSphere beschrieben.

Erstellen Sie den Arbeitslastcluster mit einem Knoten.

Hinweis
Bei Einzelknotenclustern kann tanzu cluster create noch keine flachen Clusterkonfigurationsdateien in Objektspezifikationen im Kubernetes-Stil konvertieren, wie unter Erstellen von Arbeitslastclustern beschrieben.

Legen Sie Umgebungsvariablen wie in diesem Beispiel fest:

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

Erstellen Sie ein Manifest vsphere-snc.yaml mit Cluster- und Secret-Objektspezifikationen, die auf die oben genannten Variablen verweisen:

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

Beachten Sie Folgendes:

Die Einstellung metadata.annotations für run.tanzu.vmware.com/resolve-tkr
Die Einstellung topology.variables für controlPlaneTaint
Es ist kein topology.workers-Block vorhanden, nur topology.controlPlane
In früheren Versionen von TKG sollte die topology.version auf v1.24.10+vmware.1-tiny.1 für v2.1.1 und auf v1.24.9+vmware.1-tiny.2 für v2.1.0 lauten.

(Optional) Um den Cluster für die Verwendung von Calico als CNI anstelle der standardmäßigen Antrea-CNI zu konfigurieren, befolgen Sie die Anweisungen für Einzelknotencluster in Calico-CNI für Supervisor- oder klassenbasierte Arbeitslastcluster mit einem Knoten.

Wenden Sie das Cluster-Objektmanifest an:

tanzu cluster create -f vsphere-snc.yaml