Injecter des variables d'environnement depuis le Secret Kubernetes

Injectez des données sensibles (mots de passe, clés API, jetons) du Secret Kubernetes comme variables d'environnement dans vos tâches de Jobs (Intégration de données, Big Data et services de données) et de Routes pour qu'elles puissent accéder simplement et de manière sécurisée aux identifiants.

Important : Vos données sensibles sont stockées dans votre Secret Kubernetes et gérées par la politique de sécurité de votre entreprise. Le modèle de personnalisation de Dynamic Engine fournit uniquement l'accès à ces informations aux tâches déployées dans vos environnements de Dynamic Engine. Qlik ne gère pas vos données sensibles.

Avant de commencer

Pour plus d'informations, consultez Prérequis et considérations à prendre en compte.

Procédure

Créez un fichier de ressources Secret Kubernetes avec des données sensibles.
Créez un fichier nommé external-secret-as-env.yaml contenant vos données sensibles :
```
cat <<EOF > external-secret-as-env.yaml
apiVersion: v1
kind: Secret
metadata:
  name: external-secret-as-env
  namespace: qlik-processing-env-$DYNAMIC_ENGINE_ENVIRONMENT_ID
type: Opaque
stringData:
  DATABASE_PASSWORD: "mySecurePassword123"
  API_KEY: "your_key"
  AUTH_TOKEN: "Bearer your_token"
EOF
```
Remplacez les identifiants d'exemple par vos données réelles et sensibles.

Le Dynamic Engine ne gère pas vos données sensibles. Pour plus d'informations concernant l'encodage des données dans le Secret Kubernetes, consultez Secret (en anglais) dans la documentation Kubernetes.
Créez un fichier de valeurs Helm référençant le Secret.

Créez un fichier nommé, par exemple, secret-values.yaml. Choisissez l'approche correspondant à votre cas d'utilisation :
- Injectez toutes les clés Secret comme variables d'environnement à l'aide de additionalSpec.envFrom (injection de masse) :
```
configuration:
  jobDeployment:
    additionalSpec:
      enabled: true
      envFrom:
        - secretRef:
            name: external-secret-as-env
```
  Cette approche charge toutes les clés de Secret comme variables d'environnement : DATABASE_PASSWORD, API_KEY et AUTH_TOKEN.
- Injectez, de manière sélective, les clés de Secret spécifiques à l'aide de additionalSpec.env (contrôle granulaire fin) :
```
configuration:
  jobDeployment:
    additionalSpec:
      enabled: true
      env:
        - name: DATABASE_PASSWORD
          valueFrom:
            secretKeyRef:
              name: external-secret-as-env
              key: DATABASE_PASSWORD
        - name: API_KEY
          valueFrom:
            secretKeyRef:
              name: external-secret-as-env
              key: API_KEY
```
  Cette approche injecte, de manière sélective, les seules clés dont vous avez besoin, laissant les autres clés de Secret inaccessibles pour le pod.
Déployez ou mettez à niveau votre environnement de Dynamic Engine pour créer l'espace de noms requis.
```
helm upgrade --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_VERSION} par la version de votre environnement.

Cette commande crée l'environnement de Dynamic Engine et son espace de noms associé qlik-processing-env-$DYNAMIC_ENGINE_ENVIRONMENT_ID.
Créez le Secret dans l'espace de nom de votre environnement de Dynamic Engine.
```
kubectl apply -f external-secret-as-env.yaml
```
Cette commande crée la ressource Secret dans votre cluster Kubernetes. La ressource Secret est disponible pour utilisation par tous les pods de l'espace de noms de l'environnement.
Mettez à niveau votre environnement de Dynamic Engine avec la configuration de Secret.
```
helm upgrade 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 \
  -f secret-values.yaml
```
Remplacez ${DYNAMIC_ENGINE_VERSION} par la version de votre environnement.

Cette commande applique votre configuration Secret à l'environnement de Dynamic Engine. Les données sensibles sont à présent disponibles en tant que variables d'environnement dans toutes les tâches déployées.
Vérifiez que les variables d'environnement de Secret sont disponibles dans les pods en cours d'exécution.
Vérifiez que le Secret est bien injecté à l'aide de la commande correspondant à la méthode d'injection :

Si vous avez utilisé une injection de masse avec envFrom :
```
kubectl get pod -n qlik-processing-env-$DYNAMIC_ENGINE_ENVIRONMENT_ID <pod-name> \
  -o jsonpath='{.spec.containers[*].envFrom}'
```
La sortie attendue confirme la référence du Secret :
```
[{"secretRef":{"name":"external-secret-as-env"}}]
```
Si vous avez utilisé une injection spécifique avec env :
```
kubectl get pod -n qlik-processing-env-$DYNAMIC_ENGINE_ENVIRONMENT_ID <pod-name> \
  -o jsonpath='{.spec.containers[*].env}'
```
La sortie attendue affiche vos clés Secret sélectionnées montées comme variables d'environnement.

Résultats

Les tâches de votre environnement de Dynamic Engine ont à présent un accès sécurisé aux identifiants sensibles provenant du Secret Kubernetes. Vous pouvez effectuer une rotation des identifiants en mettant à jour le Secret. Les modifications sont appliquées comme suit :

Les tâches d'Intégration de données, y compris Big Data, sont des tâches ponctuelles. Les valeurs mises à jour sont lues lorsque l'exécution de la tâche suivante démarre.
Les Routes et les services de données sont des tâches AlwaysOn. Ces tâches ne chargent pas automatiquement les modifications apportées au Secret. Mettez à jour la tâche dans Talend Management Console pour déclencher un nouveau déploiement dans votre 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