Déployer un Dynamic Engine dans un cluster GKE

Installez une instance de Dynamic Engine et son environnement dans un cluster Google Kubernetes Engine (GKE) utilisant les charts Helm et les classes de stockage spécifiques à GKE.

Remarque : Cette procédure s'applique uniquement aux clusters GKE avec un nombre fixe de nœuds, mais ne supporte pas le mode Autopilot de GKE.

Avant de commencer

Des connaissances de base de GKE sont requises. Installez l'interface en ligne de commande Google Cloud CLI sur votre machine afin d'interagir avec Google Cloud et GKE. Pour plus d'informations, consultez :
- Google Cloud SDK installation guide (en anglais) pour l'installation et l'initialisation de Google Cloud CLI.
- GKE access for kubectl (en anglais) pour l'installation du plug-in gke-gcloud-auth-plugin et l'authentification à votre projet Google Cloud.
  Note InformationsConseil : Pour installer le plug-in, exécutez :
```
gcloud components install gke-gcloud-auth-plugin
```
  Pour vous authentifier avec Google Cloud et configurer votre projet, exécutez :
```
gcloud auth login
gcloud config set project $PROJECT_ID
```
  Remplacez $PROJECT_ID par l'ID de votre projet Google Cloud.
Créez ou mettez à jour votre cluster GKE avec la configuration requise par Dynamic Engine :
```
gcloud container clusters create $CLUSTER_NAME \
  --addons=GcpFilestoreCsiDriver \
  --cluster-version=1.30 \
  --location=us-central1-a \
  --machine-type=e2-standard-4 \
  --num-nodes=3
```
Si votre cluster existe déjà, mettez-le à jour comme suit :
```
gcloud container clusters update $CLUSTER_NAME \
  --update-addons=GcpFilestoreCsiDriver=ENABLED \
  --region=$REGION
```
Ces commandes activent l'add-on GcpFilestoreCsiDriver, spécifient un type de machine avec au moins quatre vCPUs (par exemple, e2-standard-4 ou supérieur) et fournissent un nombre fixe de nœuds.
Configurez l'accès à votre cluster GKE en générant et configurant vos identifiants kubeconfig locaux. Pour plus d'informations, consultez Installer kubectl et configurer l'accès au cluster.
Note InformationsConseil : Pour générer votre kubeconfig, exécutez :
```
gcloud container clusters get-credentials $CLUSTER_NAME --region $REGION --project $PROJECT_ID
```
Vérifiez ensuite votre contexte Kubernetes actif :
```
kubectl config get-contexts
```
Si le contexte actif n'est pas celui souhaité, effectuez la configuration suivante :
```
kubectl config use-context $GKE_CONTEXT
```
$GKE_CONTEXT est généralement gke_$PROJECT_ID_$REGION_$CLUSTER_NAME. Remplacez les variables par vos valeurs réelles.
Assurez-vous que tous les pods système s'exécutent dans votre cluster GKE. Vous pouvez exécuter cette commande pour vérifier le statut :
```
kubectl get pods -n kube-system
```
La console Google Cloud Platform fournit également des informations de statut.
Les définitions des ressources personnalisées dynamic-engine-crd doivent avoir été installées à l'aide du chart Helm oci://ghcr.io/talend/helm/dynamic-engine-crd. Si ce n'est pas le cas, exécutez les commandes suivantes pour l'installation :
1. Trouvez la version du chart à utiliser :
  - Exécutez la commande Helm suivante :
    helm show chart oci://ghcr.io/talend/helm/dynamic-engine-crd --version <engine_version>
  - Visualisez la version directement depuis Talend Management Console ou consultez le Dynamic Engine journal de modification de la version du graphique dans votre version de Dynamic Engine.
  - Utilisez un appel d'API pour l'endpoint de version de Dynamic Engine (en anglais).
2. Exécutez la commande suivante pour installer le chart Helm dans une version donnée :
```
helm install dynamic-engine-crd oci://ghcr.io/talend/helm/dynamic-engine-crd --version <helm_chart_version>
```
  Remplacez <helm_chart_version> par la version du chart supportée par votre version du Dynamic Engine.
  Si vous ne spécifiez pas la version, vous installez la dernière version disponible du chart dynamic-engine-crd.

Pourquoi et quand exécuter cette tâche

Cette procédure décrit comment déployer un environnement de Dynamic Engine dans un cluster GKE à l'aide de charts Helm. Elle comprend des étapes de configuration de classes de stockage GKE et de personnalisation de fichiers de valeurs Helm pour compatibilité avec GKE.

Procédure

Configurez une classe de stockage GKE ReadWriteMany pour le Dynamic Engine.
Créez une classe de stockage ReadWriteMany dédiée au Dynamic Engine, et, dans les étapes suivantes, utilisez son nom comme étant defaultStorageClassName. Par exemple :
```
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: <filestore-tier>
  network: <name-of-configured-network>
```
Cet exemple crée une classe de stockage nommée dyn-engine, pour laquelle le provisionneur filestore.csi.storage.gke.io est configuré pour créer des volumes de persistance d'un type donné sur un réseau donné, respectivement spécifiés dans les champs tier et network.
- Pour les types de Filestore GKE que vous pouvez utiliser dans ce champ tier, consultez GKE tier (en anglais).
- Le nom du réseau est celui configuré pour votre cluster GKE. Si vous n'avez pas spécifié de nom de réseau pour votre cluster, utilisez default.
  Si vous supprimez le champ network de la configuration de classe de stockage courante, le nom default est automatiquement utilisé.
Note InformationsConseil : Une classe de stockage dédiée à Dynamic Engine est recommandée, mais il est toujours possible d'utiliser les classes de stockage par défaut fournies par GKE, selon la politique de votre entreprise. Pour la liste des classes de stockage par défaut, consultez Automatically installed GKE storage class (en anglais).
Déployez l'instance de Dynamic Engine et son environnement.
1. Exécutez cette commande pour déployer l'instance du moteur :
```
helm upgrade --install dynamic-engine \
  -f $DYNAMIC_ENGINE_ID-helm-values/$DYNAMIC_ENGINE_ID-values.yaml \
  oci://ghcr.io/talend/helm/dynamic-engine
```
  C'est un déploiement par défaut. Cette commande met à niveau ou installe l'instance de Dynamic Engine, en fonction du déploiement existant. Remplacez $DYNAMIC_ENGINE_ID par l'ID de Dynamic Engine, par exemple, c-m-sjufu4qy.
2. Créez un fichier de valeurs Helm personnalisées pour l'environnement.
  Exemple
```
cat <<EOF > $DYNAMIC_ENGINE_ENVIRONMENT_ID-custom-gke-values.yaml
---
configuration:
  persistence:
    defaultStorageClassName: dyn-engine
EOF
```
  Cet exemple configure dyn-engine, la classe de stockage précédemment créée, comme nom pour defaultStorageClassName. Modifiez le nom en fonction de la classe de stockage spécifique au Dynamic Engine que vous utilisez.
3. Déployez les charts Helm pour l'environnement de Dynamic Engine.
```
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
```
  Cette commande met à niveau ou installe l'environnement de Dynamic Engine, en fonction du déploiement existant.

Résultats

Une fois terminée, les services d'environnement de Dynamic Engine sont installés dans votre cluster GKE et sont prêts à exécuter des tâches ou des plans.

Dans Talend Management Console, le statut de cet environnement devient Ready (Prêt), confirmant qu'il est prêt à exécuter des tâches ou des plans.

Si le déploiement échoue ou si les services du Dynamic Engine sont dissociés, le statut devient Not ready (Pas prêt).

Que faire ensuite

Après un déploiement réussi, vous pouvez ajouter des tâches à l'environnement de Dynamic Engine comme pour les moteurs standards. Pour plus de détails, consultez Ajouter une tâche de Job dans un environnement de Dynamic Engine.

Cette page vous a-t-elle aidé ?

Si vous rencontrez des problèmes sur cette page ou dans son contenu – une faute de frappe, une étape manquante ou une erreur technique – faites-le-nous savoir.

Laissez vos commentaires ici