Al desplegar servicios de MySQL en Kubernetes, es crucial gestionar tanto los datos persistentes como los archivos de configuración. Mientras que los datos se pueden persistir utilizando PVCs (Persistent Volume Claims), la gestión desacoplada de los archivos de configuración se puede lograr eficientemente mediante ConfigMaps.

Introducción a ConfigMaps

Funcionalidad y Casos de Uso

Los ConfigMaps son recursos de Kubernetes diseñados para almacenar datos de configuración en forma de pares clave-valor. Permiten inyectar estos datos en los Pods de diversas maneras, promoviendo el desacoplamiento entre las imágenes de contenedor y sus configuraciones. Esto mejora la portabilidad y la reutilización de las imágenes.

• Configuración de variables de entorno.
• Provisión de archivos de configuración dentro de volúmenes montados en Pods.

Creación de ConfigMaps

Existen varias formas de crear ConfigMaps:

1. Creación con valores literales

Utilizando el comando kubectl create configmap con la opción --from-literal:

kubectl create configmap mi-configuracion --from-literal=clave1=valor1 --from-literal=clave2=valor2

Para verificar, puedes inspeccionar el ConfigMap creado:

apiVersion: v1
data:
  clave1: "valor1"
  clave2: "valor2"
kind: ConfigMap
metadata:
  name: mi-configuracion
  namespace: default

2. Creación a partir de archivos

Puedes crear un ConfigMap a partir del contenido de uno o varios archiovs. Por ejemplo, si teines un archivo llamado archivo-config.txt:

echo "parametro=valor" > archivo-config.txt
kubectl create configmap config-desde-archivo --from-file=archivo-config.txt

El contenido del archivo se almacenará bajo una clave con el mismo nombre que el archivo:

apiVersion: v1
data:
  archivo-config.txt: |
    parametro=valor
kind: ConfigMap
metadata:
  name: config-desde-archivo
  namespace: default

3. Creación a partir de directorios

Si tienes un directorio que contiene múltiples archivos de configuración, puedes crearlo como un ConfigMap:

mkdir dir-config
echo "otro_param=otro_valor" > dir-config/config2.conf
kubectl create configmap config-desde-dir --from-file=dir-config

Cada archivo dentro del directorio se convertirá en una entrada clave-valor en el ConfigMap:

apiVersion: v1
data:
  config2.conf: |
    otro_param=otro_valor
kind: ConfigMap
metadata:
  name: config-desde-dir
  namespace: default

4. Creación mediante un archivo YAML

La forma más declarativa es definir el ConfigMap en un archivo YAML. Esto es especialmente útil para configuraciones complejas o para su inclusión en sistemas de control de versiones.

apiVersion: v1
kind: ConfigMap
metadata:
  name: mysql-configuracion
  namespace: base-de-datos
data:
  my.cnf: |
    [mysqld]
    datadir = /var/lib/mysql
    port = 3306
    server-id = 1
    log-error = /var/log/mysql/error.log
    pid-file = /var/run/mysqld/mysqld.pid
    socket = /var/run/mysqld/mysqld.sock
    # Ajustes adicionales de configuración
    max_connections = 200
    innodb_buffer_pool_size = 128M
  custom-init.sql: |
    -- Script SQL de inicialización
    CREATE DATABASE IF NOT EXISTS mi_app_db;
    USE mi_app_db;
    CREATE TABLE IF NOT EXISTS usuarios (
        id INT AUTO_INCREMENT PRIMARY KEY,
        nombre VARCHAR(100) NOT NULL
    );

Para aplicar este archivo:

kubectl apply -f nombre-del-archivo.yaml

Uso de ConfigMaps en Pods

1. Como variables de entorno

Los valores de un ConfigMap pueden ser inyectados directamente como variables de entorno en los contenedores de un Pod:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: app-mysql-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: app-mysql
  template:
    metadata:
      labels:
        app: app-mysql
    spec:
      containers:
      - name: mysql-container
        image: mysql:8.0
        env:
        - name: MYSQL_ROOT_PASSWORD
          valueFrom:
            secretKeyRef:
              name: credenciales-mysql
              key: root_password
        - name: MYSQL_DATABASE
          valueFrom:
            configMapKeyRef:
              name: db-params
              key: database_name
        - name: MYSQL_USER
          valueFrom:
            configMapKeyRef:
              name: db-params
              key: db_user
        - name: MYSQL_PASSWORD
          valueFrom:
            secretKeyRef:
              name: credenciales-mysql
              key: user_password
        ports:
        - containerPort: 3306
          name: mysql

Aquí, database_name y db_user se obtienen del ConfigMap db-params.

2. Como argumentos de línea de comandos

Aunque menos común para configuraciones extensas, los valores de un ConfigMap pueden usarse en los comandos de inicio de un contenedor:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: app-utilidades
spec:
  template:
    spec:
      containers:
      - name: utilidades-container
        image: busybox
        command: ["/bin/sh", "-c", "echo 'Valor de la configuración: $MI_CONFIG_VALUE' && sleep 3600"]
        env:
        - name: MI_CONFIG_VALUE
          valueFrom:
            configMapKeyRef:
              name: config-test
              key: alguna_clave

3. Como volúmenes montados

Esta es una forma muy común y flexible de usar ConfigMaps, especialmente para archivos de configuración que una aplicación lee directamente. El ConfigMap se monta como un volumen, y cada clave dentro del ConfigMap se convierte en un archivo en el directorio montado.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mysql-server-deployment
spec:
  template:
    spec:
      containers:
      - name: mysql-server
        image: mysql:5.7
        ports:
        - containerPort: 3306
          name: mysql
        volumeMounts:
        - name: config-mysql-volumen
          mountPath: /etc/mysql/conf.d  # Directorio donde MySQL espera leer configuraciones adicionales
        - name: init-scripts-volumen
          mountPath: /docker-entrypoint-initdb.d # Directorio para scripts de inicialización en imágenes oficiales de MySQL
      volumes:
      - name: config-mysql-volumen
        configMap:
          name: mysql-configuracion # Nombre del ConfigMap que contiene el archivo my.cnf
      - name: init-scripts-volumen
        configMap:
          name: mysql-configuracion # Nombre del ConfigMap que contiene custom-init.sql

En este ejemplo, el ConfigMap mysql-configuracion tiene dos claves: my.cnf y custom-init.sql. Al montarse en /etc/mysql/conf.d y /docker-entrypoint-initdb.d respectivamente, el proceso de MySQL leerá estos archivos de configuración y ejecutará los scripts de inicialización.