Introducción
Kubernetes es una potente plataforma de orquestación de contenedores que ayuda a gestionar aplicaciones en contenedores a través de múltiples hosts. Una característica importante de Kubernetes es su sistema de gestión de trabajos (job management system), que permite ejecutar cargas de trabajo orientadas a lotes hasta su finalización. En este tutorial, aprenderá a monitorizar el estado de los trabajos de Kubernetes y a analizar sus registros (logs), habilidades esenciales para asegurar que sus aplicaciones en contenedores se ejecuten sin problemas.
Al final de este tutorial, podrá crear trabajos de Kubernetes, verificar su estado y examinar sus registros para solucionar problemas de manera efectiva.
Configuración de su Entorno Kubernetes
Antes de que podamos monitorizar los trabajos de Kubernetes, necesitamos configurar un entorno Kubernetes funcional. Usaremos Minikube, una herramienta que crea un clúster Kubernetes de un solo nodo en su máquina local.
Instalación de Minikube
Minikube ya está instalado en su máquina virtual (VM). Verifiquemos la instalación comprobando la versión:
minikube version
Debería ver una salida similar a esta:
minikube version: v1.29.0
commit: ddac20b4b34a9c8c857fc602203b6ba2679794d3
Iniciando Minikube
Ahora, iniciemos Minikube para crear un clúster Kubernetes local:
minikube start --driver=docker
Este comando tardará unos minutos en completarse. Verá una serie de mensajes a medida que Minikube descarga los componentes necesarios e inicia el clúster.
Una vez completado, debería ver un mensaje como:
🏄 ¡Listo! kubectl ahora está configurado para usar el clúster "minikube" y el espacio de nombres "default" por defecto
Verificando la Instalación de Kubernetes
Verifiquemos que nuestro clúster Kubernetes se está ejecutando correctamente comprobando el estado del nodo:
kubectl get nodes
Debería ver una salida similar a esta:
NAME STATUS ROLES AGE VERSION
minikube Ready control-plane 1m v1.26.3
Además, compruebe que los componentes principales de Kubernetes se están ejecutando:
kubectl get pods -n kube-system
Debería ver varios pods en ejecución, incluyendo componentes como kube-apiserver, kube-controller-manager, y otros.
Ahora que tenemos un clúster Kubernetes en ejecución, estamos listos para crear y monitorizar trabajos.
Creando su Primer Trabajo Kubernetes
En este paso, crearemos un trabajo Kubernetes simple que ejecutará un contenedor, realizará una tarea y luego se completará. Esto nos dará algo para monitorizar en los siguientes pasos.
Entendiendo los Trabajos Kubernetes
Un Trabajo Kubernetes (Kubernetes Job) es un controlador que crea uno o más pods y asegura que se terminen con éxito. Los trabajos son útiles para procesos por lotes, tareas únicas o cualquier tarea que deba ejecutarse hasta su finalización en lugar de indefinidamente.
Creando un Archivo de Configuración de Trabajo
Creemos un archivo de configuración de trabajo simple. Abra una terminal y cree un nuevo archivo llamado hello-job.yaml en el directorio de su proyecto:
cd ~/project
nano hello-job.yaml
Copie y pegue el siguiente contenido YAML en el archivo:
apiVersion: batch/v1
kind: Job
metadata:
name: hello-job
spec:
template:
spec:
containers:
- name: hello
image: busybox:1.28
command: ["sh", "-c", 'echo "Hello, Kubernetes!" && sleep 5']
restartPolicy: Never
backoffLimit: 4
Esta configuración define un trabajo llamado hello-job que:
- Utiliza la imagen de contenedor
busybox:1.28 - Ejecuta un comando que imprime "Hello, Kubernetes!" y luego duerme durante 5 segundos
- Tiene una política de reinicio de
Never(Nunca), lo que significa que no se reiniciará después de la finalización - Tiene un
backoffLimitde 4, lo que significa que reintentará hasta 4 veces si falla
Guarde el archivo presionando Ctrl+O, luego Enter, y salga de nano con Ctrl+X.
Creando el Trabajo
Ahora, creemos el trabajo en nuestro clúster Kubernetes:
kubectl apply -f hello-job.yaml
Debería ver la salida:
job.batch/hello-job created
¡Felicidades! Acaba de crear su primer trabajo Kubernetes. En el siguiente paso, aprenderemos a monitorizar su estado.
Monitorizando el Estado de los Trabajos Kubernetes
Ahora que tenemos un trabajo en ejecución en nuestro clúster Kubernetes, aprendamos a monitorizar su estado. Monitorizar el estado del trabajo es crucial para comprender si sus trabajos se completan con éxito o encuentran errores.
Comprobando el Estado del Trabajo con kubectl
La herramienta principal para monitorizar los recursos de Kubernetes es kubectl. Usémosla para comprobar el estado de nuestro trabajo:
kubectl get jobs
Debería ver una salida similar a esta:
NAME COMPLETIONS DURATION AGE
hello-job 1/1 10s 30s
Esta salida muestra:
NAME: El nombre del trabajoCOMPLETIONS: El número de pods completados / completamientos deseadosDURATION: Cuánto tiempo tardó el trabajo en ejecutarseAGE: Cuánto tiempo ha pasado desde que se creó el trabajo
Si su trabajo muestra 0/1 en COMPLETIONS, es posible que aún se esté ejecutando o que haya fallado. Espere unos segundos y ejecute el comando de nuevo.
Obteniendo Información Detallada del Trabajo
Para obtener información más detallada sobre un trabajo, use el comando describe:
kubectl describe job hello-job
Este comando proporciona información extensa sobre el trabajo, incluyendo:
- Etiquetas y anotaciones
- Detalles del selector
- Requisitos de paralelismo y finalización
- Estados de los pods
- Eventos relacionados con el trabajo
Busque la sección Events (Eventos) en la parte inferior, que muestra eventos importantes como la creación y finalización del pod.
Entendiendo el Estado del Trabajo
Un trabajo puede tener varios estados:
Active(Activo): El trabajo aún se está ejecutandoCompleted(Completado): El trabajo se ha completado con éxitoFailed(Fallido): El trabajo ha fallado después de alcanzar su límite de reintento (backoff limit)
Comprobemos si el pod de nuestro trabajo se ha completado:
kubectl get pods
Debería ver algo como:
NAME READY STATUS RESTARTS AGE
hello-job-abcd1 0/1 Completed 0 1m
La columna STATUS muestra Completed (Completado), lo que indica que nuestro trabajo se ejecutó con éxito.
Creando un Trabajo que Tarda Más
Creemos otro trabajo que tardará más en completarse para que podamos observarlo en el estado Active (Activo):
cd ~/project
nano long-job.yaml
Copie y pegue el siguiente contenido YAML:
apiVersion: batch/v1
kind: Job
metadata:
name: long-job
spec:
template:
spec:
containers:
- name: long
image: busybox:1.28
command:
[
"sh",
"-c",
'echo "Starting long job..." && sleep 30 && echo "Long job completed!"'
]
restartPolicy: Never
backoffLimit: 4
Guarde el archivo y salga de nano. Luego cree el trabajo:
kubectl apply -f long-job.yaml
Ahora, comprobemos su estado inmediatamente:
kubectl get jobs
Debería ver que long-job muestra 0/1 completamientos porque aún se está ejecutando. Si sigue comprobando cada pocos segundos, eventualmente verá que cambia a 1/1 después de unos 30 segundos.
Esto demuestra cómo puede monitorizar el progreso de sus trabajos en tiempo real utilizando kubectl.
Analizando los Registros de los Trabajos Kubernetes
Poder ver y analizar los registros de sus trabajos Kubernetes es esencial para la depuración y la comprensión del comportamiento del trabajo. En este paso, exploraremos cómo acceder y analizar los registros de los trabajos que hemos creado.
Obteniendo los Nombres de los Pods para Nuestros Trabajos
Antes de que podamos ver los registros, necesitamos saber los nombres de los pods creados por nuestros trabajos. Cada trabajo crea uno o más pods con nombres que incluyen el nombre del trabajo y un sufijo aleatorio.
Listemos todos los pods relacionados con nuestros trabajos:
kubectl get pods --show-labels
Esto le mostrará todos los pods junto con sus etiquetas. Busque pods con etiquetas como job-name=hello-job o job-name=long-job.
Alternativamente, puede filtrar los pods por el nombre del trabajo:
kubectl get pods -l job-name=hello-job
Esto mostrará solo los pods que pertenecen al trabajo hello-job.
Visualizando los Registros del Trabajo
Ahora que conocemos los nombres de nuestros pods, podemos ver los registros de nuestros trabajos. Use el siguiente comando, reemplazando <pod-name> con el nombre real de su pod:
kubectl logs <pod-name>
Por ejemplo, si su pod se llama hello-job-abcd1, ejecutaría:
kubectl logs hello-job-abcd1
Debería ver la salida:
Hello, Kubernetes!
Este es el mensaje que nuestro trabajo fue programado para emitir.
Comprobemos también los registros de nuestro trabajo más largo. Primero, encuentre el nombre del pod:
kubectl get pods -l job-name=long-job
Luego, vea sus registros:
kubectl logs <long-job-pod-name>
Debería ver:
Starting long job...
Long job completed!
Visualizando los Registros de los Trabajos Completados
Una de las ventajas de los trabajos Kubernetes es que puede ver los registros incluso después de que el trabajo se haya completado. Esto es muy útil para la depuración y la auditoría.
Creemos un trabajo que fallará, para que podamos ver cómo depurarlo:
cd ~/project
nano failed-job.yaml
Copie y pegue el siguiente contenido YAML:
apiVersion: batch/v1
kind: Job
metadata:
name: failed-job
spec:
template:
spec:
containers:
- name: failed
image: busybox:1.28
command: ["sh", "-c", 'echo "Attempting task..." && exit 1']
restartPolicy: Never
backoffLimit: 2
Este trabajo siempre saldrá con el código de estado 1, lo que indica un fallo. Guarde el archivo y salga de nano, luego cree el trabajo:
kubectl apply -f failed-job.yaml
Espere unos momentos para que el trabajo intente y falle varias veces (hasta el límite de reintento). Luego compruebe su estado:
kubectl get jobs failed-job
Debería ver que muestra 0/1 completamientos y ha alcanzado la fecha límite de finalización.
Ahora, examinemos qué salió mal comprobando los registros de los pods fallidos:
kubectl get pods -l job-name=failed-job
Verá varios pods, todos en el estado Error. Elija uno y vea sus registros:
kubectl logs <failed-pod-name>
Debería ver:
Attempting task...
Los registros del pod muestran que la tarea comenzó pero luego salió con un código de error. Esta información es crucial para la depuración de fallos en el trabajo.
Siguiendo los Registros en Tiempo Real
Si desea seguir los registros de un trabajo en ejecución en tiempo real, puede usar la bandera -f:
kubectl logs -f <pod-name>
Esto es particularmente útil para trabajos de ejecución más larga donde desea ver la salida a medida que ocurre.
Creemos otro trabajo de larga duración para demostrarlo:
cd ~/project
nano counter-job.yaml
Copie y pegue el siguiente contenido YAML:
apiVersion: batch/v1
kind: Job
metadata:
name: counter-job
spec:
template:
spec:
containers:
- name: counter
image: busybox:1.28
command:
[
"sh",
"-c",
'for i in $(seq 1 5); do echo "Count: $i"; sleep 5; done'
]
restartPolicy: Never
Guarde el archivo y salga de nano, luego cree el trabajo:
kubectl apply -f counter-job.yaml
Ahora, sigamos sus registros. Primero, encuentre el nombre del pod:
kubectl get pods -l job-name=counter-job
Luego, siga sus registros:
kubectl logs -f <counter-job-pod-name>
Verá el conteo incrementándose cada 5 segundos:
Count: 1
Count: 2
Count: 3
Count: 4
Count: 5
Presione Ctrl+C para dejar de seguir los registros.
Al comprender cómo acceder y analizar los registros, puede solucionar problemas y depurar eficazmente sus trabajos Kubernetes.
Técnicas Avanzadas de Monitorización de Trabajos
Ahora que conoce los conceptos básicos de la monitorización de trabajos Kubernetes, exploremos algunas técnicas más avanzadas que pueden ayudarle a monitorizar los trabajos de forma más eficaz, especialmente en entornos de producción.
Uso de Etiquetas para la Organización de Trabajos
Las etiquetas son pares clave-valor que se pueden adjuntar a los recursos Kubernetes. Son útiles para organizar y seleccionar subconjuntos de recursos. Creemos un trabajo con etiquetas personalizadas:
cd ~/project
nano labeled-job.yaml
Copie y pegue el siguiente contenido YAML:
apiVersion: batch/v1
kind: Job
metadata:
name: labeled-job
labels:
department: engineering
app: demo
environment: training
spec:
template:
spec:
containers:
- name: labeled
image: busybox:1.28
command: ["sh", "-c", 'echo "This is a labeled job" && sleep 10']
restartPolicy: Never
Guarde el archivo y salga de nano, luego cree el trabajo:
kubectl apply -f labeled-job.yaml
Ahora puede filtrar los trabajos por sus etiquetas:
kubectl get jobs -l department=engineering
Esto mostrará solo los trabajos con la etiqueta department=engineering.
Puede usar múltiples etiquetas para un filtrado más específico:
kubectl get jobs -l department=engineering,environment=training
Monitorizando los Eventos del Trabajo
Kubernetes genera eventos para varios cambios de estado en sus trabajos. Estos eventos pueden proporcionar información valiosa sobre el ciclo de vida de sus trabajos.
Veamos los eventos relacionados con nuestros trabajos:
kubectl get events --sort-by=.metadata.creationTimestamp
Este comando muestra todos los eventos en su espacio de nombres, ordenados por tiempo. Puede filtrar los eventos relacionados con un trabajo específico:
kubectl get events --field-selector involvedObject.name=labeled-job
Estos eventos pueden ayudarle a comprender cuándo y por qué se crearon, iniciaron o encontraron problemas los trabajos.
Uso de JSONPath para Salida Personalizada
Kubernetes le permite usar JSONPath para extraer campos específicos de la salida de los comandos kubectl. Esto es útil para centrarse en aspectos particulares de sus trabajos:
kubectl get job labeled-job -o jsonpath='{.status.succeeded}'
Este comando mostrará el número de pods exitosos para el labeled-job.
Para obtener la hora de creación de un trabajo:
kubectl get job labeled-job -o jsonpath='{.metadata.creationTimestamp}'
Creando un CronJob para la Ejecución Programada
Para las tareas que necesitan ejecutarse según una programación, Kubernetes proporciona CronJobs. Creemos un CronJob simple:
cd ~/project
nano simple-cronjob.yaml
Copie y pegue el siguiente contenido YAML:
apiVersion: batch/v1
kind: CronJob
metadata:
name: simple-cronjob
spec:
schedule: "*/1 * * * *" ## Ejecutar cada minuto
jobTemplate:
spec:
template:
spec:
containers:
- name: hello
image: busybox:1.28
command: ["sh", "-c", 'date; echo "Hello from CronJob"']
restartPolicy: Never
Guarde el archivo y salga de nano, luego cree el CronJob:
kubectl apply -f simple-cronjob.yaml
Compruebe que el CronJob se creó:
kubectl get cronjobs
Debería ver una salida similar a:
NAME SCHEDULE SUSPEND ACTIVE LAST SCHEDULE AGE
simple-cronjob */1 * * * * False 0 <none> 10s
Espere un minuto o dos, luego compruebe si hay trabajos creados por el CronJob:
kubectl get jobs
Debería ver trabajos con nombres como simple-cronjob-<timestamp>.
Para ver los registros de la ejecución más reciente del CronJob, primero encuentre el pod:
kubectl get pods --sort-by=.metadata.creationTimestamp
Luego, vea sus registros:
kubectl logs <latest-cronjob-pod>
Los CronJobs son potentes para programar tareas recurrentes en su clúster Kubernetes, y las mismas técnicas de monitorización que hemos aprendido se pueden aplicar a ellos también.
Limpieza
Antes de terminar, limpiemos los recursos que creamos:
kubectl delete job hello-job long-job failed-job counter-job labeled-job
kubectl delete cronjob simple-cronjob
Esto eliminará todos los trabajos y el CronJob de su clúster.
Resumen
En este tutorial, ha aprendido a monitorizar eficazmente los trabajos Kubernetes y a analizar sus registros. Ahora sabe cómo:
- Configurar un entorno Kubernetes utilizando Minikube
- Crear trabajos Kubernetes con varias configuraciones
- Monitorizar el estado del trabajo utilizando
kubectl getykubectl describe - Acceder y analizar los registros del trabajo utilizando
kubectl logs - Utilizar técnicas avanzadas como etiquetas, eventos y JSONPath para una monitorización más efectiva
- Crear trabajos programados utilizando CronJobs
Estas habilidades son esenciales para gestionar aplicaciones en contenedores en un entorno Kubernetes, lo que le permite garantizar la fiabilidad y el rendimiento de sus procesos por lotes. Al comprender cómo rastrear el progreso del trabajo y solucionar problemas a través de los registros, puede mantener cargas de trabajo Kubernetes eficientes y sin errores.
A medida que continúe su viaje en Kubernetes, considere explorar temas más avanzados como la gestión de recursos, el paralelismo de trabajos y la integración con soluciones de monitorización externas como Prometheus y Grafana.
