0Pricing
Kubernetes Basics · Lección

Comprobaciones de estado: sondas de actividad y disponibilidad

Configure sondas de actividad y disponibilidad para garantizar que sus aplicaciones estén saludables y listas para atender tráfico.

Comprobaciones de estado: sondas de actividad y disponibilidad es una lección gratuita de Kubernetes Basics en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Kubernetes Basics, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Kubernetes Basics incluye 4 lecciones en total.

Mantener las aplicaciones en buen estado

¿Cómo sabe Kubernetes si su aplicación funciona realmente? No basta con que un contenedor esté en ejecución; debe estar saludable y listo para atender tráfico.

Kubernetes utiliza comprobaciones especiales llamadas probes para supervisar sus aplicaciones. Estas probes ayudan a garantizar que sus usuarios disfruten siempre de un servicio fiable.

¿Qué son las probes de liveness?

Una Liveness Probe comprueba si su aplicación sigue activa y responde. Si una liveness probe falla, Kubernetes supone que su contenedor no está saludable y lo reinicia.

Es como un monitor de ritmo cardíaco: si el corazón se detiene, ¡es necesario reiniciarlo! Esto ayuda a recuperarse de bloqueos o fallos de la aplicación.

Conceptos básicos de las liveness probes

Puede configurar las liveness probes mediante distintos métodos:

  • HTTP GET: Realiza una solicitud HTTP a una ruta especificada.
  • TCP Socket: Comprueba si se puede abrir una conexión TCP en un puerto.
  • Exec Command: Ejecuta un comando dentro del contenedor.

En las aplicaciones web, HTTP GET es muy habitual. A continuación se muestra un fragmento que ilustra cómo definir una en el YAML de un Pod:

livenessProbe:
  httpGet:
    path: /healthz
    port: 8080
  initialDelaySeconds: 5
  periodSeconds: 5

Liveness probe en acción

Esta aplicación de Python con Flask simulará un estado no saludable al fallar después de recibir dos solicitudes a /healthz. La probe de Kubernetes lo detectará y reiniciará el contenedor.

Primero, guarde esto como app.py:

from flask import Flask, Response
import os
import time

app = Flask(__name__)
request_count = 0

@app.route('/healthz')
def health_check():
    global request_count
    request_count += 1
    if request_count > 2:
        print("Liveness probe failing! Exiting...")
        os._exit(1) # Simulate a crash
    print(f"Liveness probe successful (count: {request_count})")
    return Response("OK", status=200)

@app.route('/')
def home():
    return "Hello from the Liveness Probe Demo!"

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8080)

Ejecutar una liveness probe

Ahora veamos cómo utiliza Kubernetes la liveness probe. Si implementa esto con el siguiente YAML, Kubernetes reiniciará el Pod cuando falle la comprobación de estado:

apiVersion: v1
kind: Pod
metadata:
  name: liveness-demo
spec:
  containers:
  - name: liveness-container
    image: python:3.9-slim-buster
    command: ["python", "app.py"]
    ports:
    - containerPort: 8080
    livenessProbe:
      httpGet:
        path: /healthz
        port: 8080
      initialDelaySeconds: 5
      periodSeconds: 5
      failureThreshold: 1
    volumeMounts:
    - name: app-volume
      mountPath: /app
  volumes:
  - name: app-volume
    configMap:
      name: liveness-app-config

# (You'd need a ConfigMap for app.py, omitted for brevity)

Una vez implementado, después de 2 comprobaciones correctas, la tercera fallará y Kubernetes reiniciará el contenedor.

¿Qué son las probes de readiness?

Una Readiness Probe comprueba si su aplicación está lista para atender tráfico. Si una readiness probe falla, Kubernetes dejará de enviar tráfico a ese Pod, pero no lo reiniciará.

Esto es fundamental durante el inicio (por ejemplo, mientras se espera una conexión con la base de datos) o durante apagados ordenados. Piense: «¿Está la tienda abierta para los clientes?»

Conceptos básicos de las readiness probes

Las readiness probes se configuran de forma similar a las liveness probes, mediante solicitudes HTTP GET, sockets TCP o comandos Exec. La diferencia clave es su efecto:

  • Liveness: Reinicia el contenedor cuando falla.
  • Readiness: Elimina el Pod de los endpoints del servicio cuando falla (sin tráfico).

A continuación se muestra un fragmento de una readiness probe:

readinessProbe:
  httpGet:
    path: /ready
    port: 8080
  initialDelaySeconds: 10
  periodSeconds: 5

Readiness probe en acción

Esta aplicación de Flask simula una aplicación que tarda un tiempo en inicializarse (por ejemplo, al conectarse a una base de datos). Solo informará de que está "ready" después de 5 segundos.

Guarde esto como ready_app.py:

from flask import Flask, Response
import time

app = Flask(__name__)
start_time = time.time()
READY_AFTER_SECONDS = 5

@app.route('/ready')
def readiness_check():
    if time.time() - start_time > READY_AFTER_SECONDS:
        print("Readiness probe successful: App is ready!")
        return Response("READY", status=200)
    else:
        print("Readiness probe failing: App not ready yet...")
        return Response("NOT READY", status=503)

@app.route('/')
def home():
    return "Hello from the Readiness Probe Demo!"

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8080)

Ejecutar la sonda de disponibilidad

Cuando se implementa con este YAML, el Pod no recibirá tráfico durante los initialDelaySeconds iniciales más el tiempo que tarde /ready en devolver 200 OK.

apiVersion: v1
kind: Pod
metadata:
  name: readiness-demo
spec:
  containers:
  - name: readiness-container
    image: python:3.9-slim-buster
    command: ["python", "ready_app.py"]
    ports:
    - containerPort: 8080
    readinessProbe:
      httpGet:
        path: /ready
        port: 8080
      initialDelaySeconds: 10
      periodSeconds: 3
    volumeMounts:
    - name: app-volume
      mountPath: /app
  volumes:
  - name: app-volume
    configMap:
      name: readiness-app-config

# (You'd need a ConfigMap for ready_app.py, omitted for brevity)

Esto garantiza que el tráfico solo se dirija a las instancias que realmente estén listas.

Disponibilidad frente a actividad

Es importante utilizar correctamente ambas sondas:

  • Sonda de actividad: Se utiliza para detectar si la aplicación se ha bloqueado o se encuentra en un estado del que no puede recuperarse. Si falla, Kubernetes reinicia el contenedor.
  • Sonda de disponibilidad: Se utiliza para detectar si la aplicación está lista para aceptar y procesar solicitudes. Si falla, Kubernetes deja de enviar tráfico al Pod.

Ambas cumplen funciones diferentes, pero complementarias, para mantener la solidez de sus aplicaciones.

Compruebe sus conocimientos

¿Cuáles de las siguientes afirmaciones sobre las sondas de actividad y disponibilidad son VERDADERAS?

Sondas: conclusiones clave

En esta lección, ha aprendido sobre las sondas de actividad y disponibilidad de Kubernetes. Estas comprobaciones de estado son fundamentales para mantener la fiabilidad y disponibilidad de sus aplicaciones:

  • Las sondas de actividad detectan contenedores en mal estado y provocan reinicios.
  • Las sondas de disponibilidad controlan cuándo un Pod está listo para recibir tráfico de red.

Utilizarlas eficazmente garantiza que sus aplicaciones respondan siempre y sean resistentes a los problemas.

Preguntas frecuentes

¿La lección «Comprobaciones de estado: sondas de actividad y disponibilidad» es gratis?

Sí — el texto completo de «Comprobaciones de estado: sondas de actividad y disponibilidad» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Kubernetes Basics, actualiza a CoddyKit PRO. El curso de Kubernetes Basics incluye 4 lecciones en total.

¿Qué aprenderé en «Comprobaciones de estado: sondas de actividad y disponibilidad»?

Configure sondas de actividad y disponibilidad para garantizar que sus aplicaciones estén saludables y listas para atender tráfico. Practicas Kubernetes Basics con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Kubernetes Basics?

No se requiere experiencia previa. Kubernetes Basics en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Comprobaciones de estado: sondas de actividad y disponibilidad»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Kubernetes Basics?

Sí. Cada lección de Kubernetes Basics incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Registro con kubectl logs
  2. Métricas con Prometheus y Grafana
  3. Comprobaciones de estado: sondas de actividad y disponibilidad
  4. Trazas distribuidas y eventos
← Volver a Kubernetes Basics