Secrets Kubernetes - Comment créer, utiliser et accéder aux secrets

Présentation

La plupart des applications déployées via Kubernetes nécessitent un accès à des bases de données, des services et d'autres ressources situées en externe. Le moyen le plus simple de gérer les informations de connexion nécessaires pour accéder à ces ressources consiste à utiliser les secrets Kubernetes. Les secrets aident à organiser et à distribuer des informations sensibles dans un cluster.

Dans ce didacticiel, vous apprendrez ce que sont les secrets Kubernetes et comment les créer et les utiliser dans votre cluster.

Prérequis

• Un cluster Kubernetes (à des fins de test, vous pouvez le créer avec minikube)
• L'outil de ligne de commande Kubernetes kubectl

Que sont les secrets Kubernetes ?

Un secret Kubernetes est un objet stockant des données sensibles telles que des noms d'utilisateur, des mots de passe, des jetons et des clés. Les secrets sont créés par le système lors de l'installation d'une application ou par les utilisateurs chaque fois qu'ils ont besoin de stocker des informations sensibles et de les mettre à la disposition d'un module.

Si les mots de passe, les jetons ou les clés faisaient simplement partie d'une définition de pod ou d'une image de conteneur, ils pourraient être accidentellement exposés lors des opérations Kubernetes. Par conséquent, la fonction la plus importante du secret est d'empêcher l'exposition accidentelle des informations qui y sont stockées tout en les rendant disponibles partout où l'utilisateur en a besoin.

Types de secrets Kubernetes

Kubernetes propose deux catégories de secrets :

• Les comptes de service du système créent automatiquement des secrets intégrés et associez-les à des conteneurs avec les informations d'identification de l'API.
• Vous pouvez également créer des secrets personnalisés pour les informations d'identification que vous devez mettre à la disposition des pods.

Les secrets intégrés sont de plusieurs types, correspondant à des scénarios d'utilisation courants :

Type intégré	Description
Opaque	C'est le type de secret par défaut. Les secrets dont le fichier de configuration ne contient pas la déclaration de type sont tous considérés comme étant de ce type. Les secrets opaques sont conçus pour stocker des données utilisateur arbitraires.
kubernetes.io/service-account-token	Les secrets des jetons de compte de service stockent les jetons identifiant les comptes de service. Lors de la création d'un pod, Kubernetes crée automatiquement ce secret et l'associe au pod, permettant un accès sécurisé à l'API. Ce comportement peut être désactivé.
kubernetes.io/dockercfg	L'accès à un registre Docker pour les images nécessite des informations d'identification Docker valides. Ce type de secret est utilisé pour stocker un ~/.dockercfg sérialisé format hérité pour la configuration de la ligne de commande Docker. Il contient le .dockercfg encodé en base64 clé.
kubernetes.io/dockerconfigjson	Ce type de secret comporte un .dockerconfigjson key, qui est une version encodée en base64 du ~/.docker/config.json fichier, une nouvelle version du .dockercfg obsolète .
kubernetes.io/basic-auth	Le secret pour stocker les données d'authentification de base. Il doit contenir deux clés - username et password .
kubernetes.io/ssh-auth	Pour stocker les données nécessaires à l'établissement d'une connexion SSH, utilisez ssh-auth taper. Le champ de données de ce type doit contenir une ssh-privatekey paire clé-valeur.
kubernetes.io/tls	Ce type est utilisé pour stocker les certificats et les clés TLS. Le scénario d'utilisation le plus courant est la terminaison des ressources Ingress, mais le tls type est aussi parfois utilisé avec d'autres ressources.
bootstrap.kubernetes.io/token	Les jetons utilisés pendant le processus d'amorçage du nœud sont stockés à l'aide du type de jeton secret. Ce type est généralement créé dans le kube-system espace de noms.

Pour définir un type de secret personnalisé, affectez une chaîne non vide comme valeur dans le type champ du fichier secret. Laisser le champ vide indique à Kubernetes d'assumer le Opaque taper. Le type personnalisé libère le secret des contraintes posées par les types intégrés.

Utilisation des secrets Kubernetes

Lorsque vous créez un secret, il doit être référencé par le pod qui l'utilisera. Pour rendre un secret disponible pour un pod :

1. Montez le secret en tant que fichier dans un volume disponible pour n'importe quel nombre de conteneurs dans un pod.

2. Importez le secret en tant que variable d'environnement dans un conteneur.

3. Utilisez kubelet et les imagePullSecrets champ.

Les sections suivantes expliquent comment créer des secrets Kubernetes, ainsi que comment les décoder et y accéder.

Créer des secrets Kubernetes

Pour créer un secret Kubernetes, appliquez l'une des méthodes suivantes :

• Utilisez kubectl pour une approche basée sur la ligne de commande.
• Créez un fichier de configuration pour le secret.
• Utilisez un générateur, tel que Kustomize pour générer le secret.

Créer des secrets à l'aide de kubectl

1. Pour commencer à créer un secret avec kubectl , créez d'abord les fichiers pour stocker les informations sensibles :

echo -n '[username]' > [file1]
echo -n '[password]' > [file2]

Le -n l'option indique echo de ne pas ajouter de nouvelle ligne à la fin de la chaîne. La nouvelle ligne est également traitée comme un caractère, elle serait donc encodée avec le reste des caractères, produisant une valeur encodée différente.

2. Maintenant, utilisez kubectl pour créer un secret en utilisant les fichiers de l'étape précédente. Utilisez la sous-commande générique pour créer un Opaque secret. Ajoutez également le --from-file option pour chacun des fichiers que vous souhaitez inclure :

kubectl create secret generic [secret-name] \  
--from-file=[file1] \
--from-file=[file2]

La sortie confirme la création du secret :

3. Pour fournir des clés pour les valeurs stockées dans le secret, utilisez la syntaxe suivante :

kubectl create secret generic [secret-name] \  
--from-file=[key1]=[file1] \  
--from-file=[key2]=[file2]

4. Vérifiez que le secret a bien été créé en saisissant :

kubectl get secrets

La commande affiche la liste des secrets disponibles - leurs noms, types, nombre de valeurs de données qu'ils contiennent et leur ancienneté :

Créer des secrets dans un fichier de configuration

1. Pour créer un secret en précisant les informations nécessaires dans un fichier de configuration, commencez par encoder les valeurs que vous souhaitez stocker :

echo -n '[value1]' | base64
echo -n '[value2]' | base64

2. Créez maintenant un fichier yaml à l'aide d'un éditeur de texte. Le fichier devrait ressembler à ceci :

apiVersion: v1
kind: Secret
metadata:  
  name: newsecret
type: Opaque
data:
  username: dXNlcg==
  password: NTRmNDFkMTJlOGZh

3. Enregistrez le fichier et utilisez le kubectl apply commande pour créer le secret :

kubectl apply -f [file]

Créer un secret Kubernetes avec des générateurs

Des générateurs tels que Kustomize permettent de générer rapidement des secrets.

1. Pour créer un secret avec Kustomize, créez un fichier nommé kustomization.yaml et formatez-le comme suit :

secretGenerator:
- name: db-credentials 
  files:
  - username.txt
  - password.txt

L'exemple ci-dessus indique db-credentials comme nom du secret et utilise deux fichiers créés précédemment, username.txt , et password.txt , comme valeurs de données.

2. Alternativement, pour fournir la version littérale non chiffrée des valeurs de données, incluez les literals section avec les paires clé-valeur que vous souhaitez stocker :

secretGenerator:
- name: db-credentials
  literals:
  - username=user
  - password=54f41d12e8fa

3. Enregistrez le fichier et utilisez la commande suivante dans le dossier où kustomization.yaml est situé :

kubectl apply -k .

La sortie confirme la création du secret :

Utilisez kubectl describe pour voir les secrets créés

Le kubectl describe La commande affiche des informations de base sur les objets Kubernetes. Utilisez-le pour afficher la description d'un secret.

kubectl describe secrets/[secret]

Le premier exemple montre le secret créé en fournissant des fichiers comme valeurs de données :

Le deuxième exemple décrit le secret créé à l'aide de littéraux de chaîne. Remarquez le changement dans les Data section, qui affiche désormais les noms des clés au lieu des noms de fichiers :

Décoder les secrets

1. Pour décoder les valeurs d'un secret, accédez-y en tapant la commande suivante :

kubectl get secret [secret] -o jsonpath='{.data}'

La sortie affiche les paires clé-valeur encodées stockées dans la section de données :

2. Utilisez la commande echo pour saisir la chaîne encodée et diriger la sortie vers le base64 commande :

echo '[encoded-value]' | base64 --decode

Les chaînes décodées apparaissent en sortie :

Accéder aux secrets chargés dans un volume

1. Pour accéder aux secrets montés sur un pod dans un volume séparé, modifiez la définition du pod pour inclure un nouveau volume. Choisissez le nom de volume que vous voulez, mais assurez-vous qu'il est le même que le nom de l'objet secret.

2. Assurez-vous de spécifier readOnly comme vrai. Par exemple, la définition du pod peut ressembler à ceci :

apiVersion: v1
kind: Pod
metadata:
  name: test-pod
  spec:
    containers:
      - name: test-pod
        image: redis
        volumeMounts:
        - name: newsecret
          mountPath: “/etc/newsecret”
          readOnly: true
    volumes:
    - name: newsecret
      secret:
        secretName: newsecret

2. Ouvrez une autre instance de terminal et utilisez le kubectl exec commande pour accéder au shell bash du pod :

kubectl exec -it [pod] -- /bin/bash

3. cd dans /etc/newsecret , et trouvez les fichiers contenus dans le secret :

cd /etc/newsecret

Projeter des secrets dans un conteneur à l'aide de variables d'environnement

1. Une autre façon d'accéder aux secrets dans un pod Kubernetes consiste à les importer en tant que variables d'environnement en modifiant la définition du pod pour y inclure des références. Par exemple :

apiVersion: v1 
kind: Pod 
metadata: 
  name: secret-env-pod 
spec: 
  containers: 
  - name: secret-env-pod
    image: redis 
    env: 
      - name: SECRET_USERNAME 
        valueFrom: 
          secretKeyRef: 
            name: newsecret 
            key: username 
      - name: SECRET_PASSWORD 
        valueFrom: 
          secretKeyRef: 
            name: newsecret 
            key: password 
  restartPolicy: Never

2. Utilisez kubectl exec à nouveau pour frapper un pod.

3. Testez la variable d'environnement à l'aide de echo commande :

echo $[VARIABLE]

La sortie de la commande affiche la valeur mappée à la variable :

Utilisez des secrets pour extraire des images Docker à partir de registres Docker privés

1. Pour utiliser les registres Docker privés, vous devez d'abord vous connecter à Docker :

docker login

2. Lorsque vous y êtes invité, fournissez vos identifiants de connexion :

3. Si la connexion réussit, Docker met à jour le config.json fichier avec vos données. Utilisez la commande cat pour afficher le fichier :

cat ~/.docker/config.json

Les auths contient le auth key, qui est une version codée des identifiants Docker.

4. Utilisez kubectl pour créer un secret, en fournissant l'emplacement du config.json fichier et le type du secret :

kubectl create secret generic [secret] \
--from-file=.dockerconfigjson=./.docker/config.json \
--type=kubernetes.io/dockerconfigjson

Vous pouvez également effectuer toutes les étapes ci-dessus, y compris la connexion à Docker, sur la même ligne :

kubectl create secret docker-registry [secret] --docker-server:[address] --docker-username=[username] --docker-password=[password] --docker-email=[email]

5. Pour créer un pod ayant accès à ce secret, créez un yaml fichier qui le définit. Le fichier devrait ressembler à ceci :

apiVersion: v1
kind: Pod
metadata:
  name: private-reg
spec: 
  containers:
  - name: private-reg-container
    image:   
  imagePullSecrets:  
  - name: regcred

6. Terminez la création du pod en l'activant avec kubectl apply :

kubectl apply -f [file]

Considérations sur les secrets Kubernetes

Les secrets de Kubernetes sont un moyen sécurisé de stocker des informations sensibles. Cependant, avant de choisir la meilleure méthode pour votre scénario d'utilisation, vous devez tenir compte des points suivants :

• Les noms d'utilisateur et les mots de passe dans les secrets sont encodés en base-64. Cette technique de codage de texte masque les données et empêche toute exposition accidentelle, mais elle n'est pas sécurisée contre les cyberattaques malveillantes.
• Les secrets ne sont disponibles que dans le cluster dans lequel ils se trouvent.
• Les secrets reposent généralement sur une clé principale qui est utilisée pour tous les déverrouiller. Bien qu'il existe des méthodes pour sécuriser la clé principale, leur utilisation ne fait que créer un autre scénario de clé principale.

Pour atténuer ces problèmes, appliquez certaines des solutions ci-dessous :

• Intégrez un outil de gestion des secrets qui utilise le compte de service Kubernetes pour authentifier les utilisateurs qui ont besoin d'accéder au coffre secret.
• Intégrez un outil IAM (Gestion des identités et des accès) pour permettre au système d'utiliser des jetons d'un service de jetons sécurisés.
• Intégrez un gestionnaire de secrets tiers dans les pods.