Comando Run de Kubernetes

Introducción

El comando kubectl run es una forma sencilla de crear un Pod en Kubernetes. Las versiones modernas de Kubernetes ya no utilizan kubectl run para crear Deployments o Jobs, por lo que este laboratorio combina kubectl run con los comandos específicos para dichos recursos. Este laboratorio está diseñado para ayudar a los principiantes a entender qué comando utilizar para cada tipo de carga de trabajo.

Al finalizar este laboratorio, aprenderás a:

1. Iniciar y verificar un clúster de Minikube.
2. Crear un pod utilizando kubectl run.
3. Crear un deployment con múltiples réplicas.
4. Crear e inspeccionar un Job para procesamiento por lotes (batch).
5. Limpiar los recursos para mantener tu clúster ordenado.

Iniciar el clúster de Minikube

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

1. Navega a tu directorio de trabajo:

   Abre la terminal y dirígete a la carpeta del proyecto predeterminada:

   cd /home/labex/project
   

2. Inicia 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 iniciarse dependiendo del rendimiento de tu sistema.

3. Verifica 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.
   • 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.

Explora el comando kubectl run

El comando kubectl run se utiliza para crear y ejecutar una imagen específica en un pod. Ofrece múltiples opciones para personalizar el comportamiento, el entorno y las especificaciones del pod.

Ejecuta el siguiente comando para ver las opciones disponibles para kubectl run:

kubectl run -h

Verás la siguiente salida:

Create and run a particular image in a pod.

Examples:
## Start a nginx pod
kubectl run nginx --image=nginx

## Start a hazelcast pod and let the container expose port 5701
kubectl run hazelcast --image=hazelcast/hazelcast --port=5701

## Start a hazelcast pod and set environment variables "DNS_DOMAIN=cluster" and "POD_NAMESPACE=default" in the container
kubectl run hazelcast --image=hazelcast/hazelcast --env="DNS_DOMAIN=cluster" --env="POD_NAMESPACE=default"

## Start a hazelcast pod and set labels "app=hazelcast" and "env=prod" in the container
kubectl run hazelcast --image=hazelcast/hazelcast --labels="app=hazelcast,env=prod"

## Dry run; print the corresponding API objects without creating them
kubectl run nginx --image=nginx --dry-run=client

## Start a nginx pod, but overload the spec with a partial set of values parsed from JSON
kubectl run nginx --image=nginx --overrides='{ "apiVersion": "v1", "spec": { ... } }'

## Start a busybox pod and keep it in the foreground, don't restart it if it exits
kubectl run -i -t busybox --image=busybox --restart=Never

## Start the nginx pod using the default command, but use custom arguments (arg1 .. argN) for that command
kubectl run nginx --image=nginx -- <arg1> <arg2> ... <argN>

## Start the nginx pod using a different command and custom arguments
kubectl run nginx --image=nginx --command -- <cmd> <arg1> ... <argN>

Crear un Pod

Un pod es la unidad desplegable más pequeña en Kubernetes y representa uno o más contenedores ejecutándose juntos. En este paso, crearemos un pod que ejecute un servidor web Nginx.

1. Crea el pod:

   Ejecuta el siguiente comando para crear un pod llamado nginx-pod:

   kubectl run nginx-pod --image=nginx
   

   • La opción --image especifica la imagen del contenedor a utilizar. Aquí, usamos la imagen oficial de Nginx.

2. Verifica el pod:

   Comprueba que el pod esté en ejecución:

   kubectl get pods
   

   • Busca nginx-pod en la salida.
   • La columna STATUS debería mostrar Running cuando el pod esté listo.

Si el estado del pod muestra Pending, es posible que Kubernetes aún esté descargando la imagen del contenedor. Espera unos instantes y vuelve a ejecutar kubectl get pods.

Crear un Deployment y escalar réplicas

Un deployment gestiona un conjunto de pods y asegura que se ejecuten según lo deseado. Es útil para escalar y actualizar aplicaciones.

1. Crea el deployment:

   Ejecuta el siguiente comando para crear un deployment llamado nginx-deployment:

   kubectl create deployment nginx-deployment --image=nginx
   

   • La opción --image especifica la imagen del contenedor a utilizar.

2. Escala el deployment a 3 réplicas:

   Dado que el flag --replicas está obsoleto, escalaremos el deployment utilizando kubectl scale.

   Usa el comando kubectl scale para ajustar el número de réplicas:

   kubectl scale deployment nginx-deployment --replicas=3
   

   • Esto asegura que tres pods se ejecuten como parte del deployment.

3. Verifica el deployment y sus réplicas:

   Comprueba el estado del deployment y de los pods:

   kubectl get deployments
   kubectl get pods
   

   • Asegúrate de que el deployment muestre 3 réplicas bajo la columna READY.
   • Verifica que aparezcan tres pods en la salida de kubectl get pods.

Si un pod no está en estado Running, podría deberse a recursos insuficientes en el clúster. Comprueba los eventos del pod con:

kubectl describe pod <pod-name>

Crear un Job

En este paso, crearás un Job de Kubernetes para ejecutar una tarea corta por lotes. Un Job realiza un seguimiento de la finalización exitosa, por lo que es el recurso adecuado cuando un comando debe ejecutarse y terminar, en lugar de permanecer activo como un Pod de larga duración.

1. Crea el job

Ejecuta el siguiente comando para crear un job llamado busybox-job:

kubectl create job busybox-job --image=busybox -- echo "Hello from Kubernetes"

• kubectl create job crea un recurso de tipo Job en lugar de un Pod independiente.
• El comando echo define la tarea que el Job ejecutará.

2. Comprueba el estado del job

Ejecuta el siguiente comando para verificar el job:

kubectl get jobs

Salida esperada:

NAME          COMPLETIONS   DURATION   AGE
busybox-job   1/1           5s         10s

• COMPLETIONS: Muestra que el Job se ejecutó correctamente una vez (1/1).
• Si aún no aparece ningún Job, espera unos segundos y vuelve a ejecutar kubectl get jobs.

3. Verifica el pod del job

Dado que un job se ejecuta dentro de un pod, utiliza el siguiente comando para verificar el pod:

kubectl get pods

Salida esperada:

NAME                      READY   STATUS      RESTARTS   AGE
busybox-job-abcde         0/1     Completed   0          30s

• El nombre del Pod incluye un sufijo generado porque es propiedad del Job.
• El campo STATUS debería mostrar Completed, lo que indica que el Pod del Job finalizó correctamente.

4. Comprueba la salida del job

Inspecciona los registros (logs) del Job para verificar la salida:

kubectl logs job/busybox-job

Salida esperada:

Hello from Kubernetes

Esto confirma que el job se ejecutó correctamente.

Limpieza

Para mantener tu clúster limpio, elimina los recursos que creaste durante el laboratorio.

1. Elimina los recursos:

   Ejecuta los siguientes comandos:

   kubectl delete pod nginx-pod
   kubectl delete deployment nginx-deployment
   kubectl delete job busybox-job
   

2. Verifica la limpieza:

   Comprueba que no queden recursos:

   kubectl get pods
   kubectl get deployments
   

   • Asegúrate de que la salida no muestre los recursos que creaste.

Resumen

En este laboratorio, aprendiste a:

1. Iniciar y verificar un clúster de Minikube.
2. Usar kubectl run para crear un Pod y utilizar comandos específicos para crear Deployments y Jobs.
3. Limpiar los recursos para mantener el clúster organizado.

También viste cómo Kubernetes utiliza diferentes comandos para distintos tipos de cargas de trabajo. Al practicar estos pasos, puedes construir una base sólida para flujos de trabajo de Kubernetes más avanzados.