Saltar al contenido principal

Capítulo 5.1 - ConfigMaps

Objetivos de Aprendizaje​

Al final de este capítulo, usted será capaz de:

  • Comprender qué es un ConfigMap y por qué utilizarlo
  • Crear ConfigMaps de diferentes maneras
  • Usar ConfigMaps en sus Pods
  • Separar la configuración del código de la aplicación
  • Aplicar buenas prácticas para los ConfigMaps

Introducción​

En el desarrollo de aplicaciones, la configuración suele cambiar según el entorno (desarrollo, staging, producción). Incrustar la configuración en el código o en las imágenes Docker no es una buena práctica.

Los ConfigMaps permiten separar la configuración del código de la aplicación.

¿Qué es un ConfigMap?​

Un ConfigMap es un objeto de Kubernetes que almacena datos de configuración no sensibles en forma de pares clave-valor. Estos datos pueden ser utilizados por los Pods como variables de entorno, argumentos de comando o archivos de configuración.

¿Por qué Usar ConfigMaps?​

Problemas Sin ConfigMaps​

Problemas:

  • Configuración incrustada en el código
  • Necesidad de reconstruir la imagen para cambiar la configuración
  • Difícil de gestionar diferentes entornos
  • No hay separación de responsabilidades

Ventajas Con ConfigMaps​

Ventajas:

  • Configuración separada del código
  • No es necesario reconstruir la imagen
  • Fácil de gestionar múltiples entornos
  • Reutilizable entre varios Pods

Creación de ConfigMaps​

Método 1: Desde Literales​

kubectl create configmap app-config \
  --from-literal=database_url=postgresql://localhost:5432/mydb \
  --from-literal=log_level=info \
  --from-literal=max_connections=100

Método 2: Desde un Archivo​

Crear un archivo config.properties:

database_url=postgresql://localhost:5432/mydb
log_level=info
max_connections=100
kubectl create configmap app-config --from-file=config.properties

Método 3: Desde un Archivo YAML​

apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
  namespace: default
data:
  database_url: "postgresql://localhost:5432/mydb"
  log_level: "info"
  max_connections: "100"
  # Fichier complet
  application.properties: |
    server.port=8080
    server.host=0.0.0.0
    spring.datasource.url=jdbc:postgresql://localhost:5432/mydb

Uso en los Pods​

Método 1: Variables de Entorno (Una Clave)​

apiVersion: v1
kind: Pod
metadata:
  name: app-pod
spec:
  containers:
  - name: app
    image: my-app:1.0
    env:
    - name: DATABASE_URL
      valueFrom:
        configMapKeyRef:
          name: app-config
          key: database_url
    - name: LOG_LEVEL
      valueFrom:
        configMapKeyRef:
          name: app-config
          key: log_level

Método 2: Todas las Claves (envFrom)​

apiVersion: v1
kind: Pod
metadata:
  name: app-pod
spec:
  containers:
  - name: app
    image: my-app:1.0
    envFrom:
    - configMapRef:
        name: app-config

Resultado: Todas las claves del ConfigMap se convierten en variables de entorno.

Método 3: Como Volumen (Archivos)​

apiVersion: v1
kind: Pod
metadata:
  name: app-pod
spec:
  containers:
  - name: app
    image: my-app:1.0
    volumeMounts:
    - name: config
      mountPath: /etc/config
      readOnly: true
  volumes:
  - name: config
    configMap:
      name: app-config

Resultado: Cada clave se convierte en un archivo en /etc/config/ con el valor como contenido.

Ejemplo Completo​

Paso 1: Crear el ConfigMap​

apiVersion: v1
kind: ConfigMap
metadata:
  name: webapp-config
data:
  # Variables simples
  APP_NAME: "My Web Application"
  APP_VERSION: "1.0.0"
  ENVIRONMENT: "production"
  
  # Archivo de configuración
  nginx.conf: |
    server {
        listen 80;
        server_name example.com;
        root /usr/share/nginx/html;
        index index.html;
    }

Paso 2: Usar en 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: nginx:1.20
        env:
        - name: APP_NAME
          valueFrom:
            configMapKeyRef:
              name: webapp-config
              key: APP_NAME
        - name: ENVIRONMENT
          valueFrom:
            configMapKeyRef:
              name: webapp-config
              key: ENVIRONMENT
        volumeMounts:
        - name: nginx-config
          mountPath: /etc/nginx/conf.d
          readOnly: true
      volumes:
      - name: nginx-config
        configMap:
          name: webapp-config
          items:
          - key: nginx.conf
            path: default.conf

Casos de Uso​

1. Configuración de Aplicaciones​

apiVersion: v1
kind: ConfigMap
metadata:
  name: app-settings
data:
  database_host: "db.example.com"
  database_port: "5432"
  cache_ttl: "3600"
  feature_flags: "feature1,feature2"

2. Archivos de Configuración​

apiVersion: v1
kind: ConfigMap
metadata:
  name: nginx-config
data:
  nginx.conf: |
    events {
        worker_connections 1024;
    }
    http {
        include /etc/nginx/mime.types;
        default_type application/octet-stream;
    }

3. Scripts​

apiVersion: v1
kind: ConfigMap
metadata:
  name: init-scripts
data:
  init.sh: |
    #!/bin/bash
    echo "Initializing application..."
    /app/setup.sh
    exec /app/start.sh

Buenas Prácticas​

1. Organización por Entorno​

Crear ConfigMaps separados para cada entorno:

# Desarrollo
kubectl create configmap app-config-dev --from-file=config-dev.properties

# Producción
kubectl create configmap app-config-prod --from-file=config-prod.properties

2. Versionado​

Utilizar labels para versionar:

apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
  labels:
    version: v1
    environment: production
data:
  # ...

3. No Almacenar Datos Sensibles​

Nunca ponga en un ConfigMap:

  • Contraseñas
  • Tokens de API
  • Claves privadas
  • Certificados

Utilice Secrets en su lugar.

Comandos Útiles​

Ver un ConfigMap​

kubectl get configmap app-config
kubectl describe configmap app-config
kubectl get configmap app-config -o yaml

Modificar un ConfigMap​

kubectl edit configmap app-config

Nota: Los Pods existentes no verán los cambios inmediatamente. Es necesario reiniciarlos.

Eliminar un ConfigMap​

kubectl delete configmap app-config

Limitaciones​

Tamaño Máximo​

  • 1 MiB por entrada en un ConfigMap
  • Total limitado por etcd (generalmente ~1.5 MiB por objeto)

Actualización​

  • Variables de entorno: No cambian sin reiniciar el Pod
  • Volúmenes: Se actualizan periódicamente (retraso de algunos segundos)

Resumen​

En este capítulo, usted ha aprendido:

ConfigMap: Objeto de Kubernetes para almacenar configuración no sensible
Creación: kubectl create, YAML, desde archivos
Uso: Variables de entorno (env/envFrom) o volúmenes
Ventajas: Separación config/código, flexibilidad, reutilización
Buenas prácticas: Organización por entorno, versionado, no almacenar secretos
Limitaciones: Tamaño máximo, actualización requiere reinicio para variables de entorno

Próximos Pasos​

Capítulo 5.2: Secrets - Gestión de datos sensibles
Lab 5.1: Creación y Uso de ConfigMaps

Capítulo creado el: Diciembre 2024