Comando Run de Kubernetes

Introducción

El comando kubectl run es una de las formas más simples y versátiles de crear recursos en Kubernetes. Te permite desplegar rápidamente contenedores, crear trabajos (jobs) para el procesamiento por lotes o configurar despliegues (deployments) para gestionar múltiples réplicas de una aplicación. Este laboratorio está diseñado para ayudar a los principiantes a entender los conceptos básicos del comando kubectl run y cómo usarlo de manera efectiva.

Al final de este laboratorio, aprenderás a:

Iniciar y verificar un clúster de Minikube.
Crear un pod (contenedor agrupado) utilizando kubectl run.
Crear un despliegue (deployment) con múltiples réplicas.
Ejecutar un trabajo (job) para el procesamiento por lotes.
Limpiar los recursos para mantener tu clúster.

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.

Navegar a tu directorio de trabajo:

Abre la terminal y navega hasta la carpeta de proyecto predeterminada:
```
cd /home/labex/project
```
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 iniciarse dependiendo del rendimiento de tu sistema.
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.

Explorar el comando kubectl run

El comando kubectl run se utiliza para crear y ejecutar una imagen específica en un pod. Proporciona 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.

Ejemplos:
## Iniciar un pod de nginx
kubectl run nginx --image=nginx

## Iniciar un pod de hazelcast y hacer que el contenedor exponga el puerto 5701
kubectl run hazelcast --image=hazelcast/hazelcast --port=5701

## Iniciar un pod de hazelcast y establecer las variables de entorno "DNS_DOMAIN=cluster" y "POD_NAMESPACE=default" en el contenedor
kubectl run hazelcast --image=hazelcast/hazelcast --env="DNS_DOMAIN=cluster" --env="POD_NAMESPACE=default"

## Iniciar un pod de hazelcast y establecer las etiquetas "app=hazelcast" y "env=prod" en el contenedor
kubectl run hazelcast --image=hazelcast/hazelcast --labels="app=hazelcast,env=prod"

## Ejecución en seco; imprimir los objetos de la API correspondientes sin crearlos
kubectl run nginx --image=nginx --dry-run=client

## Iniciar un pod de nginx, pero sobrecargar la especificación con un conjunto parcial de valores analizados desde JSON
kubectl run nginx --image=nginx --overrides='{ "apiVersion": "v1", "spec": {... } }'

## Iniciar un pod de busybox y mantenerlo en primer plano, no reiniciarlo si se sale
kubectl run -i -t busybox --image=busybox --restart=Never

## Iniciar el pod de nginx utilizando el comando predeterminado, pero utilizar argumentos personalizados (arg1.. argN) para ese comando
kubectl run nginx --image=nginx -- <arg1> <arg2>... <argN>

## Iniciar el pod de nginx utilizando un comando diferente y argumentos personalizados
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 que se ejecutan juntos. En este paso, crearemos un pod que ejecute un servidor web Nginx.

Crear 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í, utilizamos la imagen oficial de Nginx.
Verificar el pod:

Comprueba que el pod está en ejecución:
```
kubectl get pods
```
- Busca nginx-pod en la salida.
- La columna STATUS debe mostrar Running (En ejecución) cuando el pod esté listo.

Si el estado del pod muestra Pending (Pendiente), Kubernetes aún puede estar descargando la imagen del contenedor. Espera unos momentos y vuelve a ejecutar kubectl get pods.

Crear un Despliegue (Deployment) y Escalar Réplicas

Un despliegue (deployment) gestiona un conjunto de pods y asegura que se ejecuten como se desea. Es útil para escalar y actualizar aplicaciones.

Crear el despliegue:

Ejecuta el siguiente comando para crear un despliegue llamado nginx-deployment:
```
kubectl create deployment nginx-deployment --image=nginx
```
- La opción --image especifica la imagen del contenedor a utilizar.
Escalar el despliegue a 3 réplicas:

Dado que la bandera --replicas está en desuso, escalaremos el despliegue utilizando kubectl scale en su lugar.

Utiliza el comando kubectl scale para ajustar el número de réplicas:
```
kubectl scale deployment nginx-deployment --replicas=3
```
- Esto asegura que tres pods estén en ejecución como parte del despliegue.
Verificar el despliegue y sus réplicas:

Comprueba el estado del despliegue y los pods:
```
kubectl get deployments
kubectl get pods
```
- Asegúrate de que el despliegue muestre 3 réplicas en la columna READY (Listas).
- Verifica que tres pods estén listados en la salida de kubectl get pods.

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

kubectl describe pod <pod-name>

Crear un Job

Un trabajo (job) se utiliza para ejecutar tareas que deben completarse con éxito. Por ejemplo, tareas por lotes o tareas de procesamiento de datos. Utilizaremos kubectl run para crear un trabajo y verificar su ejecución.

Crear el trabajo

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

kubectl run busybox-job --image=busybox --restart=OnFailure -- echo "Hello from Kubernetes"

La bandera --restart=OnFailure especifica que se trata de un trabajo.
El comando echo define la tarea que el trabajo ejecutará.

Verificar el estado del trabajo

Ejecuta el siguiente comando para verificar el trabajo:

kubectl get jobs

Salida esperada:

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

COMPLETIONS (Completados): Muestra que el trabajo se ejecutó con éxito una vez (1/1).
Si no se lista ningún trabajo, es posible que se haya limpiado automáticamente. Pasa al siguiente paso para verificar su pod.

Verificar el pod del trabajo

Dado que un trabajo 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        0/1     Completed   0          30s

El campo STATUS (Estado) debe mostrar Completed (Completado), lo que indica que el trabajo ha finalizado.

Verificar la salida del trabajo

Inspecciona los registros del pod del trabajo para verificar la salida:

kubectl logs busybox-job

Salida esperada:

Hello from Kubernetes

Esto confirma que el trabajo se ejecutó con éxito.

Limpieza

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

Eliminar los recursos:

Ejecuta los siguientes comandos:

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

Verificar la limpieza:

Comprueba que no queden recursos:
```
kubectl get pods
kubectl get deployments
```
- Asegúrate de que la salida no liste los recursos que creaste.

Resumen

En este laboratorio, aprendiste cómo:

Iniciar y verificar un clúster de Minikube.
Utilizar kubectl run para crear y gestionar pods, despliegues (deployments) y trabajos (jobs).
Limpiar los recursos para mantener el clúster organizado.

El comando kubectl run proporciona una forma simple y poderosa de desplegar aplicaciones y gestionar cargas de trabajo en Kubernetes. Al practicar estos pasos, puedes construir una base sólida para flujos de trabajo más avanzados de Kubernetes.