Gestion des Secrets et Configurations dans Kubernetes

Introduction

Dans un environnement Kubernetes, la gestion des configurations et des secrets est un aspect crucial pour le déploiement et la maintenance des applications. Cet article explore les différentes méthodes pour gérer ces éléments de manière sécurisée et efficace.

ConfigMaps : Gestion des Configurations

Les ConfigMaps sont des objets Kubernetes qui permettent de stocker des données non-confidentielles sous forme de paires clé-valeur. Ils sont idéaux pour séparer la configuration de l’application du code, facilitant ainsi les modifications sans reconstruire l’image.

Création d’un ConfigMap

Méthode 1 : À partir d’un fichier

# Créer un fichier de configuration
cat > app-config.properties << EOF
APP_ENV=production
LOG_LEVEL=info
API_URL=https://api.example.com
EOF

# Créer un ConfigMap à partir du fichier
kubectl create configmap app-config --from-file=app-config.properties

Méthode 2 : À partir de lignes de commande

kubectl create configmap app-config \
  --from-literal=APP_ENV=production \
  --from-literal=LOG_LEVEL=info \
  --from-literal=API_URL=https://api.example.com

Méthode 3 : Définition YAML

apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  APP_ENV: production
  LOG_LEVEL: info
  API_URL: https://api.example.com

Utilisation des ConfigMaps

1. Variables d’environnement

apiVersion: apps/v1
kind: Deployment
metadata:
  name: app-deployment
spec:
  template:
    spec:
      containers:
      - name: myapp
        image: myapp:1.0
        envFrom:
        - configMapRef:
            name: app-config

2. Variables d’environnement individuelles

apiVersion: apps/v1
kind: Deployment
metadata:
  name: app-deployment
spec:
  template:
    spec:
      containers:
      - name: myapp
        image: myapp:1.0
        env:
        - name: APP_ENV
          valueFrom:
            configMapKeyRef:
              name: app-config
              key: APP_ENV
        - name: LOG_LEVEL
          valueFrom:
            configMapKeyRef:
              name: app-config
              key: LOG_LEVEL

3. Fichiers de configuration

apiVersion: apps/v1
kind: Deployment
metadata:
  name: app-deployment
spec:
  template:
    spec:
      containers:
      - name: myapp
        image: myapp:1.0
        volumeMounts:
        - name: config-volume
          mountPath: /app/config
      volumes:
      - name: config-volume
        configMap:
          name: app-config

Secrets : Gestion des Données Sensibles

Les Secrets sont similaires aux ConfigMaps mais sont conçus pour stocker des données sensibles comme des mots de passe, des tokens d’API et des clés privées. Kubernetes stocke les secrets en base64, mais cela ne constitue pas un chiffrement réel.

Création d’un Secret

Méthode 1 : À partir de lignes de commande

kubectl create secret generic app-secrets \
  --from-literal=DB_USERNAME=admin \
  --from-literal=DB_PASSWORD=secretpassword

Méthode 2 : À partir d’un fichier

# Créer un fichier de secrets
cat > app-secrets.txt << EOF
DB_USERNAME=admin
DB_PASSWORD=secretpassword
EOF

# Créer un Secret à partir du fichier
kubectl create secret generic app-secrets --from-file=app-secrets.txt

Méthode 3 : Définition YAML (avec valeurs base64)

apiVersion: v1
kind: Secret
metadata:
  name: app-secrets
type: Opaque
data:
  DB_USERNAME: YWRtaW4=  # base64 de "admin"
  DB_PASSWORD: c2VjcmV0cGFzc3dvcmQ=  # base64 de "secretpassword"

Utilisation des Secrets

1. Variables d’environnement

apiVersion: apps/v1
kind: Deployment
metadata:
  name: app-deployment
spec:
  template:
    spec:
      containers:
      - name: myapp
        image: myapp:1.0
        envFrom:
        - secretRef:
            name: app-secrets

2. Variables d’environnement individuelles

apiVersion: apps/v1
kind: Deployment
metadata:
  name: app-deployment
spec:
  template:
    spec:
      containers:
      - name: myapp
        image: myapp:1.0
        env:
        - name: DB_USERNAME
          valueFrom:
            secretKeyRef:
              name: app-secrets
              key: DB_USERNAME
        - name: DB_PASSWORD
          valueFrom:
            secretKeyRef:
              name: app-secrets
              key: DB_PASSWORD

3. Fichiers de configuration

apiVersion: apps/v1
kind: Deployment
metadata:
  name: app-deployment
spec:
  template:
    spec:
      containers:
      - name: myapp
        image: myapp:1.0
        volumeMounts:
        - name: secret-volume
          mountPath: /app/secrets
          readOnly: true
      volumes:
      - name: secret-volume
        secret:
          secretName: app-secrets

Bonnes Pratiques pour la Gestion des Secrets

1. Utiliser un Gestionnaire de Secrets Externe

Kubernetes stocke les secrets en base64, ce qui ne constitue pas un chiffrement réel. Pour une sécurité renforcée, utilisez un gestionnaire de secrets externe comme :

• HashiCorp Vault : Solution complète de gestion de secrets
• AWS Secrets Manager : Service géré pour les secrets AWS
• Azure Key Vault : Service de gestion de secrets Azure
• Google Secret Manager : Service de gestion de secrets GCP

Intégration avec Vault

apiVersion: secrets.hashicorp.com/v1beta1
kind: VaultAuth
metadata:
  name: vault-auth
spec:
  method: kubernetes
  mount: kubernetes
  kubernetes:
    role: application
    serviceAccount: vault-auth
    tokenReviewerJWT: ""
---
apiVersion: secrets.hashicorp.com/v1beta1
kind: VaultSecret
metadata:
  name: app-secrets
spec:
  vaultAuthRef: vault-auth
  path: secret/data/application
  type: Opaque

2. Utiliser des Secrets pour les Registres de Conteneurs

Pour accéder aux registres de conteneurs privés, utilisez des secrets de type docker-registry :

kubectl create secret docker-registry regcred \
  --docker-server=<your-registry-server> \
  --docker-username=<your-username> \
  --docker-password=<your-password> \
  --docker-email=<your-email>

Puis référencez-le dans votre déploiement :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: app-deployment
spec:
  template:
    spec:
      imagePullSecrets:
      - name: regcred
      containers:
      - name: myapp
        image: private-registry.example.com/myapp:1.0

3. Utiliser des Secrets pour les Certificats TLS

Pour les certificats TLS, utilisez des secrets de type tls :

kubectl create secret tls tls-secret \
  --cert=path/to/tls.cert \
  --key=path/to/tls.key

Puis utilisez-le dans votre Ingress :

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: tls-ingress
spec:
  tls:
  - hosts:
    - example.com
    secretName: tls-secret
  rules:
  - host: example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: app-service
            port:
              number: 80

4. Rotation des Secrets

Implémentez une stratégie de rotation régulière des secrets :

apiVersion: v1
kind: Secret
metadata:
  name: app-secrets
  annotations:
    kubernetes.io/change-cause: "Rotation des secrets - 2024-05-10"
type: Opaque
data:
  DB_PASSWORD: <new-base64-encoded-password>

Gestion des Configurations Avancée

1. ConfigMaps pour les Fichiers de Configuration

Pour les applications qui nécessitent des fichiers de configuration complets :

apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  nginx.conf: |
    server {
      listen 80;
      server_name example.com;
      location / {
        proxy_pass http://backend;
      }
    }
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  template:
    spec:
      containers:
      - name: nginx
        image: nginx:1.19
        volumeMounts:
        - name: config-volume
          mountPath: /etc/nginx/conf.d
      volumes:
      - name: config-volume
        configMap:
          name: app-config

2. ConfigMaps pour les Scripts d’Initialisation

Pour les scripts d’initialisation ou de configuration :

apiVersion: v1
kind: ConfigMap
metadata:
  name: init-scripts
data:
  init.sh: |
    #!/bin/bash
    echo "Initializing application..."
    # Script d'initialisation
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: app-deployment
spec:
  template:
    spec:
      initContainers:
      - name: init
        image: busybox
        command: ["/scripts/init.sh"]
        volumeMounts:
        - name: scripts-volume
          mountPath: /scripts
      containers:
      - name: myapp
        image: myapp:1.0
      volumes:
      - name: scripts-volume
        configMap:
          name: init-scripts
          defaultMode: 0755

3. Utilisation de Helm pour la Gestion des Configurations

Helm est un gestionnaire de paquets pour Kubernetes qui simplifie la gestion des configurations :

# values.yaml
config:
  APP_ENV: production
  LOG_LEVEL: info
secrets:
  DB_PASSWORD: secretpassword
---
# templates/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ .Release.Name }}-deployment
spec:
  template:
    spec:
      containers:
      - name: myapp
        image: myapp:{{ .Values.image.tag }}
        env:
        - name: APP_ENV
          value: {{ .Values.config.APP_ENV }}
        - name: LOG_LEVEL
          value: {{ .Values.config.LOG_LEVEL }}
        - name: DB_PASSWORD
          valueFrom:
            secretKeyRef:
              name: {{ .Release.Name }}-secrets
              key: DB_PASSWORD

Sécurité des Secrets

1. Chiffrement au Repos (Encryption at Rest)

Activez le chiffrement au repos pour les secrets dans etcd :

apiVersion: apiserver.config.k8s.io/v1
kind: EncryptionConfiguration
resources:
  - resources:
    - secrets
    providers:
    - aescbc:
        keys:
        - name: key1
          secret: <base64-encoded-key>
    - identity: {}

2. RBAC pour les Secrets

Utilisez RBAC pour limiter l’accès aux secrets :

apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  namespace: default
  name: secret-reader
rules:
- apiGroups: [""]
  resources: ["secrets"]
  verbs: ["get", "list", "watch"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: secret-reader-binding
subjects:
- kind: ServiceAccount
  name: app-service-account
  namespace: default
roleRef:
  kind: Role
  name: secret-reader
  apiGroup: rbac.authorization.k8s.io

3. Audit des Secrets

Activez l’audit pour suivre l’accès aux secrets :

apiVersion: audit.k8s.io/v1
kind: Policy
rules:
- level: Metadata
  users: ["system:serviceaccount"]
  verbs: ["get", "list", "watch"]
  resources:
  - group: ""
    resources: ["secrets"]

Exemple Complet : Application avec ConfigMaps et Secrets

Voici un exemple complet d’une application utilisant ConfigMaps et Secrets :

# ConfigMap pour la configuration de l'application
apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  APP_ENV: production
  LOG_LEVEL: info
  API_URL: https://api.example.com
  nginx.conf: |
    server {
      listen 80;
      server_name example.com;
      location / {
        proxy_pass http://backend;
      }
    }
---
# Secret pour les données sensibles
apiVersion: v1
kind: Secret
metadata:
  name: app-secrets
type: Opaque
data:
  DB_USERNAME: YWRtaW4=  # base64 de "admin"
  DB_PASSWORD: c2VjcmV0cGFzc3dvcmQ=  # base64 de "secretpassword"
---
# Déploiement de l'application
apiVersion: apps/v1
kind: Deployment
metadata:
  name: app-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: myapp
        image: myapp:1.0
        ports:
        - containerPort: 8080
        envFrom:
        - configMapRef:
            name: app-config
        - secretRef:
            name: app-secrets
        volumeMounts:
        - name: config-volume
          mountPath: /app/config
        - name: nginx-config-volume
          mountPath: /etc/nginx/conf.d
      volumes:
      - name: config-volume
        configMap:
          name: app-config
      - name: nginx-config-volume
        configMap:
          name: app-config
---
# Service pour exposer l'application
apiVersion: v1
kind: Service
metadata:
  name: app-service
spec:
  selector:
    app: myapp
  ports:
  - port: 80
    targetPort: 8080
  type: LoadBalancer

Conclusion

La gestion efficace des secrets et des configurations est essentielle pour le déploiement sécurisé d’applications dans Kubernetes. En utilisant ConfigMaps pour les données non-confidentielles et Secrets pour les données sensibles, vous pouvez séparer la configuration du code et faciliter les modifications sans reconstruire les images.

Pour une sécurité renforcée, envisagez d’utiliser un gestionnaire de secrets externe comme HashiCorp Vault, qui offre un chiffrement réel et des fonctionnalités avancées de gestion des secrets.

Dans le prochain article, nous explorerons le monitoring et le logging dans Kubernetes, des aspects cruciaux pour maintenir la santé et la performance de vos applications.