Ejecución de múltiples comandos y manejo de fallos de inicio
En este paso, aprenderemos cómo ejecutar múltiples comandos al iniciar un Pod y cómo manejar los fallos de inicio utilizando comprobaciones de salud.
Ejecución de múltiples comandos
A menudo, es necesario ejecutar múltiples comandos cuando un contenedor se inicia. Hay varias formas de hacer esto en Kubernetes:
- Encadenar comandos utilizando operadores de shell (
&&, ;, etc.).
- Utilizar un archivo de script.
- Utilizar un contenedor de inicialización (init container).
Exploremos el primer método examinando el archivo multi-command-pod.yaml:
nano multi-command-pod.yaml
Verás:
apiVersion: v1
kind: Pod
metadata:
name: multi-command-pod
spec:
containers:
- name: ubuntu
image: ubuntu:20.04
command: ["/bin/bash", "-c"]
args:
[
"echo 'First command' > /tmp/first.txt && echo 'Second command' > /tmp/second.txt && sleep 3600"
]
Esta configuración encadena múltiples comandos utilizando el operador &&, que ejecuta cada comando solo si el anterior tiene éxito.
Presiona Ctrl+X para salir del editor.
Vamos a crear este Pod:
kubectl apply -f multi-command-pod.yaml
Deberías ver:
pod/multi-command-pod created
Ahora, verifiquemos que ambos comandos se hayan ejecutado comprobando los archivos creados:
kubectl exec multi-command-pod -- cat /tmp/first.txt
Deberías ver:
First command
Y para el segundo archivo:
kubectl exec multi-command-pod -- cat /tmp/second.txt
Deberías ver:
Second command
Manejo de fallos de inicio con comprobaciones de salud
Kubernetes proporciona mecanismos para detectar y manejar fallos de inicio:
- Liveness Probes (Comprobaciones de vida): Comprueban si el contenedor está en ejecución; si no lo está, Kubernetes lo reiniciará.
- Readiness Probes (Comprobaciones de preparación): Comprueban si el contenedor está listo para recibir tráfico.
- Startup Probes (Comprobaciones de inicio): Comprueban si la aplicación se ha iniciado; son útiles para contenedores que tardan en iniciar.
Examinemos un Pod que utiliza una comprobación de vida (liveness probe):
nano liveness-probe-pod.yaml
Verás:
apiVersion: v1
kind: Pod
metadata:
name: liveness-probe-pod
spec:
containers:
- name: ubuntu
image: ubuntu:20.04
command: ["/bin/bash", "-c"]
args: ["touch /tmp/healthy && sleep 3600"]
livenessProbe:
exec:
command: ["cat", "/tmp/healthy"]
initialDelaySeconds: 5
periodSeconds: 5
En esta configuración:
- El contenedor crea un archivo
/tmp/healthy al iniciar.
- La comprobación de vida comprueba este archivo cada 5 segundos.
- Si el archivo falta, Kubernetes considera que el contenedor no está saludable y lo reinicia.
Presiona Ctrl+X para salir del editor.
Vamos a crear este Pod:
kubectl apply -f liveness-probe-pod.yaml
Deberías ver:
pod/liveness-probe-pod created
Comprueba que el Pod esté en ejecución:
kubectl get pods liveness-probe-pod
Deberías ver:
NAME READY STATUS RESTARTS AGE
liveness-probe-pod 1/1 Running 0 30s
Ahora, veamos qué sucede si eliminamos el archivo de comprobación de salud:
kubectl exec liveness-probe-pod -- rm /tmp/healthy
Espera unos 10 segundos y luego comprueba el estado del Pod de nuevo:
kubectl get pods liveness-probe-pod
Deberías ver que el contenedor se ha reiniciado:
NAME READY STATUS RESTARTS AGE
liveness-probe-pod 1/1 Running 1 60s
El contador de reinicios (RESTARTS) ha aumentado a 1, lo que indica que Kubernetes detectó el estado no saludable y reinició el contenedor.
Verifiquemos que el archivo de comprobación de salud exista de nuevo (debería haber sido recreado por el comando de inicio cuando el contenedor se reinició):
kubectl exec liveness-probe-pod -- ls -la /tmp/healthy
Deberías ver que el archivo existe de nuevo:
-rw-r--r-- 1 root root 0 Sep 21 10:30 /tmp/healthy
Esto demuestra cómo Kubernetes puede recuperarse automáticamente de fallos de inicio y mantener el estado deseado de tus aplicaciones.
Creación de un script de inicio personalizado
Para una inicialización más compleja, es posible que desees utilizar un script de inicio personalizado. Vamos a crear un Pod que utilice un script de shell para el inicio:
nano script-pod.yaml
Agrega el siguiente contenido:
apiVersion: v1
kind: Pod
metadata:
name: script-pod
spec:
containers:
- name: ubuntu
image: ubuntu:20.04
command: ["/bin/bash", "-c"]
args:
- |
cat > /tmp/startup.sh << 'EOF'
#!/bin/bash
echo "Script started at $(date)" > /tmp/script-log.txt
echo "Creating configuration files..." >> /tmp/script-log.txt
mkdir -p /tmp/config
echo "app_name=MyApp" > /tmp/config/app.conf
echo "version=1.0" >> /tmp/config/app.conf
echo "Script completed successfully" >> /tmp/script-log.txt
EOF
chmod +x /tmp/startup.sh
/tmp/startup.sh
sleep 3600
Esta configuración:
- Crea un script de inicio en el contenedor.
- Lo hace ejecutable.
- Ejecuta el script.
- Mantiene el contenedor en ejecución con un comando de espera (sleep).
Guarda y sal con Ctrl+X, seguido de Y y Enter.
Vamos a crear este Pod:
kubectl apply -f script-pod.yaml
Deberías ver:
pod/script-pod created
Espera un momento para que el Pod se inicie y luego comprueba su estado:
kubectl get pods script-pod
Deberías ver:
NAME READY STATUS RESTARTS AGE
script-pod 1/1 Running 0 30s
Ahora, comprobemos la salida de nuestro script:
kubectl exec script-pod -- cat /tmp/script-log.txt
Deberías ver algo como:
Script started at Tue Sep 21 10:35:42 UTC 2023
Creating configuration files...
Script completed successfully
Y verifiquemos que el archivo de configuración se haya creado:
kubectl exec script-pod -- cat /tmp/config/app.conf
Deberías ver:
app_name=MyApp
version=1.0
Esto demuestra cómo utilizar scripts de inicio complejos para inicializar tus contenedores en Kubernetes.
