Executando Múltiplos Comandos e Lidando com Falhas de Inicialização
Nesta etapa, aprenderemos como executar vários comandos na inicialização do Pod e como lidar com falhas de inicialização usando verificações de integridade.
Executando Múltiplos Comandos
Frequentemente, você precisa executar vários comandos quando um contêiner inicia. Existem várias maneiras de fazer isso no Kubernetes:
- Encadeie comandos usando operadores de shell (
&&, ;, etc.)
- Use um arquivo de script
- Use um contêiner init
Vamos explorar o primeiro método examinando o arquivo multi-command-pod.yaml:
nano multi-command-pod.yaml
Você verá:
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 configuração encadeia vários comandos usando o operador &&, que executa cada comando somente se o anterior for bem-sucedido.
Pressione Ctrl+X para sair do editor.
Vamos criar este Pod:
kubectl apply -f multi-command-pod.yaml
Você deve ver:
pod/multi-command-pod created
Agora, vamos verificar se ambos os comandos foram executados, verificando os arquivos criados:
kubectl exec multi-command-pod -- cat /tmp/first.txt
Você deve ver:
First command
E para o segundo arquivo:
kubectl exec multi-command-pod -- cat /tmp/second.txt
Você deve ver:
Second command
Lidando com Falhas de Inicialização com Verificações de Integridade
O Kubernetes fornece mecanismos para detectar e lidar com falhas de inicialização:
- Liveness Probes (Sondas de Vivacidade): Verificam se o contêiner está em execução; caso contrário, o Kubernetes o reiniciará
- Readiness Probes (Sondas de Prontidão): Verificam se o contêiner está pronto para receber tráfego
- Startup Probes (Sondas de Inicialização): Verificam se o aplicativo foi iniciado; útil para contêineres de inicialização lenta
Vamos examinar um Pod que usa uma sonda de vivacidade:
nano liveness-probe-pod.yaml
Você verá:
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
Nesta configuração:
- O contêiner cria um arquivo
/tmp/healthy na inicialização
- A sonda de vivacidade verifica este arquivo a cada 5 segundos
- Se o arquivo estiver ausente, o Kubernetes considera o contêiner não íntegro e o reinicia
Pressione Ctrl+X para sair do editor.
Vamos criar este Pod:
kubectl apply -f liveness-probe-pod.yaml
Você deve ver:
pod/liveness-probe-pod created
Verifique se o Pod está em execução:
kubectl get pods liveness-probe-pod
Você deve ver:
NAME READY STATUS RESTARTS AGE
liveness-probe-pod 1/1 Running 0 30s
Agora, vamos ver o que acontece se removermos o arquivo de verificação de integridade:
kubectl exec liveness-probe-pod -- rm /tmp/healthy
Aguarde cerca de 10 segundos e, em seguida, verifique o status do Pod novamente:
kubectl get pods liveness-probe-pod
Você deve ver que o contêiner foi reiniciado:
NAME READY STATUS RESTARTS AGE
liveness-probe-pod 1/1 Running 1 60s
A contagem de RESTARTS aumentou para 1, indicando que o Kubernetes detectou o estado não íntegro e reiniciou o contêiner.
Vamos verificar se o arquivo de verificação de integridade existe novamente (ele deveria ter sido recriado pelo comando de inicialização quando o contêiner reiniciou):
kubectl exec liveness-probe-pod -- ls -la /tmp/healthy
Você deve ver que o arquivo existe novamente:
-rw-r--r-- 1 root root 0 Sep 21 10:30 /tmp/healthy
Isso demonstra como o Kubernetes pode se recuperar automaticamente de falhas de inicialização e manter o estado desejado de seus aplicativos.
Criando um Script de Inicialização Personalizado
Para uma inicialização mais complexa, você pode querer usar um script de inicialização personalizado. Vamos criar um Pod que usa um script de shell para inicialização:
nano script-pod.yaml
Adicione o seguinte conteúdo:
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 configuração:
- Cria um script de inicialização no contêiner
- Torna-o executável
- Executa o script
- Mantém o contêiner em execução com sleep
Salve e saia com Ctrl+X, seguido por Y e Enter.
Vamos criar este Pod:
kubectl apply -f script-pod.yaml
Você deve ver:
pod/script-pod created
Aguarde um momento para o Pod iniciar e, em seguida, verifique seu status:
kubectl get pods script-pod
Você deve ver:
NAME READY STATUS RESTARTS AGE
script-pod 1/1 Running 0 30s
Agora, vamos verificar a saída do nosso script:
kubectl exec script-pod -- cat /tmp/script-log.txt
Você deve ver algo como:
Script started at Tue Sep 21 10:35:42 UTC 2023
Creating configuration files...
Script completed successfully
E vamos verificar se o arquivo de configuração foi criado:
kubectl exec script-pod -- cat /tmp/config/app.conf
Você deve ver:
app_name=MyApp
version=1.0
Isso demonstra como usar scripts de inicialização complexos para inicializar seus contêineres no Kubernetes.
