HowtoForge

Tutoriales de Linux

Mapas de configuración en Kubernetes

Un ConfigMap se utiliza para almacenar datos no confidenciales. Los datos están en pares clave-valor. Los pods pueden consumir ConfigMaps como argumentos de línea de comandos, variables de entorno o como archivos de configuración en un volumen.

Utilizando un ConfigMap podemos desacoplar la configuración específica del entorno de las imágenes del contenedor. Esto puede ayudarnos a crear nuestras aplicaciones portátiles. El ConfigMap no proporciona encriptación, por lo que siempre se recomienda no almacenar información confidencial en el Configmap. En lugar de utilizar Config, se pueden utilizar secretos para almacenar información confidencial o claves de seguridad o contraseñas.

Existen las siguientes formas diferentes de utilizar los datos de ConfigMap dentro de un Pod:

  1. Argumentos de la línea de comandos de un contenedor
  2. Variables de entorno de un contenedor
  3. Añadir un archivo en volumen de sólo lectura.
  4. Escribir código para ejecutar dentro del Pod que utilice la API de Kubernetes para leer un ConfigMap.

Para saber más sobre Configmap, visita la página oficial de Kubernetes aquí.

En este artículo, veremos dos ejemplos para acceder a los datos de los configmaps. En un ejemplo utilizaremos los configmaps como variables de entorno en el comando pod y en el otro rellenaremos un volumen con datos almacenados en un ConfigMap.

Requisitos previos

  1. Clúster Kubernetes con al menos 1 nodo trabajador.
    Si quieres aprender a crear un Clúster Kubernetes, haz clicaquí. Esta guía te ayudará a crear un clúster Kubernetes con 1 Maestro y 2 Nodos en Instancias EC2 de AWS Ubuntu 18.04.

¿Qué vamos a hacer?

  1. Crear un Configmap y acceder a sus datos

Crea un Configmap y accede a sus datos.

Crea un archivo con la siguiente definición de configmap.

vim my-configmap-demo1.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: my-configmap-demo1
data:
  variable_one: one
  variable_two: two

configmap-definition

Configmap se puede crear con el siguiente comando.

kubectl create -f my-configmap-demo1.yaml

Obtén los datos del configmap que hemos creado.

kubectl get configmaps
kubectl describe configmaps my-configmap-demo1

crear-configmap

En la captura de pantalla anterior, puedes ver que tenemos nuestros datos «variable_uno» y «variable_dos» disponibles en el config map que hemos creado.

Ahora, se puede acceder a este mapa de configuración en el Pod.

Para acceder a los datos del configmap como variables de entorno en los comandos del pod, vamos a crear un archivo de definición del pod con el siguiente contenido.

vim my-pod-with-configmaps-as-environment-variables.yml
apiVersion: v1
kind: Pod
metadata:
  name: my-pod-configmap-demo
spec:
  containers:
    - name: my-container-configmap-demo
      image: k8s.gcr.io/busybox
      command: [ "/bin/sh", "-c", "echo $(variable_one_env) $(variable_two_env)" ]
      env:
        - name: variable_one_env
          valueFrom:
            configMapKeyRef:
              name: my-configmap-demo1
              key: variable_one
        - name: variable_two_env
          valueFrom:
            configMapKeyRef:
              name: my-configmap-demo1
              key: variable_two
  restartPolicy: Never

pod-definition-to-use-configmap-as-environment-variables

Ahora, estamos preparados para crear un pod que pueda acceder a los datos del configmap como variables de entorno.

kubectl get podss
kubectl create -f my-pod-with-configmaps-as-environment-variables.yml
kubectl get pod

crear-pod-para-usar-configmap-como-variables-ambientales

Dado que el pod ha completado con éxito su ejecución y ha existido, ya que no hay ningún proceso que pueda mantener los pods vivos, podemos comprobar sus registros para ver si configmap estaba disponible en el pod o no. Para comprobarlo, hemos utilizado el comando echo en el pod que imprimirá los valores de las variables.

kubectl get pods
kubectl logs my-pod-configmap-demo

check-pod-logs-to-see-configmap

En la captura de pantalla anterior, se puede ver que los datos de configmap estaban accesibles en el pod y ha impreso los valores utilizando el comando echo como «uno» y «dos».

Los datos del configmap también están disponibles como archivos en los volúmenes.

Para acceder a los datos del configmap a través de un volumen, crea una definición de pod con el siguiente contenido.

vim my-pod-with-configmaps-added-to-volume.yml
apiVersion: v1
kind: Pod
metadata:
  name: my-pod-configmap-demo2
spec:
  containers:
    - name: my-container-configmap-demo2
      image: k8s.gcr.io/busybox
      command: [ "/bin/sh", "-c", "ls /etc/myconfig/" ]
      volumeMounts:
      - name: my-config-volume
        mountPath: /etc/myconfig
  volumes:
    - name: my-config-volume
      configMap:
        name: my-configmap-demo1
  restartPolicy: Never

pod-definition-to-mount-configmap-as-a-volume

Ahora vamos a crear un pod que pueda tener los datos del configmap disponibles como archivos del volumen «mi-config-volumen». Estos datos de configmap estarán disponibles en el directorio «/etc/myconfig» del pod.

kubectl get pods
kubectl create -f my-pod-with-configmaps-added-to-volume.yml
kubectl get pods

crear-pod-a-usar-configmap-de-volumen-como-archivos

Esta vez también, el pod ha salido con éxito ya que no hay ningún proceso que mantenga vivo el pod.

Pero, hemos utilizado el comando «ls /etc/myconfig» que listará el contenido del directorio «/etc/myconfig».

kubectl get pods

En los registros podemos ver que los datos de configmap estaban disponibles como archivos en «/etc/myconfig»

kubectl logs my-pod-configmap-demo2

check-pod-logs-to-see-cofigmap-as-files

En la captura de pantalla anterior, puedes ver que los datos del configmap estaban disponibles en el pod como archivos «variable_one» y «variable_two».

Conclusión

En este artículo hemos aprendido a crear un configmap y a acceder a él de dos maneras. Hemos visto los pasos para acceder a los datos del configmap como variables de entorno al comando pod y archivos en volumen en el pod.

También te podría gustar...