Configurer des fichiers TrustStore ou KeyStore personnalisés pour les Jobs et les Routes

Configurez des fichiers TrustStore ou KeyStore personnalisés pour les tâches d'intégration de données (y compris Big Data), les services de données et les Routes pour authentifier leurs connexions aux systèmes externes.

Dans cet exemple, les Jobs d'intégration de données sont utilisés pour présenter la configuration. La même procédure s'applique aux Routes et services de données.

Avant de commencer

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.
Votre Dynamic Engine doit avoir été déployé. Si ce n'est pas le cas, exécutez cette commande pour le déployer :
```
helm install dynamic-engine -f <engine-id>-helm-values/<engine-id>-values.yaml oci://ghcr.io/talend/helm/dynamic-engine 
```
Ce déploiement est celui par défaut, car la personnalisation courante est nécessaire uniquement côté environnement du Dynamic Engine. Ainsi, aucune personnalisation n'a été configurée pour l'instance du Dynamic Engine.

Pourquoi et quand exécuter cette tâche

Lorsque vos Jobs ou Routes doivent se connecter à des systèmes externes nécessitant une authentification basée TLS, vous pouvez fournir un TrustStore personnalisé afin de valider le certificat du système externe, ou fournir un TrustStore et un KeyStore, si le système externe nécessite l'authentification par certificat client.

Remarque : Routes ou services de données :

Cette configuration s'applique uniquement aux connexions sortantes vers des systèmes externes. Elle n'active pas le protocole HTTPS pour les requêtes client entrantes vers les Routes ou services de données. Le TrustStore et KeyStore configurés ici sont utilisés lorsque les composants de vos Routes ou services de données jouent le rôle de clients TLS vers des systèmes externes et non pour exposer les composants eux-mêmes sur le protocole HTTPS.

Procédure

Sur la machine de Kubernetes, décompressez le fichier ZIP de déploiement Helm précédemment téléchargé.
Créez le fichier TrustStore ou KeyStore à utiliser par vos Jobs d'intégration de données.
Exemple
Par exemple, vos Jobs doivent se connecter à une base de données MySQL et ont besoin d'un fichier TrustStore personnel pour vérifier l'identité du serveur. Vous pouvez utiliser l'utilitaire keytool en ligne de commande pour générer des fichiers TrustStore et KeyStore. Le TrustStore utilisé par vos Jobs doit contenir l'autorité de certification (Certificate Authority) ayant signé le certificat du serveur MySQL, afin que votre environnement de Dynamic Engine en tant que client MySQL puisse valider l'identité du serveur.

Pour des instructions relatives à l'utilitaire keytool, consultez Keytool (en anglais). Pour des instructions concernant la configuration de la connexion MySQL au SSL, consultez la documentation MySQL.
Note InformationsRemarque : À propos du KeyStore et du TrustStore :
- KeyStore du serveur et TrustStore du client : Le KeyStore du serveur contient la clé privée et la chaîne de certification du serveur. Le TrustStore du client doit contenir le certificat signé du serveur (exporté depuis le KeyStore du serveur à l'aide de l'outil keytool -export) ou le certificat de l'autorité de certification ayant signé le certificat du serveur, afin que le client puisse valider l'identité du serveur.
  Lors de l'exécution, la couche TLS du client (Transport Layer Security) vérifie que le certificat du serveur est fiable. Pour ce faire, elle suit la chaîne de certification du serveur, via les éventuels certificats intermédiaires, jusqu'à trouver un certificat déjà indiqué comme fiable dans son TrustStore. Si la vérification échoue, la connexion sécurisée (handshake) est arrêtée. En d'autres termes, le client établit la connexion uniquement lorsque le certificat du serveur correspond à une entrée de son TrustStore.

Créez un fichier de valeurs personnalisées afin de fournir les fichiers TrustStore ou les fichiers TrustStore et KeyStore à l'environnement Dynamic Engine.

Exemple

Dans cet exemple, seul le fichier TrustStore est utilisé.

STORE_TYPE=truststore
STORE_FILE=${keystoreFolder}/job-truststore.pc12
STORE_PASSWORD=${jobTruststorePassword}
STORE_FILE_TYPE=$(keytool -list -keystore "$STORE_FILE" \
-storepass "$STORE_PASSWORD" 2>/dev/null | awk -F': ' '/Keystore type/{print $2}')
cat <<EOF > $DYNAMIC_ENGINE_ENVIRONMENT_ID-custom-$STORE_TYPE-values.yaml
configuration:
  $STORE_TYPE:
    enabled: true
    data: $(base64 -i $STORE_FILE | tr -d '\n')
    password: $STORE_PASSWORD
    type: $STORE_FILE_TYPE
EOF

Remplacez les valeurs des variables selon les besoins de votre environnement et vos identifiants.

Conseil : Dans certains cas, vos Jobs doivent fournir un fichier TrustStore (pour vérifier l'identité du système externe) et un fichier KeyStore (pour s'authentifier au système externe). Dans ces scénarios, créez un fichier de valeurs pour chaque TrustStore et KeyStore :

# Create the truststore values file
STORE_TYPE=truststore
STORE_FILE=${keystoreFolder}/job-truststore.pc12
STORE_PASSWORD=${jobTruststorePassword}
STORE_FILE_TYPE=$(keytool -list -keystore "$STORE_FILE" \
-storepass "$STORE_PASSWORD" 2>/dev/null | awk -F': ' '/Keystore type/{print $2}')
cat <<EOF > $DYNAMIC_ENGINE_ENVIRONMENT_ID-custom-$STORE_TYPE-values.yaml
configuration:
  $STORE_TYPE:
    enabled: true
    data: $(base64 -i $STORE_FILE | tr -d '\n')
    password: $STORE_PASSWORD
    type: $STORE_FILE_TYPE
EOF  

# Create the values file forkeystore
STORE_TYPE=keystore
STORE_FILE=${keystoreFolder}/job-keystore.jks
STORE_PASSWORD=${jobKeystorePassword}
STORE_FILE_TYPE=$(keytool -list -keystore "$STORE_FILE" \
-storepass "$STORE_PASSWORD" 2>/dev/null | awk -F': ' '/Keystore type/{print $2}')
cat <<EOF > $DYNAMIC_ENGINE_ENVIRONMENT_ID-custom-$STORE_TYPE-values.yaml
configuration:
  $STORE_TYPE:
    enabled: true
    data: $(base64 -i $STORE_FILE | tr -d '\n')
    password: $STORE_PASSWORD
    type: $STORE_FILE_TYPE
EOF

Installez ou mettez à niveau le chart d'environnement de Dynamic Engine avec le fichier de valeurs.

helm install dynamic-engine-environment-$DYNAMIC_ENGINE_ENVIRONMENT_ID -f $DYNAMIC_ENGINE_ENVIRONMENT_ID-values.yaml  \
 -f $DYNAMIC_ENGINE_ENVIRONMENT_ID-custom-truststore-values.yaml \
 oci://ghcr.io/talend/helm/dynamic-engine-environment \
 --version $DYNAMIC_ENGINE_VERSION

Comme expliqué précédemment, seul le fichier de valeurs du TrustStore est requis ici.

Pour les mises à niveau, utilisez helm upgrade au lieu de helm install.

Conseil : Lorsque les Jobs doivent fournir les fichiers TrustStore et KeyStore, exécutez cette commande pour appliquer les deux fichiers de valeurs en même temps :

helm install dynamic-engine-environment-$DYNAMIC_ENGINE_ENVIRONMENT_ID -f $DYNAMIC_ENGINE_ENVIRONMENT_ID-values.yaml  \
 -f $DYNAMIC_ENGINE_ENVIRONMENT_ID-custom-truststore-values.yaml \
  -f $DYNAMIC_ENGINE_ENVIRONMENT_ID-custom-keystore-values.yaml \
 oci://ghcr.io/talend/helm/dynamic-engine-environment \
 --version $DYNAMIC_ENGINE_VERSION

Vérifiez que l'environnement de Dynamic Engine est prêt et que les Jobs d'intégration de données peuvent accéder aux fichiers TrustStore et KeyStore personnalisés.
- Vérifiez que tous les services d'environnement sont en cours d'exécution.
- Démarrez un Job d'intégration de données et confirmez qu'il se connecte bien aux systèmes externes requis, à l'aide des fichiers TrustStore et KeyStore personnalisés.

Résultats

Lorsque le déploiement est terminé, vos Jobs d'intégration de données dans l'environnement de Dynamic Engine utilisent le TrustStore ou le KeyStore spécifié pour une connectivité sécurisée.

Conseil : Pour connecter des Jobs d'intégration de données de manière sécurisée aux systèmes externes, configurez simplement le fichier TrustStore ou KeyStore au niveau de l'environnement. Ce fichier contient la chaîne de certification permettant l'authentification TLS vers les systèmes externes. Vous n'avez pas besoin de changer quoi que ce soit dans les Jobs ou le Studio.

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