Explorar y depurar aplicaciones de Kubernetes

Introducción

En este laboratorio, explorarás y depurarás aplicaciones de Kubernetes. Iniciarás un clúster local de Kubernetes utilizando Minikube, desplegarás una aplicación de muestra y aprenderás diversas técnicas de depuración, como inspeccionar la configuración de la aplicación, ver los registros (logs), ejecutar comandos dentro de los pods y examinar los eventos del clúster. Estas habilidades son esenciales para desarrollar y solucionar problemas en aplicaciones basadas en Kubernetes.

Iniciar el clúster de Kubernetes

En este paso, aprenderá cómo iniciar y verificar un clúster local de Kubernetes utilizando Minikube. Este es un primer paso esencial para desarrollar y probar aplicaciones de Kubernetes en su máquina local.

Primero, inicie el clúster de Minikube:

minikube start

Ejemplo de salida:

😄  minikube v1.29.0 on Ubuntu 22.04
✨  Automatically selected the docker driver
📌  Using Docker driver with root permissions
🔥  Creating kubernetes in kubernetes cluster
🔄  Restarting existing kubernetes cluster
🐳  Preparing Kubernetes v1.26.1 on Docker 20.10.23 ...
🚀  Launching Kubernetes ...
🌟  Enabling addons: storage-provisioner, default-storageclass
🏄  Done! kubectl is now configured to use "minikube" cluster and "default" namespace

Ahora, verifique el estado del clúster utilizando múltiples comandos:

minikube status
kubectl get nodes

Ejemplo de salida:

minikube
type: Control Plane
host: Running
kubelet: Running
apiserver: Running
kubeconfig: Configured

NAME       STATUS   ROLES           AGE   VERSION
minikube   Ready    control-plane   1m    v1.26.1

Estos comandos confirman que:

1. Minikube se está ejecutando correctamente.
2. Se ha creado un clúster local de Kubernetes.
3. El clúster está listo para usar.
4. Tiene un clúster de un solo nodo con capacidades de plano de control (control plane).

Comprobemos el contexto (context) del clúster para asegurarnos de que está conectado al clúster correcto:

kubectl config current-context

Ejemplo de salida:

minikube

Esto verifica que kubectl está configurado para usar el clúster de Minikube.

Desplegar una Aplicación de Ejemplo

En este paso, aprenderás cómo crear y desplegar una aplicación simple de Kubernetes usando manifiestos YAML. Crearemos tanto un Pod como un Deployment para demostrar diferentes formas de desplegar aplicaciones.

Primero, crea un directorio para tus manifiestos de Kubernetes:

mkdir -p ~/project/k8s-manifests
cd ~/project/k8s-manifests

Crea un manifiesto simple de Pod NGINX:

nano nginx-pod.yaml

Añade el siguiente contenido:

apiVersion: v1
kind: Pod
metadata:
  name: nginx-pod
  labels:
    app: nginx
spec:
  containers:
    - name: nginx
      image: nginx:latest
      ports:
        - containerPort: 80

Presiona Ctrl+X, luego Y, y Enter para guardar y salir.

Ahora, crea un manifiesto de Deployment:

nano nginx-deployment.yaml

Añade el siguiente contenido:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
        - name: nginx
          image: nginx:latest
          ports:
            - containerPort: 80

Aplica los manifiestos para crear los recursos:

kubectl apply -f nginx-pod.yaml
kubectl apply -f nginx-deployment.yaml

Ejemplo de salida:

pod/nginx-pod created
deployment.apps/nginx-deployment created

Verifica los recursos creados:

kubectl get pods
kubectl get deployments

Ejemplo de salida:

NAME                                READY   STATUS    RESTARTS   AGE
nginx-pod                           1/1     Running   0          1m
nginx-deployment-xxx-yyy            1/1     Running   0          1m
nginx-deployment-xxx-zzz            1/1     Running   0          1m
nginx-deployment-xxx-www            1/1     Running   0          1m

NAME               READY   UP-TO-DATE   AVAILABLE   AGE
nginx-deployment   3/3     3            3           1m

Espera a que el deployment cree las réplicas. La columna READY debería mostrar 3/3 cuando todas las réplicas estén listas.

Diferencias clave entre Pod y Deployment:

• Pod: Instancia única de una aplicación
• Deployment: Gestiona múltiples réplicas y proporciona auto-recuperación (self-healing)

Verificar la configuración de la aplicación

En este paso, aprenderás cómo inspeccionar y recuperar los detalles de configuración de los Despliegues (Deployments) y Pods de Kubernetes utilizando varios comandos de kubectl. Comprender cómo examinar las configuraciones de los recursos es crucial para solucionar problemas y entender la configuración de tu aplicación.

Primero, recuperemos la configuración YAML del Pod que creamos en el paso anterior:

kubectl get pod nginx-pod -o yaml

Ejemplo de salida (parcial):

apiVersion: v1
kind: Pod
metadata:
  name: nginx-pod
  namespace: default
  labels:
    app: nginx
spec:
  containers:
    - image: nginx:latest
      imagePullPolicy: Always
      name: nginx
      ports:
        - containerPort: 80
      resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Always

Ahora, examinemos la configuración del Despliegue:

kubectl get deployment nginx-deployment -o yaml

Ejemplo de salida (parcial):

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  namespace: default
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
        - name: nginx
          image: nginx:latest
          ports:
            - containerPort: 80

Utiliza kubectl describe para obtener información más detallada sobre los recursos:

kubectl describe pod nginx-pod
kubectl describe deployment nginx-deployment

Ejemplo de salida para describe pod (parcial):

Name:         nginx-pod
Namespace:    default
Priority:     0
Node:         minikube/172.17.0.2
Start Time:   [timestamp]
Labels:       app=nginx
Annotations:  <none>
Status:       Running
IP:           172.17.0.5
Containers:
  nginx:
    Container ID:   docker://[container-id]
    Image:          nginx:latest
    Image ID:       docker-pullable://nginx@[image-digest]
    Port:           80/TCP
    Host Port:      0/TCP
    State:          Running
    Ready:          True
    Restart Count:  0
Conditions:
  Type              Status
  Initialized       True
  Ready             True
  ContainersReady   True
  PodScheduled      True

También puedes utilizar la salida en formato JSON para formatos más legibles por máquina:

kubectl get pod nginx-pod -o json

Aspectos clave a buscar al inspeccionar las configuraciones:

• Metadatos del recurso (nombre, etiquetas, espacio de nombres)
• Imagen y puertos del contenedor
• Número de réplicas (para Despliegues)
• Estado y condiciones del recurso

Ver los registros (logs) de una aplicación

En este paso, aprenderás cómo ver e inspeccionar los registros (logs) de los Pods de Kubernetes utilizando kubectl logs. Ver los registros es crucial para entender el comportamiento de la aplicación, depurar problemas y monitorear el rendimiento de la aplicación.

Primero, lista los Pods disponibles para asegurarte de trabajar con los recursos correctos:

kubectl get pods

Ejemplo de salida:

NAME                                READY   STATUS    RESTARTS   AGE
nginx-pod                           1/1     Running   0          20m
nginx-deployment-xxx-yyy            1/1     Running   0          20m
nginx-deployment-xxx-zzz            1/1     Running   0          20m
nginx-deployment-xxx-www            1/1     Running   0          20m

Ver los registros de un Pod específico:

## Ver los registros del nginx-pod
kubectl logs nginx-pod

Ejemplo de salida:

/docker-entrypoint.sh: /docker-entrypoint.d/ is not empty, will attempt to perform configuration
/docker-entrypoint.sh: Looking for shell scripts in /docker-entrypoint.d/
/docker-entrypoint.sh: Launching /docker-entrypoint.d/10-listen-on-ipv6-by-default.sh
...
2023/xx/xx [notice] xxxx#x: signal process started

Ver los registros de los Pods de un Despliegue (Deployment):

## Ver los registros de un Pod específico en el despliegue
POD_NAME=$(kubectl get pods -l app=nginx | grep nginx-deployment | head -n 1 | awk '{print $1}')
kubectl logs $POD_NAME

Explora opciones adicionales para ver los registros:

## Ver las últimas 50 líneas de los registros
kubectl logs nginx-pod --tail=50

## Seguir los registros en tiempo real
kubectl logs -f nginx-pod

Ejemplo de seguimiento de registros:

[real-time log output will be displayed]

Sal del modo de visualización de registros en tiempo real presionando Ctrl + C.

Para Pods con múltiples contenedores, especifica el nombre del contenedor:

## Si un Pod tiene múltiples contenedores
kubectl logs nginx-pod -c nginx

Técnicas clave para ver los registros:

• Ver todo el historial de registros
• Limitar el número de líneas de los registros
• Seguir los registros en tiempo real
• Especificar el contenedor en Pods con múltiples contenedores

Depurar usando kubectl exec

En este paso, aprenderás cómo utilizar kubectl exec para ejecutar comandos dentro de un Pod de Kubernetes, lo cual es esencial para depurar e investigar los entornos de contenedores.

Primero, verifica los Pods disponibles:

kubectl get pods

Ejemplo de salida:

NAME                                READY   STATUS    RESTARTS   AGE
nginx-pod                           1/1     Running   0          30m
nginx-deployment-xxx-yyy            1/1     Running   0          30m
nginx-deployment-xxx-zzz            1/1     Running   0          30m
nginx-deployment-xxx-www            1/1     Running   0          30m

Ejecuta una shell interactiva en el nginx-pod:

kubectl exec -it nginx-pod -- /bin/bash

Ejemplo de interacciones dentro del Pod:

## Check nginx configuration
cat /etc/nginx/nginx.conf

## Verify installed packages
apt update && apt list --installed

## Exit the pod shell
exit

Asegúrate de ejecutar exit en la shell interactiva para volver al prompt de la shell.

Ejecuta comandos específicos sin entrar en una shell interactiva:

## Check nginx version
kubectl exec nginx-pod -- nginx -v

## List files in the web root
kubectl exec nginx-pod -- ls /usr/share/nginx/html

Para los Pods de un Despliegue (Deployment), selecciona un Pod específico:

## Get a Pod name from the deployment
POD_NAME=$(kubectl get pods -l app=nginx | grep nginx-deployment | head -n 1 | awk '{print $1}')

## Run commands in the deployment's Pod
kubectl exec -it $POD_NAME -- /bin/bash

Técnicas clave de kubectl exec:

• Ejecutar shells interactivas
• Ejecutar comandos específicos
• Investigar el interior de los Pods
• Depurar configuraciones de contenedores

Usar kubectl describe para solucionar problemas

En este paso, aprenderás cómo utilizar kubectl describe para diagnosticar y solucionar problemas de los recursos de Kubernetes, lo que te proporcionará información detallada sobre el estado de los Pods, Despliegues (Deployments) y componentes del clúster.

Primero, creemos un despliegue problemático para demostrar la depuración:

cd ~/project/k8s-manifests
nano problematic-deployment.yaml

Agrega el siguiente contenido:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: debug-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: debug
  template:
    metadata:
      labels:
        app: debug
    spec:
      containers:
        - name: debug-container
          image: non-existent-image:latest
          ports:
            - containerPort: 80

Aplica el despliegue:

kubectl apply -f problematic-deployment.yaml

Ahora, utiliza kubectl describe para investigar el despliegue:

kubectl describe deployment debug-deployment

Ejemplo de salida:

Name:                   debug-deployment
Namespace:              default
CreationTimestamp:      [timestamp]
Labels:                 <none>
Annotations:            deployment.kubernetes.io/revision: 1
Selector:               app=debug
Replicas:               2 desired | 0 available | 2 total | 2 unavailable
StrategyType:           RollingUpdate
MinReadySeconds:        0
RollingUpdateStrategy:  25% max unavailable, 25% max surge
Conditions:
  Type           Status   Reason
  ----           ------   ------
  Available      False    MinimumReplicasUnavailable
  Progressing    False    ProgressDeadlineExceeded
OldReplicaSets:  <none>
NewReplicaSet:   debug-deployment-xxx (2/2 replicas created)
Events:
  Type     Reason                    Age   From                   Message
  ----     ------                    ----  ----                   -------
  Warning  FailedCreate              1m    deployment-controller  Failed to create pod
  Normal   ScalingReplicaSet         1m    deployment-controller  Scaled up replica set

Describe los Pods para obtener más detalles:

kubectl describe pods -l app=debug

Ejemplo de salida:

Name:           debug-deployment-xxx-yyy
Namespace:      default
Priority:       0
Node:           minikube/172.17.0.2
Start Time:     [timestamp]
Labels:         app=debug
Annotations:    <none>
Status:         Pending
Conditions:
  Type           Status
  Initialized    True
  Ready          False
  PodScheduled   True
Events:
  Type     Reason                  Age   From               Message
  ----     ------                  ----  ----               -------
  Warning  FailedCreatePodSandBox  1m    kubelet            Failed to create pod sandbox
  Warning  Failed                  1m    kubelet            Failed to pull image

Describe los recursos del nodo:

kubectl describe nodes minikube

Técnicas clave para solucionar problemas:

• Identificar el estado del despliegue y de los Pods
• Ver mensajes de error detallados
• Comprender por qué los recursos no se están ejecutando
• Verificar las condiciones del nodo y del clúster

Examinar los eventos del clúster (kubectl get events) para encontrar pistas y cronologías

En este paso, aprenderás cómo utilizar kubectl get events para investigar los eventos a nivel de clúster, comprender las actividades del sistema y diagnosticar problemas en tu entorno de Kubernetes.

Primero, visualiza todos los eventos del clúster:

kubectl get events

Ejemplo de salida:

LAST SEEN   TYPE      REASON                 OBJECT                           MESSAGE
10m         Warning   FailedCreate           deployment/debug-deployment     Failed to create pod
5m          Normal    Scheduled              pod/nginx-pod                   Successfully assigned default/nginx-pod to minikube
3m          Normal    Pulled                 pod/nginx-deployment-xxx-yyy    Container image "nginx:latest" already present on machine

Filtra los eventos por espacio de nombres (namespace):

kubectl get events -n default

Utiliza opciones más detalladas para visualizar los eventos:

## Observar eventos en tiempo real
kubectl get events -w

## Obtener eventos ordenados por marca de tiempo
kubectl get events --sort-by='.metadata.creationTimestamp'

Crea un escenario personalizado para generar eventos:

cd ~/project/k8s-manifests
nano event-test-deployment.yaml

Agrega el siguiente contenido:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: event-test
spec:
  replicas: 3
  selector:
    matchLabels:
      app: event-test
  template:
    metadata:
      labels:
        app: event-test
    spec:
      containers:
        - name: nginx
          image: nginx:latest
          resources:
            limits:
              cpu: "100m"
              memory: "50Mi"

Aplica el despliegue y examina los eventos:

kubectl apply -f event-test-deployment.yaml
kubectl get events

Filtrado avanzado de eventos:

## Filtrar por tipo de evento
kubectl get events --field-selector type=Warning

## Filtrar por recurso específico
kubectl get events --field-selector involvedObject.kind=Deployment

Técnicas clave para examinar eventos:

• Visualizar eventos a nivel de clúster
• Filtrar eventos por espacio de nombres
• Observar eventos en tiempo real
• Identificar eventos de advertencia y error

Resumen

En este laboratorio, aprendiste cómo iniciar y verificar un clúster local de Kubernetes utilizando Minikube, lo cual es un primer paso esencial para desarrollar y probar aplicaciones de Kubernetes en tu máquina local. También aprendiste cómo crear y desplegar una sencilla aplicación de Kubernetes utilizando manifiestos YAML, incluyendo tanto un Pod como un Deployment. Además, exploraste varios comandos para inspeccionar la configuración, ver los registros (logs), depurar y solucionar problemas de la aplicación, lo que te permitió comprender mejor cómo gestionar y monitorear aplicaciones de Kubernetes.