Ejecución de contenedores en Pods

Introducción

En este laboratorio, aprenderás cómo ejecutar contenedores en Pods de Kubernetes. Los Pods son la unidad más pequeña y simple en Kubernetes, y pueden contener uno o más contenedores. Ejecutar contenedores en Pods ofrece muchos beneficios, incluyendo una mejor utilización de recursos, un escalado más fácil y una implementación más eficiente.

Iniciar el clúster de Minikube

Antes de crear recursos, necesitas un clúster de Kubernetes en ejecución. Minikube es un entorno ligero de Kubernetes que se ejecuta en tu máquina local.

1. Navegar a tu directorio de trabajo:

   Abre la terminal y navega hasta la carpeta de proyecto predeterminada:

   cd /home/labex/project
   

2. Iniciar Minikube:

   Inicia Minikube para inicializar un clúster de Kubernetes:

   minikube start
   

   • Este comando configura un clúster de Kubernetes de un solo nodo en tu máquina local.
   • Minikube puede tardar unos minutos en iniciar dependiendo del rendimiento de tu sistema.

3. Verificar que Minikube esté en ejecución:

   Comprueba el estado del clúster de Minikube:

   minikube status
   

   • Busca componentes como kubelet y apiserver listados como Running (En ejecución).
   • Si el clúster no está en ejecución, vuelve a ejecutar minikube start.

Si encuentras problemas al iniciar Minikube, utiliza minikube delete para restablecer el entorno si es necesario.

Crear un Pod con un solo contenedor

El primer paso es crear un Pod con un solo contenedor. Para hacer esto, crearás un archivo YAML que defina el Pod y su contenedor.

apiVersion: v1
kind: Pod
metadata:
  name: my-pod-1
spec:
  containers:
    - name: my-container
      image: nginx

Guarda el código anterior en un archivo llamado /home/labex/project/pod-single-container.yaml y ejecuta el siguiente comando:

kubectl apply -f /home/labex/project/pod-single-container.yaml

Este comando creará un Pod llamado my-pod-1 con un solo contenedor llamado my-container que ejecuta la imagen de Nginx.

Crear un Pod con múltiples contenedores

El segundo paso es crear un Pod con múltiples contenedores. Para hacer esto, modificarás el archivo YAML anterior para agregar otro contenedor.

apiVersion: v1
kind: Pod
metadata:
  name: my-pod-2
spec:
  containers:
    - name: my-container
      image: nginx
    - name: my-sidecar
      image: busybox
      command: ["sh", "-c", "echo Hello from the sidecar! && sleep 3600"]

Guarda el código anterior en un archivo llamado /home/labex/project/pod-multiple-containers.yaml y ejecuta el siguiente comando:

kubectl apply -f /home/labex/project/pod-multiple-containers.yaml

Este comando creará un Pod llamado my-pod-2 con dos contenedores. El primer contenedor ejecuta la imagen de Nginx, y el segundo contenedor ejecuta la imagen de BusyBox y muestra un mensaje en la consola.

Crear un Pod con variables de entorno

El tercer paso es crear un Pod con variables de entorno. Para hacer esto, modificarás el archivo YAML para agregar variables de entorno al contenedor de Nginx.

apiVersion: v1
kind: Pod
metadata:
  name: my-pod-3
spec:
  containers:
    - name: my-container
      image: nginx
      env:
        - name: MY_ENV_VAR
          value: "Hello World!"

Guarda el código anterior en un archivo llamado /home/labex/project/pod-env-vars.yaml y ejecuta el siguiente comando:

kubectl apply -f /home/labex/project/pod-env-vars.yaml

Este comando creará un Pod llamado my-pod-3 con un solo contenedor llamado my-container que ejecuta la imagen de Nginx y tiene una variable de entorno llamada MY_ENV_VAR con el valor Hello World!.

Crear un Pod con ConfigMaps

El cuarto paso es crear un Pod con ConfigMaps. Un ConfigMap es un recurso de Kubernetes que te permite almacenar datos de configuración (como variables de entorno, archivos de configuración) por separado del código de tu aplicación. Esta separación facilita cambiar la configuración sin tener que reconstruir tus contenedores.

Vamos a dividir esto en pasos sencillos:

1. Primero, crea un ConfigMap:

   kubectl create configmap my-config --from-literal=MY_ENV_VAR=labex
   

   Este comando crea un ConfigMap llamado my-config que almacena un solo par clave-valor:

   • Clave: MY_ENV_VAR
   • Valor: labex

   Puedes verificar que se haya creado el ConfigMap y ver su contenido utilizando:

   kubectl get configmap my-config -o yaml
   

2. A continuación, crea un Pod que utilice este ConfigMap:

   apiVersion: v1
   kind: Pod
   metadata:
     name: my-pod-4
   spec:
     containers:
       - name: my-container
         image: nginx
         envFrom:
           - configMapRef:
               name: my-config
   

   Guarda este YAML en /home/labex/project/pod-configmap.yaml y aplícalo:

   kubectl apply -f /home/labex/project/pod-configmap.yaml
   

Esto creará un Pod que tenga acceso al valor de configuración que almacenamos en el ConfigMap. El valor estará disponible como una variable de entorno dentro del contenedor. Puedes verificar esto ejecutando:

kubectl exec -it my-pod-4 -- env | grep MY_ENV_VAR

Crear un Pod con Volúmenes Persistentes

El quinto paso es crear un Pod con un Volumen Persistente (Persistent Volume, PV) y una Solicitud de Volumen Persistente (Persistent Volume Claim, PVC). Los PV y PVC se utilizan para almacenar y acceder a datos de forma persistente a través de reinicios de Pod.

Para hacer esto, primero crearás un PV.

apiVersion: v1
kind: PersistentVolume
metadata:
  name: my-pv
spec:
  capacity:
    storage: 1Gi
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: "/mnt/data"

Guarda el código anterior en un archivo llamado /home/labex/project/pv.yaml y ejecuta el siguiente comando:

kubectl apply -f /home/labex/project/pv.yaml

Este comando creará un PV llamado my-pv con una capacidad de 1Gi y una ruta de host de /mnt/data.

A continuación, crearás un PVC que solicite 1Gi de almacenamiento del PV.

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: my-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi

Guarda el código anterior en un archivo llamado /home/labex/project/pvc.yaml y ejecuta el siguiente comando:

kubectl apply -f /home/labex/project/pvc.yaml

Este comando creará un PVC llamado my-pvc que solicita 1Gi de almacenamiento.

Finalmente, modificarás el archivo YAML para agregar un volumen y un montaje de volumen al contenedor de Nginx.

apiVersion: v1
kind: Pod
metadata:
  name: my-pod-5
spec:
  containers:
    - name: my-container
      image: nginx
      volumeMounts:
        - name: my-volume
          mountPath: /mnt/data
  volumes:
    - name: my-volume
      persistentVolumeClaim:
        claimName: my-pvc

Guarda el código anterior en un archivo llamado /home/labex/project/pod-pv.yaml y ejecuta el siguiente comando:

kubectl apply -f /home/labex/project/pod-pv.yaml

Este comando creará un Pod llamado my-pod-5 con un solo contenedor llamado my-container que ejecuta la imagen de Nginx y tiene un montaje de volumen en /mnt/data respaldado por el PVC llamado my-pvc.

Resumen

¡Felicidades! Has completado este laboratorio y aprendido cómo ejecutar contenedores en Pods de Kubernetes. También has aprendido cómo crear Pods con múltiples contenedores, variables de entorno, ConfigMaps y Volúmenes Persistentes. Estos son conceptos poderosos que te ayudarán a construir aplicaciones más resistentes y escalables.