# Implémenter Dynamic Engine sur un minikube pour des tests pratiques

Installez et configurez des Dynamic Engines sur un cluster minikube pour un test pratique avant de les déployer dans votre entreprise.

Prérequis :

* Docker et minikube doivent être installés.

* Assurez-vous que le démon Docker est en cours d'exécution.

* L'outil minikube a bien été installé et configuré pour utiliser une version de Kubernetes supportée par Dynamic Engine. Pour plus d'informations concernant les versions supportées de Kubernetes, consultez [Spécifications de Kubernetes](https://help.qlik.com/talend/fr-FR/dynamic-engine-configuration-guide/Cloud/prerequisits-to-use-dynamic-engines#anchor-2).

  Pour plus d'informations, consultez [minikube installation](https://minikube.sigs.k8s.io/docs/start/) (en anglais).

* Les outils suivants d'invite de commande sont installés : kubectl et helm. La version de Helm doit être 3.17.2 ou supérieure.

## Ajouter un Dynamic Engine et son environnement pour test sur un minikube

### Procédure

1. Dans Talend Management Console, allez à la page Processing (Traitement), sélectionnez l'onglet Dynamic Engines et ajoutez un Dynamic Engine.

   Cela crée l'entité logique de votre Dynamic Engine. Fermez la boîte de dialogue de déploiement sans effectuer de téléchargement. Vous téléchargerez le fichier ZIP de déploiement après avoir attribué un environnement de Dynamic Engine.
2. Toujours dans Talend Management Console, créez une entité logique d'environnement de Dynamic Engine. Pour plus d'informations, consultez [Ajouter un environnement de Dynamic Engine](https://help.qlik.com/talend/fr-FR/dynamic-engine-configuration-guide/Cloud/set-up-dynamic-engine-on-registered-kubernetes-cluster#anchor-3).
3. Allez à la page Processing (Traitement) et ouvrez l'onglet Dynamic Engines.
4. Cliquez-droit sur le Dynamic Engine précédemment créé dans Talend Management Console.
5. Cliquez sur Assign environments (Attribuer des environnements) pour ouvrir la page d'attribution des environnements.
6. Sélectionnez l'environnement créé et cliquez sur Assign (Attribuer).
7. Laissez le type et la version de déploiement Helm par défaut, puis cliquez sur Download (Télécharger) pour obtenir le fichier ZIP de déploiement.

   Ce fichier ZIP contient un fichier de valeurs Helm pour le moteur et un pour chaque environnement attribué, nommé en fonction de leur ID respectif. Par exemple, pour un Dynamic Engine d'ID c-m-sjufu4qy et un environnement d'ID 67f7d562ffd7c3525a902542, le ZIP contient :
   * c-m-sjufu4qy-helm-values/c-m-sjufu4qy-values.yaml
   * c-m-sjufu4qy-helm-values/67f7d562ffd7c3525a902542-values.yaml
8. Cliquez sur Close (Fermer).

### Résultats

Le Dynamic Engine et son environnement sont créés en tant qu'entités logiques dans le Talend Management Console, l'environnement est attribué au moteur et le fichier ZIP de déploiement est téléchargé et prêt à être appliqué sur votre cluster.

## Déployer Dynamic Engine et son environnement sur minikube

### Procédure

1. Exécutez la commande suivante dans votre terminal pour démarrer une instance de minikube :
   ```
   minikube start -p QlikDE --cpus=4 --memory=8000
   ```

   Cette commande démarre une instance nommée QlikDE et alloue 4 processeurs et 8 Go de mémoire. Vous pouvez nommer l'instance comme vous le souhaitez.
2. Dézippez le fichier téléchargé et installez le chart Helm dynamic-engine-crd :
   ```
   helm install dynamic-engine-crd \
     oci://ghcr.io/talend/helm/dynamic-engine-crd \
     --version ${DYNAMIC_ENGINE_VERSION}
   ```

   Remplacez <helm\_chart\_version> par la version du chart supportée par votre version du Dynamic Engine.
3. Déployez l'instance du moteur :
   ```
   helm install dynamic-engine-$DYNAMIC_ENGINE_ID \
     oci://ghcr.io/talend/helm/dynamic-engine \
     --version ${DYNAMIC_ENGINE_VERSION} -f $DYNAMIC_ENGINE_ID-values.yaml
   ```

   Remplacez $DYNAMIC\_ENGINE\_ID par l'ID de Dynamic Engine, par exemple, c-m-sjufu4qy.
4. Vérifiez que le moteur a bien été déployé en exécutant :
   ```
   kubectl get de -A
   ```

   Vous devriez voir des informations semblables à celles-ci :
   ```
   NAME                                     VERSION   STATUS    LAST UPDATE
   qlik-dynamic-engine-$DYNAMIC_ENGINE_ID   0.22.0    RUNNING   2m
   ```
5. Déployez l'environnement à l'aide de Helm en exécutant :
   ```
   helm install dynamic-engine-environment-$DYNAMIC_ENGINE_ENVIRONMENT_ID \
     oci://ghcr.io/talend/helm/dynamic-engine-environment \
     --version ${DYNAMIC_ENGINE_VERSION} -f $DYNAMIC_ENGINE_ENVIRONMENT_ID-values.yaml
   ```

   Remplacez $DYNAMIC\_ENGINE\_ENVIRONMENT\_ID par l'ID d'environnement de Dynamic Engine, par exemple, 67f7d562ffd7c3525a902542.

   Le processus complet prend trois à quatre minutes, en fonction de la capacité de votre machine minikube. Utilisez les commandes suivantes pour vérifier la progression :
   * ```
     kubectl wait --for=condition=Ready pod -A -l 'app.qlik.com/part-of' --timeout=10m
     ```

     Cette commande vérifie que tous les pods associés aux environnements sont bien en cours d'exécution. Une fois l'opération terminée, un message similaire à celui-ci est retourné :

     ```
     pod/dynamic-engine-operator-68478645bb-wn7x9 condition met
     pod/dpe-di-job-deployer-86dc4ddb7f-7v9lz condition met
     pod/dpe-di-job-restore-orphans-6d4f8968d4-g75dk condition met
     pod/dpe-engine-config-manager-6bc9fb44-4z6nh condition met
     pod/dpe-job-controller-7c74467648-p7k8c condition met
     pod/dpe-log-collector-7fc4fb664d-scdf9 condition met
     ```

     Les pods s'exécutant dans d'autres espaces de noms sont également listés dans le message. Par exemple, dynamic-engine-operator-68478645bb-wn7x9.

   * ```
     kubectl get namespaces
     ```

     Cette commande liste tous les espaces de noms, vous permettant d'identifier l'espace de noms de l'environnement de Dynamic Engine, quui regroupe tous les services associés, comme qlik-processing-env-66f2c0bb3e063d3518122259.

   * ```
     kubectl get pods --namespace qlik-processing-env-66f2c0bb3e063d3518122259
     ```

     Cette commande liste tous les services s'exécutant dans l'environnement. Lorsque tous les status indiquent Running (En cours d'exécution), l'installation de votre environnement de Dynamic Engine est terminée. Dans Talend Management Console, le statut de cet environnement devient Ready (Prêt), indiquant qu'il est prêt à exécuter des tâches ou des plans.

### Résultats

Pour exécuter des tâches dans l'environnement de ce Dynamic Engine, consultez [Gérer les tâches de Job dans un environnement de Dynamic Engine dans Talend Management Console](https://help.qlik.com/talend/fr-FR/dynamic-engine-configuration-guide/Cloud/managing-tasks-in-dynamic-engine-environments-in-tmc).

### Que faire ensuite

Pour supprimer l'instance du minikube, exécutez :

```
minikube delete --profile QlikDE
```

Cela supprime l'instance de minikube et tous les fichiers associés.

* Pour plus d'informations sur les logs Dynamic Engine, consultez [Désactiver le transfert des logs et métriques après déploiement ou mise à niveau](https://help.qlik.com/talend/fr-FR/dynamic-engine-configuration-guide/Cloud/deploy-environment-with-disabled-logs-metrics).
* Pour les limitations connues des Dynamic Engines, consultez [Limitations connues](https://help.qlik.com/talend/fr-FR/dynamic-engine-configuration-guide/Cloud/known-limitations-dynamic-engine).
* Pour un guide complet concernant les Dynamic Engines, consultez le [Guide de configuration de Dynamic Engine](https://help.qlik.com/talend/fr-FR/dynamic-engine-configuration-guide/Cloud/management-console-dynamic-engine-architecture). Avec ce guide, vous apprenez à créer et déployer des Dynamic Engines et leurs environnements de production.