Gestión de Secrets y Configuraciones en Kubernetes

Introducción

En un entorno Kubernetes, la gestión de las configuraciones y de los secrets es un aspecto crucial para el despliegue y el mantenimiento de las aplicaciones. Este artículo explora los distintos métodos para gestionar estos elementos de forma segura y eficaz.

ConfigMaps: gestión de las configuraciones

Los ConfigMaps son objetos de Kubernetes que permiten almacenar datos no confidenciales en forma de pares clave-valor. Son ideales para separar la configuración de la aplicación del código, lo que facilita las modificaciones sin tener que reconstruir la imagen.

Creación de un ConfigMap

Método 1: a partir de un archivo

# 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étodo 2: a partir de la línea de comandos

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

Método 3: definición YAML

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

Uso de los ConfigMaps

1. Variables de entorno

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 de entorno individuales

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. Archivos de configuración

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: gestión de los datos sensibles

Los Secrets son similares a los ConfigMaps, pero están diseñados para almacenar datos sensibles como contraseñas, tokens de API y claves privadas. Kubernetes almacena los secrets en base64, pero eso no constituye un cifrado real.

Creación de un Secret

Método 1: a partir de la línea de comandos

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

Método 2: a partir de un archivo

# 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étodo 3: definición YAML (con valores en base64)

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

Uso de los Secrets

1. Variables de entorno

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 de entorno individuales

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. Archivos de configuración

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

Buenas prácticas para la gestión de secrets

1. Utilizar un gestor de secrets externo

Kubernetes almacena los secrets en base64, lo que no constituye un cifrado real. Para reforzar la seguridad, utilice un gestor de secrets externo como:

• HashiCorp Vault: solución completa de gestión de secrets
• AWS Secrets Manager: servicio gestionado para los secrets de AWS
• Azure Key Vault: servicio de gestión de secrets de Azure
• Google Secret Manager: servicio de gestión de secrets de GCP

Integración con 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. Utilizar secrets para los registros de contenedores

Para acceder a registros de contenedores privados, utilice secrets de tipo 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>

Después, haga referencia a él en su despliegue:

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. Utilizar secrets para los certificados TLS

Para los certificados TLS, utilice secrets de tipo tls:

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

Después, utilícelo en su 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. Rotación de los secrets

Implemente una estrategia de rotación periódica de los 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>

Gestión avanzada de las configuraciones

1. ConfigMaps para archivos de configuración

Para las aplicaciones que necesitan archivos de configuración completos:

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 para scripts de inicialización

Para los scripts de inicialización o de configuración:

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. Uso de Helm para la gestión de las configuraciones

Helm es un gestor de paquetes para Kubernetes que simplifica la gestión de las configuraciones:

# 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

Seguridad de los secrets

1. Cifrado en reposo (Encryption at Rest)

Active el cifrado en reposo para los secrets en etcd:

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

2. RBAC para los secrets

Utilice RBAC para limitar el acceso a los 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. Auditoría de los secrets

Active la auditoría para hacer un seguimiento del acceso a los secrets:

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

Ejemplo completo: aplicación con ConfigMaps y Secrets

A continuación se muestra un ejemplo completo de una aplicación que utiliza ConfigMaps y 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

Conclusión

La gestión eficaz de los secrets y de las configuraciones es esencial para el despliegue seguro de aplicaciones en Kubernetes. Al utilizar ConfigMaps para los datos no confidenciales y Secrets para los datos sensibles, puede separar la configuración del código y facilitar las modificaciones sin reconstruir las imágenes.

Para reforzar la seguridad, considere utilizar un gestor de secrets externo como HashiCorp Vault, que ofrece un cifrado real y funcionalidades avanzadas de gestión de secrets.

En el próximo artículo exploraremos la monitorización y el logging en Kubernetes, aspectos cruciales para mantener la salud y el rendimiento de sus aplicaciones.