Verificações de integridade: sondas de atividade e prontidão
Configure sondas de atividade e prontidão para garantir que suas aplicações estejam saudáveis e prontas para atender ao tráfego.
Verificações de integridade: sondas de atividade e prontidão é uma aula grátis de Kubernetes Basics no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Kubernetes Basics, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Kubernetes Basics inclui 4 aulas no total.
Mantendo as aplicações saudáveis
Como o Kubernetes sabe se sua aplicação está realmente funcionando? Não basta um contêiner estar apenas em execução; ele precisa estar saudável e pronto para atender ao tráfego.
O Kubernetes usa verificações especiais chamadas sondas para monitorar suas aplicações. Essas sondas ajudam a garantir que seus usuários sempre tenham uma experiência de serviço confiável.
O que são sondas de atividade?
Uma sonda de atividade verifica se sua aplicação ainda está ativa e respondendo. Se uma sonda de atividade falhar, o Kubernetes presume que seu contêiner não está saudável e o reinicia.
Pense nisso como um monitor de batimentos cardíacos: se o coração parar, será necessário reiniciar! Isso ajuda a recuperar-se de bloqueios ou falhas da aplicação.
Fundamentos das sondas de atividade
Você pode configurar sondas de atividade usando diferentes métodos:
- GET HTTP: Faz uma solicitação HTTP para um caminho especificado.
- Socket TCP: Verifica se uma conexão TCP pode ser aberta em uma porta.
- Comando Exec: Executa um comando dentro do contêiner.
Para aplicações web, GET HTTP é muito comum. Veja um trecho que mostra como você definiria uma em um YAML de Pod:
livenessProbe:
httpGet:
path: /healthz
port: 8080
initialDelaySeconds: 5
periodSeconds: 5Sonda de atividade em ação
Esta aplicação Python com Flask simulará um estado não saudável ao falhar depois de duas solicitações a /healthz. A sonda do Kubernetes detectará isso e reiniciará o contêiner.
Primeiro, salve isto 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)Executando uma sonda de atividade
Agora, vamos ver como o Kubernetes usa a sonda de atividade. Se você implantar isto com o YAML a seguir, o Kubernetes reiniciará o Pod quando a verificação de integridade falhar:
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)Após a implantação, a terceira verificação falhará depois de duas verificações bem-sucedidas, e o Kubernetes reiniciará o contêiner.
O que são sondas de prontidão?
Uma sonda de prontidão verifica se sua aplicação está pronta para atender ao tráfego. Se uma sonda de prontidão falhar, o Kubernetes interromperá o envio de tráfego para esse Pod, mas não o reiniciará.
Isso é fundamental durante a inicialização (por exemplo, enquanto aguarda uma conexão com o banco de dados) ou durante desligamentos normais. Pense: "A loja está aberta para os clientes?"
Fundamentos das sondas de prontidão
As sondas de prontidão são configuradas de forma semelhante às sondas de atividade, usando GET HTTP, Socket TCP ou comandos Exec. A principal diferença é o efeito:
- Atividade: Reinicia o contêiner em caso de falha.
- Prontidão: Remove o Pod dos endpoints do serviço em caso de falha (sem tráfego).
Veja um trecho de uma sonda de prontidão:
readinessProbe:
httpGet:
path: /ready
port: 8080
initialDelaySeconds: 10
periodSeconds: 5Sonda de prontidão em ação
Esta aplicação Flask simula uma aplicação que leva algum tempo para inicializar (por exemplo, ao conectar-se a um banco de dados). Ela só informará que está "pronta" após 5 segundos.
Salve isto 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)Executando uma sonda de prontidão
Quando implantado com este YAML, o pod não receberá tráfego durante os primeiros initialDelaySeconds segundos, somados ao tempo necessário para que /ready retorne 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)Isso garante que o tráfego seja direcionado somente para instâncias realmente prontas.
Atividade versus prontidão
É importante usar as duas sondas corretamente:
- Sonda de atividade: usada para detectar se a sua aplicação falhou ou está em um estado irrecuperável. Se ela falhar, o Kubernetes reiniciará o contêiner.
- Sonda de prontidão: usada para detectar se a sua aplicação está pronta para aceitar e processar solicitações. Se ela falhar, o Kubernetes interromperá o envio de tráfego para o pod.
Elas têm finalidades diferentes, mas complementares, para manter as suas aplicações robustas.
Verifique sua compreensão
Quais das afirmações a seguir sobre as sondas de atividade e de prontidão são TRUE?
Sondas: principais conclusões
Nesta lição, você aprendeu sobre as sondas de atividade e de prontidão no Kubernetes. Essas verificações de integridade são essenciais para manter a confiabilidade e a disponibilidade das suas aplicações:
- Sondas de atividade detectam contêineres não íntegros e acionam reinicializações.
- Sondas de prontidão controlam quando um pod está pronto para receber tráfego de rede.
Usá-las com eficiência garante que as suas aplicações estejam sempre responsivas e resilientes a problemas.
Perguntas Frequentes
A aula “Verificações de integridade: sondas de atividade e prontidão” é grátis?
Sim — o texto completo de “Verificações de integridade: sondas de atividade e prontidão” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Kubernetes Basics, atualize para CoddyKit PRO. O curso de Kubernetes Basics inclui 4 aulas no total.
O que vou aprender em “Verificações de integridade: sondas de atividade e prontidão”?
Configure sondas de atividade e prontidão para garantir que suas aplicações estejam saudáveis e prontas para atender ao tráfego. Você pratica Kubernetes Basics com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Kubernetes Basics?
Nenhuma experiência prévia é necessária. Kubernetes Basics no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.
Quanto tempo leva a aula “Verificações de integridade: sondas de atividade e prontidão”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Kubernetes Basics?
Sim. Cada aula de Kubernetes Basics inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Logging com kubectl logs
- Métricas com Prometheus e Grafana
- Verificações de integridade: sondas de atividade e prontidão
- Rastreamento Distribuído e Eventos