Aller au contenu principal

Chapitre 5.2 - Secrets

Objectifs d'Apprentissage​

À la fin de ce chapitre, vous serez capable de:

  • Comprendre ce qu'est un Secret et pourquoi l'utiliser
  • Créer des Secrets de différentes manières
  • Utiliser des Secrets dans vos Pods de manière sécurisée
  • Comprendre les limitations de sécurité des Secrets
  • Appliquer les bonnes pratiques pour la gestion des secrets

Introduction​

Les Secrets sont similaires aux ConfigMaps mais sont conçus pour stocker des données sensibles comme des mots de passe, tokens d'API, clés privées, et certificats.

Important: Les Secrets Kubernetes ne sont pas chiffrés par défaut. Ils sont seulement encodés en base64.

Qu'est-ce qu'un Secret?​

Un Secret est un objet Kubernetes qui stocke des données sensibles. Par défaut, les Secrets sont encodés en base64 (pas de chiffrement).

Types de Secrets​

Kubernetes supporte plusieurs types de Secrets:

  • Opaque: Données arbitraires (par défaut)
  • kubernetes.io/dockerconfigjson: Credentials pour registres Docker
  • kubernetes.io/tls: Certificats TLS
  • kubernetes.io/service-account-token: Tokens de Service Account

Pourquoi Utiliser des Secrets?​

Problèmes Sans Secrets​

Problèmes:

  • Mots de passe hardcodés dans le code
  • Risque d'exposition dans Git
  • Difficile de rotation
  • Pas de gestion centralisée

Avantages Avec Secrets​

Avantages:

  • Séparés du code applicatif
  • Gestion centralisée
  • Rotation facilitée
  • Intégration avec outils externes (Vault, etc.)

Création de Secrets​

Méthode 1: Depuis des Littéraux​

kubectl create secret generic db-secret \
  --from-literal=username=admin \
  --from-literal=password=secretpassword123

Méthode 2: Depuis un Fichier​

Créer un fichier password.txt:

mysecretpassword
kubectl create secret generic db-secret \
  --from-file=password=password.txt

Méthode 3: Depuis un Fichier YAML​

apiVersion: v1
kind: Secret
metadata:
  name: db-secret
type: Opaque
data:
  username: YWRtaW4=  # base64 de "admin"
  password: cGFzc3dvcmQxMjM=  # base64 de "password123"

Important: Les valeurs dans data doivent être encodées en base64.

Pour encoder:

echo -n "admin" | base64
# Résultat: YWRtaW4=

Types de Secrets Spécialisés​

Secret Docker Registry​

Pour accéder à un registre Docker privé:

kubectl create secret docker-registry regcred \
  --docker-server=docker.io \
  --docker-username=myuser \
  --docker-password=mypassword \
  --docker-email=myuser@example.com

Utilisation dans un Pod:

spec:
  containers:
  - name: app
    image: private-registry.io/myapp:1.0
  imagePullSecrets:
  - name: regcred

Secret TLS​

Pour les certificats SSL/TLS:

kubectl create secret tls tls-secret \
  --cert=tls.crt \
  --key=tls.key

Utilisation dans les Pods​

Méthode 1: Variables d'Environnement (Une Clé)​

apiVersion: v1
kind: Pod
metadata:
  name: app-pod
spec:
  containers:
  - name: app
    image: my-app:1.0
    env:
    - name: DB_USERNAME
      valueFrom:
        secretKeyRef:
          name: db-secret
          key: username
    - name: DB_PASSWORD
      valueFrom:
        secretKeyRef:
          name: db-secret
          key: password

Méthode 2: Toutes les Clés (envFrom)​

apiVersion: v1
kind: Pod
metadata:
  name: app-pod
spec:
  containers:
  - name: app
    image: my-app:1.0
    envFrom:
    - secretRef:
        name: db-secret

Méthode 3: Comme Volume (Fichiers)​

apiVersion: v1
kind: Pod
metadata:
  name: app-pod
spec:
  containers:
  - name: app
    image: my-app:1.0
    volumeMounts:
    - name: secrets
      mountPath: /etc/secrets
      readOnly: true
  volumes:
  - name: secrets
    secret:
      secretName: db-secret
      defaultMode: 0400  # Permissions: lecture seule

Résultat: Chaque clé devient un fichier dans /etc/secrets/ avec la valeur décodée.

Sécurité des Secrets​

Limitations Importantes​

Important:

  • Les Secrets sont encodés en base64, pas chiffrés
  • Accessibles à quiconque a accès à etcd
  • Visibles avec kubectl get secret -o yaml
  • Logs peuvent exposer les secrets

Bonnes Pratiques de Sécurité​

  1. Activer le Chiffrement au Repos

Créer un fichier encryption-config.yaml:

apiVersion: apiserver.config.k8s.io/v1
kind: EncryptionConfiguration
resources:
- resources:
  - secrets
  providers:
  - aescbc:
      keys:
      - name: key1
        secret: <base64-encoded-secret>
  - identity: {}  # Permet le déchiffrement
  1. Utiliser External Secrets Operator

Pour intégrer avec Vault, AWS Secrets Manager, etc.

  1. RBAC Restrictif

Limiter l'accès aux Secrets avec RBAC:

apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: secret-reader
rules:
- apiGroups: [""]
  resources: ["secrets"]
  resourceNames: ["db-secret"]
  verbs: ["get"]
  1. Ne Jamais Commiter les Secrets
  • Utiliser .gitignore pour les fichiers de secrets
  • Utiliser des outils de gestion de secrets
  • Rotation régulière

Exemple Complet​

Étape 1: Créer le Secret​

apiVersion: v1
kind: Secret
metadata:
  name: app-secrets
type: Opaque
data:
  database_url: cG9zdGdyZXNxbDovL3VzZXI6cGFzc0BkYjoxMjM0L215ZGI=
  api_key: c2VjcmV0X2FwaV9rZXlfMTIzNDU2
  jwt_secret: bXlfanN0X3NlY3JldF9rZXlfZm9yX3NpZ25pbmc=

Étape 2: Utiliser dans un Deployment​

apiVersion: apps/v1
kind: Deployment
metadata:
  name: webapp
spec:
  replicas: 3
  selector:
    matchLabels:
      app: webapp
  template:
    metadata:
      labels:
        app: webapp
    spec:
      containers:
      - name: webapp
        image: my-app:1.0
        envFrom:
        - secretRef:
            name: app-secrets
        volumeMounts:
        - name: certs
          mountPath: /etc/ssl/certs
          readOnly: true
      volumes:
      - name: certs
        secret:
          secretName: tls-secret
          defaultMode: 0400

Commandes Utiles​

Voir un Secret (Encodé)​

kubectl get secret db-secret
kubectl describe secret db-secret
kubectl get secret db-secret -o yaml

Décoder un Secret​

# Voir la valeur décodée
kubectl get secret db-secret -o jsonpath='{.data.password}' | base64 -d

Modifier un Secret​

kubectl edit secret db-secret

Note: Les valeurs doivent être en base64 dans l'éditeur.

Supprimer un Secret​

kubectl delete secret db-secret

Rotation des Secrets​

Processus de Rotation​

Étapes:

  1. Créer un nouveau Secret avec un nom différent
  2. Mettre à jour le Deployment pour référencer le nouveau Secret
  3. Attendre que les Pods redémarrent
  4. Supprimer l'ancien Secret

External Secrets Operator​

Pour une gestion avancée avec des outils externes:

apiVersion: external-secrets.io/v1beta1
kind: ExternalSecret
metadata:
  name: db-secret
spec:
  secretStoreRef:
    name: vault-backend
    kind: SecretStore
  target:
    name: db-secret
  data:
  - secretKey: password
    remoteRef:
      key: production/database/password

Résumé​

Dans ce chapitre, vous avez appris:

Secret: Objet Kubernetes pour données sensibles (base64, pas chiffré par défaut)
Types: Opaque, docker-registry, TLS, service-account-token
Création: kubectl create, YAML avec valeurs base64
Utilisation: Variables d'environnement ou volumes
Sécurité: Activer chiffrement au repos, RBAC, External Secrets
Limitations: Base64 seulement, visible dans etcd, logs
Rotation: Créer nouveau secret, mettre à jour, supprimer ancien

Prochaines Étapes​

Chapitre 5.3: Injection dans les Pods
Chapitre 5.4: Bonnes Pratiques
Lab 5.2: Gestion des Secrets

Chapitre créé le: Décembre 2024