¿Cómo monitorizar el estado y los registros de un trabajo Kubernetes?

KubernetesBeginner
Practicar Ahora

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 backoffLimit de 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 trabajo
  • COMPLETIONS: El número de pods completados / completamientos deseados
  • DURATION: Cuánto tiempo tardó el trabajo en ejecutarse
  • AGE: 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á ejecutando
  • Completed (Completado): El trabajo se ha completado con éxito
  • Failed (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 get y kubectl 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.