Containerprobe en Kubernetes

KubernetesKubernetesIntermediate
Practicar Ahora

💡 Este tutorial está traducido por IA desde la versión en inglés. Para ver la versión original, puedes hacer clic aquí

Introducción

En Kubernetes, una sonda (probe) es una herramienta de diagnóstico utilizada para determinar si un contenedor está vivo y listo para aceptar tráfico. Hay dos tipos de sondas: las sondas de vitalidad (liveness probes) y las sondas de preparación (readiness probes). En este laboratorio, nos centraremos en ContainerProbe, que es una herramienta utilizada para detectar cuándo un contenedor está listo para aceptar tráfico.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL kubernetes(("Kubernetes")) -.-> kubernetes/BasicsGroup(["Basics"]) kubernetes(("Kubernetes")) -.-> kubernetes/BasicCommandsGroup(["Basic Commands"]) kubernetes(("Kubernetes")) -.-> kubernetes/AdvancedCommandsGroup(["Advanced Commands"]) kubernetes(("Kubernetes")) -.-> kubernetes/TroubleshootingandDebuggingCommandsGroup(["Troubleshooting and Debugging Commands"]) kubernetes/BasicsGroup -.-> kubernetes/initialization("Initialization") kubernetes/BasicCommandsGroup -.-> kubernetes/get("Get") kubernetes/BasicCommandsGroup -.-> kubernetes/create("Create") kubernetes/AdvancedCommandsGroup -.-> kubernetes/apply("Apply") kubernetes/TroubleshootingandDebuggingCommandsGroup -.-> kubernetes/describe("Describe") kubernetes/TroubleshootingandDebuggingCommandsGroup -.-> kubernetes/exec("Exec") kubernetes/TroubleshootingandDebuggingCommandsGroup -.-> kubernetes/logs("Logs") subgraph Lab Skills kubernetes/initialization -.-> lab-12263{{"Containerprobe en Kubernetes"}} kubernetes/get -.-> lab-12263{{"Containerprobe en Kubernetes"}} kubernetes/create -.-> lab-12263{{"Containerprobe en Kubernetes"}} kubernetes/apply -.-> lab-12263{{"Containerprobe en Kubernetes"}} kubernetes/describe -.-> lab-12263{{"Containerprobe en Kubernetes"}} kubernetes/exec -.-> lab-12263{{"Containerprobe en Kubernetes"}} kubernetes/logs -.-> lab-12263{{"Containerprobe en Kubernetes"}} end

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.

  1. Navegar a tu directorio de trabajo:

    Abre la terminal y navega hasta la carpeta de proyecto predeterminada:

    cd /home/labex/project
  2. 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.
  3. 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.

Crear un Despliegue (Deployment)

El primer paso es crear un despliegue (deployment) en Kubernetes. Utilizaremos este despliegue para probar ContainerProbe.

  1. Crea un nuevo archivo llamado deployment.yaml en el directorio /home/labex/project.
  2. Copia y pega el siguiente código en el archivo:
apiVersion: apps/v1
kind: Deployment
metadata:
  name: containerprobe-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: containerprobe
  template:
    metadata:
      labels:
        app: containerprobe
    spec:
      containers:
        - name: containerprobe
          image: nginx
          ports:
            - containerPort: 80

Este código crea un despliegue con una réplica, un selector con la etiqueta app: containerprobe y un contenedor que ejecuta la imagen de nginx.

  1. Aplica el despliegue a tu clúster:
kubectl apply -f deployment.yaml

Agregar una sonda de vitalidad (Liveness Probe)

El siguiente paso es agregar una sonda de vitalidad (liveness probe) al contenedor de nginx. Una sonda de vitalidad se utiliza para determinar si el contenedor está vivo. Si la sonda falla, Kubernetes reiniciará el contenedor.

  1. Actualiza el archivo deployment.yaml en el directorio /home/labex/project con el siguiente contenido:
apiVersion: apps/v1
kind: Deployment
metadata:
  name: containerprobe-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: containerprobe
  template:
    metadata:
      labels:
        app: containerprobe
    spec:
      containers:
        - name: containerprobe
          image: nginx
          ports:
            - containerPort: 80
          livenessProbe:
            httpGet:
              path: /
              port: 80

Este código especifica que la sonda de vitalidad debe enviar una solicitud HTTP GET a la ruta raíz en el puerto 80.

  1. Actualiza el despliegue (deployment):
kubectl apply -f deployment.yaml

Probar la sonda de vitalidad (Liveness Probe)

Ahora que hemos agregado una sonda de vitalidad, podemos probarla para ver si está funcionando correctamente.

  1. Obtener el nombre del pod (pod):
kubectl get pods -l app=containerprobe -o jsonpath='{.items[0].metadata.name}'

Este comando obtiene el nombre del pod creado por el despliegue (deployment).

  1. Obtener el estado de la sonda de vitalidad:
kubectl describe pod <pod-name>

Reemplaza <pod-name> con el nombre del pod del paso anterior.

Deberías ver una salida que incluya lo siguiente:

Liveness: http-get http://:80/ delay=0s timeout=1s period=10s #success=1 #failure=3

Esto indica que la sonda de vitalidad está configurada correctamente.

Agregar una sonda de preparación (Readiness Probe)

El siguiente paso es agregar una sonda de preparación (readiness probe) al contenedor de nginx. Una sonda de preparación se utiliza para determinar si el contenedor está listo para recibir tráfico. Si la sonda falla, Kubernetes no enviará tráfico al contenedor.

  1. Agrega el siguiente código a la definición del contenedor en deployment.yaml:
apiVersion: apps/v1
kind: Deployment
metadata:
  name: containerprobe-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: containerprobe
  template:
    metadata:
      labels:
        app: containerprobe
    spec:
      containers:
        - name: containerprobe
          image: nginx
          ports:
            - containerPort: 80
          livenessProbe:
            httpGet:
              path: /
              port: 80
          readinessProbe:
            httpGet:
              path: /
              port: 80

Este código especifica que la sonda de preparación debe enviar una solicitud HTTP GET a la ruta raíz en el puerto 80.

  1. Actualiza el despliegue (deployment):
kubectl apply -f deployment.yaml

Probar la sonda de preparación (Readiness Probe)

Ahora que hemos agregado una sonda de preparación, podemos probarla para ver si está funcionando correctamente.

  1. Obtener el nombre del pod (pod):
kubectl get pods -l app=containerprobe -o jsonpath='{.items[0].metadata.name}'

Este comando obtiene el nombre del pod creado por el despliegue (deployment).

  1. Obtener el estado de la sonda de preparación:
kubectl describe pod <pod-name>

Reemplaza <pod-name> con el nombre del pod del paso anterior.

Deberías ver una salida que incluya lo siguiente:

Readiness: http-get http://:80/ delay=0s timeout=1s period=10s #success=1 #failure=3

Esto indica que la sonda de preparación está configurada correctamente.

Resumen

En este laboratorio, aprendimos cómo usar ContainerProbe en Kubernetes. Creamos un despliegue (deployment), agregamos una sonda de vitalidad (liveness probe), probamos la sonda de vitalidad, agregamos una sonda de preparación (readiness probe) y probamos la sonda de preparación. Al utilizar ContainerProbe, podemos asegurarnos de que nuestros contenedores estén listos para recibir tráfico y estén funcionando correctamente.