Tema:

Configmaps en Kubernetes

Introducción

Los ConfigMaps en Kubernetes son recursos esenciales que permiten a los desarrolladores desacoplar la configuración de las aplicaciones del código. Esto facilita la gestión de configuraciones dinámicas, habilitando la reutilización y el intercambio de configuraciones entre distintos entornos sin necesidad de modificar los contenedores. En este laboratorio, exploraremos cómo utilizar ConfigMaps para configurar variables de entorno y montar archivos dentro de los contenedores desplegados.

Objetivo

Objetivo General:

El objetivo de este laboratorio es proporcionar una comprensión práctica sobre el uso de ConfigMaps en Kubernetes, permitiendo a los participantes:

Configurar aplicaciones utilizando variables de entorno derivadas de ConfigMaps.

Montar archivos de configuración en contenedores mediante ConfigMaps.

Gestionar configuraciones de manera eficiente y segura dentro de un clúster de Kubernetes.

Laboratorio 1: Usar ConfigMap para Variables de Entorno

Asegurarse de estar en el servidor bastion con el usuario student
```
student@lab-0-bastion:~>
```
Ingresar como usuario administrador al cluster de Kubernetes con el siguiente comando:
```
export KUBECONFIG=/home/student/rke2_conn/cluster1/cluster1_kubeconfig.yaml
```
Crear un nuevo namespace llamado example-configmap
```
kubectl create ns example-configmap
```

Establecer el nuevo namespace por defecto en el contexto actual:

kubectl config set-context --current --namespace=example-configmap

Crea un ConfigMap que almacene las configuraciones para ser utilizadas como variables de entorno. Ejecuta el siguiente comando para crear un ConfigMap llamado example-config:
```
kubectl create configmap example-config \
  --from-literal=APP_NAME=my-app \
  --from-literal=APP_ENV=production
```

Confirma que el ConfigMap fue creado correctamente:

kubectl get configmap example-config -o yaml

Deberías ver una salida similar a esta:

apiVersion: v1
data:
  APP_ENV: production
  APP_NAME: my-app
kind: ConfigMap
metadata:
  creationTimestamp: "2025-01-16T04:53:46Z"
  name: example-config
  namespace: example-configmap
  resourceVersion: "99335"
  uid: b922befa-c362-4927-a1fa-6c236671193e

Ahora crea un Deployment que utilice las variables del ConfigMap como variables de entorno. Guarda el siguiente manifiesto YAML en un archivo llamado deployment-env.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: example-deployment-env
spec:
  replicas: 1
  selector:
    matchLabels:
      app: example-env
  template:
    metadata:
      labels:
        app: example-env
    spec:
      containers:
      - name: example-container
        image: busybox
        command: ["sh", "-c", "env; sleep 3600"]
        env:
        - name: APP_NAME
          valueFrom:
            configMapKeyRef:
              name: example-config
              key: APP_NAME
        - name: APP_ENV
          valueFrom:
            configMapKeyRef:
              name: example-config
              key: APP_ENV

Aplica el manifiesto:
```
kubectl apply -f deployment-env.yaml
```
Verifica que el Pod utilice las variables del ConfigMap. Primero, identifica el nombre del Pod:
```
kubectl get pods -l app=example-env
```
Luego verificar las variables configuradas, debes reemplazar el nombre del Pod identificado anteriormente:
```
kubectl exec -it <pod-name> -- env
```

Busca las variables APP_NAME y APP_ENV en la salida del comando anterior. Deberías ver una salida como la siguiente:

PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
HOSTNAME=example-deployment-env-8495bd84f8-6pkfr
APP_NAME=my-app
APP_ENV=production
KUBERNETES_PORT_443_TCP=tcp://10.39.0.1:443

Laboratorio 2: Montar un Archivo desde un ConfigMap

Crea un ConfigMap que contenga un archivo de configuración.
```
echo "LOG_LEVEL=debug" > app-config.env
```
Ejecuta el siguiente comando para crear un ConfigMap llamado file-config desde un archivo local:
```
kubectl create configmap file-config --from-file=app-config.env
```

Confirma que el ConfigMap fue creado correctamente:

kubectl describe configmap file-config

Deberías ver que contiene el archivo app-config.env.

Name:         file-config
Namespace:    example-configmap
Labels:       <none>
Annotations:  <none>

Data
====
app-config.env:
----
LOG_LEVEL=debug

Crea un Deployment que monte el ConfigMap como un archivo en el contenedor. Guarda el siguiente manifiesto YAML en un archivo llamado deployment-file.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: example-deployment-file
spec:
  replicas: 1
  selector:
    matchLabels:
      app: example-file
  template:
    metadata:
      labels:
        app: example-file
    spec:
      containers:
      - name: example-container
        image: busybox
        command: ["sh", "-c", "cat /etc/config/app-config.env; sleep 3600"]
        volumeMounts:
        - name: config-volume
          mountPath: /etc/config
      volumes:
      - name: config-volume
        configMap:
          name: file-config

Aplica el manifiesto:
```
kubectl apply -f deployment-file.yaml
```
Verifica que el archivo del ConfigMap esté montado en el contenedor. Primero, identifica el nombre del Pod:
```
kubectl get pods -l app=example-file
```
Luego, verifica el contenido del archivo dentro del contenedor, debes reemplazar el nombre del por identificado anteriormente.
```
kubectl exec -it <pod-name> -- cat /etc/config/app-config.env
```
Deberías ver el contenido del archivo montado:
```
LOG_LEVEL=debug
```

Limpieza

kubectl delete deployment example-deployment-env example-deployment-file

kubectl delete configmap example-config file-config

kubectl delete ns example-configmap

rm -f deployment-env.yaml app-config.env deployment-file.yaml

Conclusión

En este laboratorio, aprendiste a utilizar ConfigMaps en Kubernetes para:

Pasar configuraciones como variables de entorno a contenedores.
Montar archivos de configuración en contenedores como volúmenes.

Estas técnicas son esenciales para la gestión de configuraciones en aplicaciones desplegadas en Kubernetes, permitiendo flexibilidad y desacoplamiento entre la configuración y el código.