Como Monitorar o Status e Logs de Jobs Kubernetes

KubernetesBeginner
Pratique Agora

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 backoffLimit de 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 job
  • COMPLETIONS: O número de pods concluídos / conclusões desejadas
  • DURATION: Quanto tempo o job levou para ser executado
  • AGE: 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ção
  • Completed: O job foi concluído com sucesso
  • Failed: 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 get e kubectl 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.