Bereitstellen von Dynamic Engine in einem GKE-Cluster

Installieren Sie eine Dynamic Engine-Instanz und ihre Umgebung in einem GKE-Cluster (Google Kubernetes Engine) mithilfe von Helm-Diagrammen und GKE-spezifischen Speicherklassen.

Anmerkung: Dieses Verfahren gilt nur für GKE-Cluster mit einer festen Anzahl Knoten, unterstützt aber nicht den GKE-Autopilot-Modus.

Vorbereitungen

Grundlegendes Wissen über GKE ist erforderlich. Installieren Sie die Google Cloud CLI auf Ihrem Rechner, um mit Google Cloud und GKE zu interagieren. Weitere Informationen finden Sie hier:
- Google Cloud SDK-Installationshandbuch zum Installieren und Initialisieren der Google Cloud CLI.
- GKE-Zugriff für kubectl zum Installieren des Plug-Ins gke-gcloud-auth-plugin und Authentifizieren bei Ihrem Google Cloud-Projekt.
  InformationshinweisTipp: Führen Sie zum Installieren des Plug-Ins Folgendes aus:
```
gcloud components install gke-gcloud-auth-plugin
```
  Um sich bei Google Cloud zu authentifizieren und das Projekt einzurichten, führen Sie Folgendes aus:
```
gcloud auth login
gcloud config set project $PROJECT_ID
```
  Ersetzen Sie $PROJECT_ID durch Ihre Google Cloud-Projekt-ID.
Erstellen oder aktualisieren Sie den GKE-Cluster mit der für Dynamic Engine erforderlichen Konfiguration:
```
gcloud container clusters create $CLUSTER_NAME \
  --addons=GcpFilestoreCsiDriver \
  --cluster-version=1.30 \
  --location=us-central1-a \
  --machine-type=e2-standard-4 \
  --num-nodes=3
```
Wenn der Cluster bereits vorhanden ist, aktualisieren Sie ihn wie folgt:
```
gcloud container clusters update $CLUSTER_NAME \
  --update-addons=GcpFilestoreCsiDriver=ENABLED \
  --region=$REGION
```
Diese Befehle aktivieren das Add-On GcpFilestoreCsiDriver, geben einen Rechnertyp mit mindestens 4 vCPUs an (z. B. e2-standard-4 oder höher) und stellen eine feste Anzahl Knoten bereit.
Konfigurieren Sie Zugriff auf Ihren GKE-Cluster, indem Sie Ihre lokalen kubeconfig-Anmeldeinformationen generieren und einrichten. Weitere Informationen finden Sie unter GKE-Zugriff für kubectl.
InformationshinweisTipp: Führen Sie folgenden Befehl aus, um Ihre kubeconfig zu generieren:
```
gcloud container clusters get-credentials $CLUSTER_NAME --region $REGION --project $PROJECT_ID
```
Überprüfen Sie dann den aktuellen Kubernetes-Kontext:
```
kubectl config get-contexts
```
Wenn der aktuelle Kontext nicht der gewünschte ist, legen Sie ihn fest:
```
kubectl config use-context $GKE_CONTEXT
```
$GKE_CONTEXT ist in der Regel gke_$PROJECT_ID_$REGION_$CLUSTER_NAME. Ersetzen Sie die Variablen durch Ihre tatsächlichen Werte.
Vergewissern Sie sich, dass alle System-Pods in Ihrem GKE-Cluster ausgeführt werden. Sie können den folgenden Befehl ausführen, um den Status zu prüfen:
```
kubectl get pods -n kube-system
```
Die Google Cloud Platform-Konsole stellt ebenfalls die Statusinformationen bereit.
Die benutzerdefinierten Ressourcendefinitionen dynamic-engine-crd müssen mit dem Helm-Diagramm oci://ghcr.io/talend/helm/dynamic-engine-crd installiert worden sein. Führen Sie andernfalls die folgenden Befehle für die Installation aus:
1. Suchen Sie die zu verwendende Diagrammversion:
  - Führen Sie den folgenden Helm-Befehl aus:
    helm show chart oci://ghcr.io/talend/helm/dynamic-engine-crd --version <engine_version>
  - Sehen Sie die Version direkt über Talend Management Console ein oder suchen Sie im Dynamic Engine Änderungs-Log nach der in Ihrer Dynamic Engine-Version enthaltenen Diagrammversion.
  - Verwenden Sie einen API-Aufruf an den Dynamic Engine-Versionsendpunkt.
2. Führen Sie den folgenden Befehl aus, um das Helm-Diagramm einer bestimmten Version zu installieren:
```
helm install dynamic-engine-crd oci://ghcr.io/talend/helm/dynamic-engine-crd --version <helm_chart_version>
```
  Ersetzen Sie <helm_chart_version> durch die Diagrammversion, die von Ihrer Dynamic Engine-Version unterstützt wird.
  Wenn die Version nicht angegeben wird, installieren Sie die neueste verfügbare dynamic-engine-crd-Diagrammversion.

Warum und wann dieser Vorgang ausgeführt wird

In diesem Verfahren wird beschrieben, wie Sie eine benutzerdefinierte Dynamic Engine-Umgebung in einem GKE-Cluster mithilfe von Helm-Diagrammen implementieren. Es umfasst Schritte zum Konfigurieren der GKE-Speicherklassen und zum Anpassen der Helm-Wertedateien für GKE-Kompatibilität.

Prozedur

Konfigurieren Sie eine GKE-Speicherklasse ReadWriteMany GKE für Dynamic Engine.
Erstellen Sie eine Speicherklasse ReadWriteMany eigens für Dynamic Engine und verwenden Sie in späteren Schritten deren Namen als defaultStorageClassName. Beispiel:
```
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: dyn-engine
provisioner: filestore.csi.storage.gke.io
volumeBindingMode: WaitForFirstConsumer
allowVolumeExpansion: true
reclaimPolicy: Delete
parameters:
  tier: <type-of-storage-class>
  network: <name-of-configured-network>
```
In diesem Beispiel wird eine Speicherklasse namens dyn-engine erstellt, für die der Bereitsteller filestore.csi.storage.gke.io konfiguriert ist, um Persistenz-Volumes eines bestimmten Typs in einem bestimmten Netzwerk zu erstellen, die in den Feldern tier und network angegeben sind.
- Die folgenden Typen sind für das Feld tier verfügbar:
  - standard-rwx
  - premium-rwx
  - enterprise-rwx
  - enterprise-multishare-rwx
  - zonal-rwx
  Weitere Einzelheiten finden Sie unter Filestore-Mehrfachfreigaben für GKE.
- Der Name des Netzwerks ist derjenige, den Sie für Ihren GKE-Cluster konfiguriert haben. Wenn Sie keinen Netzwerknamen für den Cluster angegeben haben, verwenden Sie default.
  Wenn Sie das Feld network aus der aktuellen Speicherklassenkonfiguration entfernen, wird automatisch der Name default verwendet.
Implementieren Sie die Dynamic Engine-Instanz und ihre Umgebungen.
1. Führen Sie den folgenden Befehl aus, um die Engine-Instanz bereitzustellen:
```
helm upgrade --install dynamic-engine \
  -f $DYNAMIC_ENGINE_ID-helm-values/$DYNAMIC_ENGINE_ID-values.yaml \
  oci://ghcr.io/talend/helm/dynamic-engine
```
  Dies ist eine Standardimplementierung. Mit diesem Befehl wird die Dynamic Engine-Instanz aktualisiert oder installiert, je nachdem, ob sie zuvor bereits implementiert war. Ersetzen Sie $DYNAMIC_ENGINE_ID durch die Dynamic Engine-ID, beispielsweise c-m-sjufu4qy.
2. Erstellen Sie eine benutzerdefinierte Helm-Wertedatei für die Umgebung.
  Example
```
cat <<EOF > $DYNAMIC_ENGINE_ENVIRONMENT_ID-custom-gke-values.yaml
---
configuration:
  persistence:
    defaultStorageClassName: dyn-engine
EOF
```
  In diesem Beispiel wird dyn-engine, die zuvor von Ihnen erstellte Speicherklasse, als Name für defaultStorageClassName festgelegt. Ändern Sie entsprechend in die verwendete Dynamic Engine-spezifische Speicherklasse.
3. Implementieren Sie die Helm-Diagramme für die Dynamic Engine-Umgebung.
```
helm upgrade --install dynamic-engine-environment-$DYNAMIC_ENGINE_ENVIRONMENT_ID \
  -f $DYNAMIC_ENGINE_ENVIRONMENT_ID-values.yaml  \
  -f $DYNAMIC_ENGINE_ENVIRONMENT_ID-custom-gke-values.yaml \
  oci://ghcr.io/talend/helm/dynamic-engine-environment \
  --version $DYNAMIC_ENGINE_VERSION
```
  Mit diesem Befehl wird die Dynamic Engine-Umgebung aktualisiert oder installiert, je nachdem, ob sie zuvor bereits implementiert war.

Ergebnisse

Nach Abschluss sind die Dynamic Engine-Umgebungsdienste auf Ihrem GKE-Cluster installiert und stehen für die Ausführung von Tasks oder Plänen bereit.

In Talend Management Console ändert sich der Status dieser Umgebung zu Ready (Bereit), was bestätigt, dass sie zum Ausführen von Tasks oder Plänen bereit ist.

Wenn die Implementierung fehlschlägt oder die Dynamic Engine-Dienste getrennt werden, ändert sich der Status in Not ready (Nicht bereit).

Nächste Maßnahme

Nach der erfolgreichen Implementierung können Sie Aufgaben zur Dynamic Engine-Umgebung genau wie bei Standard-Engines hinzufügen. Detaillierte Informationen finden Sie unter Hinzufügen einer Jobtask in einer Dynamic Engine-Umgebung.

Hat diese Seite Ihnen geholfen?

Wenn Sie ein Problem mit dieser Seite oder ihrem Inhalt feststellen, sei es ein Tippfehler, ein ausgelassener Schritt oder ein technischer Fehler, informieren Sie uns bitte!

Geben Sie hier Ihr Feedback ab