RKE

Tema:

Pods en Kubernetes

Introducción

Los Pods son la unidad básica de ejecución en Kubernetes, diseñados para encapsular contenedores y proporcionar un entorno compartido de red y almacenamiento. En esta guía de laboratorio, aprenderás cómo crear y gestionar Pods de manera eficiente, explorando tanto su configuración básica como características avanzadas, como Pods Multi-Contenedor e Init Containers. Este enfoque práctico te permitirá adquirir habilidades esenciales para gestionar aplicaciones contenerizadas en Kubernetes.

Objetivo

Objetivo General:

Desarrollar las habilidades necesarias para crear, gestionar y optimizar Pods en Kubernetes, aplicando técnicas prácticas y buenas prácticas para maximizar su eficiencia y funcionalidad en entornos productivos.

Laboratorio: Pods en Kubernetes

Esta guía muestra cómo crear y gestionar un recurso tipo POD dentro de Kubernetes

Antes de comenzar

Contar con el acceso al ambiente de laboratorio
Haber realizado la validación de conexión y funcionamiento
Finalizar las prácticas de laboratorio de las instalaciones de RKE2.
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-pod
```
kubectl create ns example-pod
```

Establecer el nuevo namespace por defecto en el contexto actual:

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

Listar los recursos disponibles en el API de Kubernetes
```
kubectl api-resources
```
Listar los recursos que estan disponibles bajo el alcance el Namespace
```
kubectl api-resources --namespaced=true
```
Verificar el recurso POD en los Recursos del API de Kubernetes
```
kubectl api-resources --namespaced=true | grep pods
```
Utilizar el comando kubectl explain para revisar la descripción y documentación de un POD.
```
kubectl explain pod
```
En kubernetes en posible crear un POD que no dependa de ninguna carga de trabajo (Workloads) de Kubernetes, puede ser creado de forma imperativa con un comando o de forma declarativa mediante un archivo YAML, utilice el siguiente comando para crear un POD independiente de un Workload:
```
kubectl run nginx-pod --image=nginx
```
```
pod/nginx-pod created
```

Puede verificar la ejecución de uno o varios Pods dentro de un Namespace con el siguiente comando:

kubectl get pods

NAME        READY   STATUS    RESTARTS   AGE
nginx-pod   1/1     Running   0          40s

Puede verificar el detalle de la configuración deseada y el estado de ejecución actual de un Pod:
```
kubectl describe pod nginx-pod
```
Puede verificar los recursos que se encuentran siendo utilizados por los Pods con el siguiente comando:
```
kubectl top pods
```
Es posible revisar los logs generados por los Pods de las aplicaciones que contienen:
```
kubectl logs nginx-pod
```
Puede realizar cambios en el Pod, como el siguiente comando que actualiza la versión de la imagen del Contenedor en ejecución:
```
kubectl set image pod/nginx-pod nginx-pod=nginx:1.9.1
```
Es posible verificar los eventos de los cambios que sufre un Pod listando los eventos de Kubernetes o utilizando el subcomando describe:
```
kubectl get events
```
```
kubectl describe pod nginx-pod
```
Los Pods que no son dependientes de ninguna carga de trabajo pueden ser eliminados utilizando las siguientes opciones de comando:
```
kubectl delete pod nginx-pod
```
```
kubectl delete pod nginx-pod --force --grace-period 0
```

Crear la definición de un pod en formato YAML con el comando kubectl run, sin crear el recurso en Kubernetes.

kubectl run hazelcast --image=hazelcast/hazelcast --labels="app=hazelcast,env=prod" --env="DNS_DOMAIN=cluster" --env="POD_NAMESPACE=example-pod" --dry-run=client -o yaml > pod-example.yaml

Explorar el contenido del archivo YAML creado anteriormente
```
cat pod-example.yaml
```

Crear el recurso Pod a partir de un archivo YAML

kubectl apply -f pod-example.yaml

kubectl get pods

Eliminar el pod creado anteriormente de la misma forma que se creo, utilizando el archivo YAML
```
kubectl delete -f pod-example.yaml
```

Es posible crear un Pod que contenga mas de un contenedor, lo cual recibe el nombre de Multi-Contenedor, a continuación cree un archivo YAML con el nombre multi-container.yaml

apiVersion: v1
kind: Pod
metadata:
  name: multi-container
spec:
  volumes:
  - name: html
    emptyDir: {}
  containers:
  - name: 1st
    image: nginx
    volumeMounts:
    - name: html
      mountPath: /usr/share/nginx/html
  - name: 2nd
    image: debian
    volumeMounts:
    - name: html
      mountPath: /html
    command: ["/bin/sh", "-c"]
    args:
      - while true; do
          date >> /html/index.html;
          sleep 1;
        done

En el ejemplo anterior, el contenedor 2st escribe la fecha en el archivo index.html y el contenedor 1st se encarga de mostrarla en el servicio web NGINX.

Ejecute la creación del Pod con el siguiente comando:
```
kubectl apply -f multi-container.yaml
```

Verifique la ejecución de un Pod Multi Contenedor:

kubectl get pods

multi-container   2/2     Running   0          4s

Verifique la salida de la ejecución de ambos Contenedores:

kubectl exec multi-container -c 1st -- /bin/cat /usr/share/nginx/html/index.html

kubectl exec multi-container -c 2nd -- /bin/cat /html/index.html

También es posible ejecutar un Contenedor antes que se ejecute el Contenedor principal dentro de un Pod, para ejecutar alguna tarea previa de preparación para el Contenedor que contiene la aplicación principal, a este modelo se le denomina Init Container, a continuación cree un archivo YAML con el nombre init-container.yaml

apiVersion: v1
kind: Pod
metadata:
  name: init-demo
spec:
  containers:
  - name: nginx
    image: nginx
    ports:
    - containerPort: 80
    volumeMounts:
    - name: workdir
      mountPath: /usr/share/nginx/html
  # These containers are run during pod initialization
  initContainers:
  - name: install
    image: busybox:1.28
    command:
    - wget
    - "-O"
    - "/work-dir/index.html"
    - http://info.cern.ch
    volumeMounts:
    - name: workdir
      mountPath: "/work-dir"
  dnsPolicy: Default
  volumes:
  - name: workdir
    emptyDir: {}

En el ejemplo anterior, el contenedor con nombre install es el Init Container, y se ejecuta antes del contenedor principal nginx. La función del Init Container en es caso es de crear y preparar el sitio web que el contenedor principal de NGINX se encargará de publicar.

Ejecute la creación del Pod bajo el modelo de Init Container con el siguiente comando:
```
kubectl apply -f init-container.yaml
```
Verifique la ejecución y funcionamiento del Pod creado anteriormente:
```
kubectl get pods
```

kubectl exec -it init-demo -- /bin/bash

curl localhost

exit

Note que es posible ingresar al SHELL del Contenedor utilizando kubectl exec -it init-demo -- /bin/bash

Puede realizar limpieza del laboratorio con los siguientes comandos:
```
kubectl delete -f multi-container.yaml
```

kubectl delete -f init-container.yaml

kubectl delete pods --all -n example-pod

kubectl delete ns example-pod

rm -f multi-container.yaml pod-example.yaml init-container.yaml

Conclusión

En esta práctica, exploramos los Pods, el recurso más básico y fundamental en Kubernetes, que actúa como la unidad mínima de despliegue en el clúster. Aprender a crear, gestionar y observar el comportamiento de los Pods es esencial para comprender cómo Kubernetes ejecuta las aplicaciones.

Los Pods son el pilar sobre el cual se construyen las aplicaciones en Kubernetes. Aunque efímeros y con limitaciones para la gestión directa en entornos productivos, su comprensión es crucial para aprovechar recursos más avanzados, como Deployments o StatefulSets.

Esta práctica nos permitió sentar las bases para trabajar con workloads en Kubernetes, preparando el terreno para implementar aplicaciones escalables, resilientes y gestionadas de forma eficiente en un clúster.