Introdução
O Kubernetes é uma poderosa plataforma de orquestração de contêineres que auxilia no gerenciamento de aplicações em contêineres em múltiplos hosts. Uma característica importante do Kubernetes é seu sistema de gerenciamento de jobs, que permite executar cargas de trabalho orientadas a lotes até a conclusão. Neste tutorial, você aprenderá como monitorar o status dos jobs do Kubernetes e analisar seus logs, habilidades essenciais para garantir que suas aplicações em contêineres sejam executadas sem problemas.
Ao final deste tutorial, você será capaz de criar jobs do Kubernetes, verificar seu status e examinar seus logs para solucionar problemas de forma eficaz.
Configurando seu Ambiente Kubernetes
Antes de podermos monitorar os jobs do Kubernetes, precisamos configurar um ambiente Kubernetes funcional. Usaremos o Minikube, uma ferramenta que cria um cluster Kubernetes de nó único em sua máquina local.
Instalando o Minikube
O Minikube já está instalado em sua VM. Vamos verificar a instalação checando a versão:
minikube version
Você deve ver uma saída semelhante a esta:
minikube version: v1.29.0
commit: ddac20b4b34a9c8c857fc602203b6ba2679794d3
Iniciando o Minikube
Agora, vamos iniciar o Minikube para criar um cluster Kubernetes local:
minikube start --driver=docker
Este comando levará alguns minutos para ser concluído. Você verá uma série de mensagens à medida que o Minikube baixa os componentes necessários e inicia o cluster.
Após a conclusão, você deverá ver uma mensagem como:
🏄 Done! kubectl is now configured to use "minikube" cluster and "default" namespace by default
Verificando a Instalação do Kubernetes
Vamos verificar se nosso cluster Kubernetes está sendo executado corretamente, checando o status do nó:
kubectl get nodes
Você deve ver uma saída semelhante a esta:
NAME STATUS ROLES AGE VERSION
minikube Ready control-plane 1m v1.26.3
Além disso, verifique se os componentes principais do Kubernetes estão em execução:
kubectl get pods -n kube-system
Você deve ver vários pods em execução, incluindo componentes como kube-apiserver, kube-controller-manager e outros.
Agora que temos um cluster Kubernetes em execução, estamos prontos para criar e monitorar jobs.
Criando seu Primeiro Job Kubernetes
Nesta etapa, criaremos um job Kubernetes simples que executará um contêiner, realizará uma tarefa e, em seguida, será concluído. Isso nos dará algo para monitorar nas etapas seguintes.
Entendendo os Jobs Kubernetes
Um Job Kubernetes é um controlador que cria um ou mais pods e garante que eles terminem com sucesso. Os jobs são úteis para processos em lote, tarefas únicas ou qualquer tarefa que deva ser executada até a conclusão, em vez de indefinidamente.
Criando um Arquivo de Configuração de Job
Vamos criar um arquivo de configuração de job simples. Abra um terminal e crie um novo arquivo chamado hello-job.yaml em seu diretório de projeto:
cd ~/project
nano hello-job.yaml
Copie e cole o seguinte conteúdo YAML no arquivo:
apiVersion: batch/v1
kind: Job
metadata:
name: hello-job
spec:
template:
spec:
containers:
- name: hello
image: busybox:1.28
command: ["sh", "-c", 'echo "Hello, Kubernetes!" && sleep 5']
restartPolicy: Never
backoffLimit: 4
Esta configuração define um job chamado hello-job que:
- Usa a imagem de contêiner
busybox:1.28 - Executa um comando que imprime "Hello, Kubernetes!" e, em seguida, dorme por 5 segundos
- Tem uma política de reinicialização de
Never, o que significa que não reiniciará após a conclusão - Tem um
backoffLimitde 4, o que significa que tentará novamente até 4 vezes se falhar
Salve o arquivo pressionando Ctrl+O, depois Enter e saia do nano com Ctrl+X.
Criando o Job
Agora, vamos criar o job em nosso cluster Kubernetes:
kubectl apply -f hello-job.yaml
Você deve ver a saída:
job.batch/hello-job created
Parabéns! Você acabou de criar seu primeiro job Kubernetes. Na próxima etapa, aprenderemos como monitorar seu status.
Monitorando o Status do Job Kubernetes
Agora que temos um job em execução em nosso cluster Kubernetes, vamos aprender como monitorar seu status. Monitorar o status do job é crucial para entender se seus jobs estão sendo concluídos com sucesso ou encontrando erros.
Verificando o Status do Job com kubectl
A principal ferramenta para monitorar recursos Kubernetes é o kubectl. Vamos usá-la para verificar o status do nosso job:
kubectl get jobs
Você deve ver uma saída semelhante a esta:
NAME COMPLETIONS DURATION AGE
hello-job 1/1 10s 30s
Esta saída mostra:
NAME: O nome do jobCOMPLETIONS: O número de pods concluídos / conclusões desejadasDURATION: Quanto tempo o job levou para ser executadoAGE: Quanto tempo se passou desde que o job foi criado
Se seu job mostrar 0/1 em COMPLETIONS, ele ainda pode estar em execução ou ter falhado. Aguarde alguns segundos e execute o comando novamente.
Obtendo Informações Detalhadas do Job
Para obter informações mais detalhadas sobre um job, use o comando describe:
kubectl describe job hello-job
Este comando fornece informações extensas sobre o job, incluindo:
- Labels e annotations
- Detalhes do seletor
- Requisitos de paralelismo e conclusão
- Status dos pods
- Eventos relacionados ao job
Procure a seção Events na parte inferior, que mostra eventos importantes como a criação e conclusão do pod.
Entendendo o Status do Job
Um job pode ter vários status:
Active: O job ainda está em execuçãoCompleted: O job foi concluído com sucessoFailed: O job falhou após atingir seu limite de backoff
Vamos verificar se o pod do nosso job foi concluído:
kubectl get pods
Você deve ver algo como:
NAME READY STATUS RESTARTS AGE
hello-job-abcd1 0/1 Completed 0 1m
A coluna STATUS mostra Completed, indicando que nosso job foi executado com sucesso.
Criando um Job que Leva Mais Tempo
Vamos criar outro job que levará mais tempo para ser concluído para que possamos observá-lo no estado Active:
cd ~/project
nano long-job.yaml
Copie e cole o seguinte conteúdo YAML:
apiVersion: batch/v1
kind: Job
metadata:
name: long-job
spec:
template:
spec:
containers:
- name: long
image: busybox:1.28
command:
[
"sh",
"-c",
'echo "Starting long job..." && sleep 30 && echo "Long job completed!"'
]
restartPolicy: Never
backoffLimit: 4
Salve o arquivo e saia do nano. Em seguida, crie o job:
kubectl apply -f long-job.yaml
Agora, vamos verificar seu status imediatamente:
kubectl get jobs
Você deve ver que long-job mostra 0/1 conclusões porque ainda está em execução. Se você continuar verificando a cada poucos segundos, eventualmente verá que ele muda para 1/1 após cerca de 30 segundos.
Isso demonstra como você pode monitorar o progresso de seus jobs em tempo real usando kubectl.
Analisando os Logs do Job Kubernetes
Ser capaz de visualizar e analisar os logs de seus jobs Kubernetes é essencial para depurar e entender o comportamento do job. Nesta etapa, exploraremos como acessar e analisar logs dos jobs que criamos.
Obtendo os Nomes dos Pods para Nossos Jobs
Antes de podermos visualizar os logs, precisamos saber os nomes dos pods criados por nossos jobs. Cada job cria um ou mais pods com nomes que incluem o nome do job e um sufixo aleatório.
Vamos listar todos os pods relacionados aos nossos jobs:
kubectl get pods --show-labels
Isso mostrará todos os pods junto com seus labels. Procure por pods com labels como job-name=hello-job ou job-name=long-job.
Alternativamente, você pode filtrar os pods por nome do job:
kubectl get pods -l job-name=hello-job
Isso mostrará apenas os pods que pertencem ao job hello-job.
Visualizando os Logs do Job
Agora que sabemos os nomes dos nossos pods, podemos visualizar os logs de nossos jobs. Use o seguinte comando, substituindo <pod-name> pelo nome real do seu pod:
kubectl logs <pod-name>
Por exemplo, se seu pod se chama hello-job-abcd1, você executaria:
kubectl logs hello-job-abcd1
Você deve ver a saída:
Hello, Kubernetes!
Esta é a mensagem que nosso job foi programado para gerar.
Vamos também verificar os logs do nosso job mais longo. Primeiro, encontre o nome do pod:
kubectl get pods -l job-name=long-job
Em seguida, visualize seus logs:
kubectl logs <long-job-pod-name>
Você deve ver:
Starting long job...
Long job completed!
Visualizando Logs de Jobs Concluídos
Uma das vantagens dos jobs Kubernetes é que você pode visualizar os logs mesmo após a conclusão do job. Isso é muito útil para fins de depuração e auditoria.
Vamos criar um job que falhará, para que possamos ver como depurá-lo:
cd ~/project
nano failed-job.yaml
Copie e cole o seguinte conteúdo YAML:
apiVersion: batch/v1
kind: Job
metadata:
name: failed-job
spec:
template:
spec:
containers:
- name: failed
image: busybox:1.28
command: ["sh", "-c", 'echo "Attempting task..." && exit 1']
restartPolicy: Never
backoffLimit: 2
Este job sempre sairá com o código de status 1, o que indica falha. Salve o arquivo e saia do nano, depois crie o job:
kubectl apply -f failed-job.yaml
Aguarde alguns instantes para que o job tente e falhe algumas vezes (até o limite de backoff). Em seguida, verifique seu status:
kubectl get jobs failed-job
Você deve ver que ele mostra 0/1 conclusões e atingiu o prazo de conclusão.
Agora, vamos examinar o que deu errado, verificando os logs dos pods com falha:
kubectl get pods -l job-name=failed-job
Você verá vários pods, todos no estado Error. Escolha um e visualize seus logs:
kubectl logs <failed-pod-name>
Você deve ver:
Attempting task...
Os logs do pod mostram que a tarefa começou, mas depois saiu com um código de erro. Essa informação é crucial para depurar falhas de job.
Acompanhando Logs em Tempo Real
Se você deseja acompanhar os logs de um job em execução em tempo real, pode usar a flag -f:
kubectl logs -f <pod-name>
Isso é particularmente útil para jobs de execução mais longa, onde você deseja ver a saída conforme ela acontece.
Vamos criar outro job de longa duração para demonstrar:
cd ~/project
nano counter-job.yaml
Copie e cole o seguinte conteúdo YAML:
apiVersion: batch/v1
kind: Job
metadata:
name: counter-job
spec:
template:
spec:
containers:
- name: counter
image: busybox:1.28
command:
[
"sh",
"-c",
'for i in $(seq 1 5); do echo "Count: $i"; sleep 5; done'
]
restartPolicy: Never
Salve o arquivo e saia do nano, depois crie o job:
kubectl apply -f counter-job.yaml
Agora, vamos acompanhar seus logs. Primeiro, encontre o nome do pod:
kubectl get pods -l job-name=counter-job
Em seguida, acompanhe seus logs:
kubectl logs -f <counter-job-pod-name>
Você verá a contagem incrementando a cada 5 segundos:
Count: 1
Count: 2
Count: 3
Count: 4
Count: 5
Pressione Ctrl+C para parar de acompanhar os logs.
Ao entender como acessar e analisar logs, você pode solucionar problemas e depurar seus jobs Kubernetes de forma eficaz.
Técnicas Avançadas de Monitoramento de Jobs
Agora que você conhece os conceitos básicos de monitoramento de jobs Kubernetes, vamos explorar algumas técnicas mais avançadas que podem ajudá-lo a monitorar jobs de forma mais eficaz, especialmente em ambientes de produção.
Usando Labels para Organização de Jobs
Labels são pares chave-valor que podem ser anexados a recursos Kubernetes. Eles são úteis para organizar e selecionar subconjuntos de recursos. Vamos criar um job com labels personalizados:
cd ~/project
nano labeled-job.yaml
Copie e cole o seguinte conteúdo YAML:
apiVersion: batch/v1
kind: Job
metadata:
name: labeled-job
labels:
department: engineering
app: demo
environment: training
spec:
template:
spec:
containers:
- name: labeled
image: busybox:1.28
command: ["sh", "-c", 'echo "This is a labeled job" && sleep 10']
restartPolicy: Never
Salve o arquivo e saia do nano, depois crie o job:
kubectl apply -f labeled-job.yaml
Agora você pode filtrar jobs por seus labels:
kubectl get jobs -l department=engineering
Isso mostrará apenas os jobs com o label department=engineering.
Você pode usar vários labels para uma filtragem mais específica:
kubectl get jobs -l department=engineering,environment=training
Monitorando Eventos de Job
O Kubernetes gera eventos para várias mudanças de estado em seus jobs. Esses eventos podem fornecer informações valiosas sobre o ciclo de vida de seus jobs.
Vamos visualizar os eventos relacionados aos nossos jobs:
kubectl get events --sort-by=.metadata.creationTimestamp
Este comando mostra todos os eventos em seu namespace, classificados por tempo. Você pode filtrar por eventos relacionados a um job específico:
kubectl get events --field-selector involvedObject.name=labeled-job
Esses eventos podem ajudá-lo a entender quando e por que os jobs foram criados, iniciados ou encontraram problemas.
Usando JSONPath para Saída Personalizada
O Kubernetes permite que você use JSONPath para extrair campos específicos da saída dos comandos kubectl. Isso é útil para se concentrar em aspectos específicos de seus jobs:
kubectl get job labeled-job -o jsonpath='{.status.succeeded}'
Este comando gerará a saída do número de pods bem-sucedidos para o labeled-job.
Para obter o tempo de criação de um job:
kubectl get job labeled-job -o jsonpath='{.metadata.creationTimestamp}'
Criando um CronJob para Execução Agendada
Para tarefas que precisam ser executadas em um cronograma, o Kubernetes fornece CronJobs. Vamos criar um CronJob simples:
cd ~/project
nano simple-cronjob.yaml
Copie e cole o seguinte conteúdo YAML:
apiVersion: batch/v1
kind: CronJob
metadata:
name: simple-cronjob
spec:
schedule: "*/1 * * * *" ## Run every minute
jobTemplate:
spec:
template:
spec:
containers:
- name: hello
image: busybox:1.28
command: ["sh", "-c", 'date; echo "Hello from CronJob"']
restartPolicy: Never
Salve o arquivo e saia do nano, depois crie o CronJob:
kubectl apply -f simple-cronjob.yaml
Verifique se o CronJob foi criado:
kubectl get cronjobs
Você deve ver uma saída semelhante a:
NAME SCHEDULE SUSPEND ACTIVE LAST SCHEDULE AGE
simple-cronjob */1 * * * * False 0 <none> 10s
Aguarde um ou dois minutos e, em seguida, verifique se há jobs criados pelo CronJob:
kubectl get jobs
Você deve ver jobs com nomes como simple-cronjob-<timestamp>.
Para visualizar os logs da execução mais recente do CronJob, primeiro encontre o pod:
kubectl get pods --sort-by=.metadata.creationTimestamp
Em seguida, visualize seus logs:
kubectl logs <latest-cronjob-pod>
CronJobs são poderosos para agendar tarefas recorrentes em seu cluster Kubernetes, e as mesmas técnicas de monitoramento que aprendemos podem ser aplicadas a eles também.
Limpando
Antes de terminarmos, vamos limpar os recursos que criamos:
kubectl delete job hello-job long-job failed-job counter-job labeled-job
kubectl delete cronjob simple-cronjob
Isso removerá todos os jobs e o CronJob do seu cluster.
Resumo
Neste tutorial, você aprendeu como monitorar efetivamente jobs Kubernetes e analisar seus logs. Agora você sabe como:
- Configurar um ambiente Kubernetes usando Minikube
- Criar jobs Kubernetes com várias configurações
- Monitorar o status do job usando
kubectl getekubectl describe - Acessar e analisar logs de jobs usando
kubectl logs - Usar técnicas avançadas como labels, eventos e JSONPath para um monitoramento mais eficaz
- Criar jobs agendados usando CronJobs
Essas habilidades são essenciais para gerenciar aplicações em contêineres em um ambiente Kubernetes, permitindo que você garanta a confiabilidade e o desempenho de seus processos em lote. Ao entender como rastrear o progresso do job e solucionar problemas por meio de logs, você pode manter cargas de trabalho Kubernetes eficientes e sem erros.
À medida que você continua sua jornada no Kubernetes, considere explorar tópicos mais avançados, como gerenciamento de recursos, paralelismo de jobs e integração com soluções de monitoramento externas como Prometheus e Grafana.
