# Como automatizar tarefas com Kubernetes CronJob

O Kubernetes monitora ativamente a implementação de CronJobs e executa as ações definidas pelo usuário se houver erros. Com os arquivos YAML, a configuração dos Kubernetes CronJobs se transforma em um processo simples e direto.

## O que é CronJob?

CronJob é um método para **automatizar tarefas** que pode ser comparado a um alarme: ele é configurado para executar automaticamente determinadas tarefas em horários específicos. Um CronJob é capaz de automatizar vários tipos de ações, como atualizar bancos de dados, fazer backups de arquivos, executar scripts e enviar e-mails em intervalos regulares. Ao integrar os CronJobs no Kubernetes, as tarefas passam a ser monitoradas e gerenciadas isoladamente em contêineres.

Dica A solução [Managed Kubernetes](https://cloud.ionos.com/managed/kubernetes "Managed Kubernetes — IONOS") da IONOS oferece infraestrutura de alto desempenho para que você configure nodes de trabalho de acordo com as suas necessidades. Essa abrangente solução da IONOS de gerenciamento em nuvem facilita as operações.

## Como configurar Kubernetes CronJobs

O processo de criação de um CronJob é muito parecido com o processo de criação de um *job* comum no Kubernetes. Para isso, é necessário criar um **arquivo de manifesto YAML**, uma descrição estruturada que contém todos os detalhes relevantes do CronJob. Você define parâmetros importantes nesse arquivo, como agendamento da realização da tarefa, os contêineres usados e os comandos exatos que serão executados neles.

### Criar arquivo YAML

Abra o editor de texto da sua preferência para criar o arquivo de configuração YAML. Certifique-se de definir o agendamento do CronJob no **formato Cron**. Adicione a definição do *job*, incluindo a tarefa que será executada. Em seguida, salve o arquivo com a extensão `.yaml`.

```yaml
apiVersion: batch/v1 
kind: CronJob 
metadata: 
    name: novo_cronjob 
spec: 
    schedule: "0     ****    " 
    jobTemplate: 
        spec: 
            template: 
                spec: 
                    containers: 
                    - name: container 
                        image: latest 
                        command:    
                     - /bin/sh
```

Se necessário, adicione os requisitos de recursos e demais configurações na **especificação do *contêiner***:

```yaml
spec: 
    containers: 
    - name: container 
        resources: 
            requests: 
                memory: "64Mi" 
                cpu: "250m" 
            limits: 
                memory: "128Mi" 
                cpu: "500m"
```

### Ativar o CronJob

Insira o comando a seguir no terminal para criar o CronJob no cluster do Kubernetes:

```shell
kubectl apply -f [nomedoarquivo].yaml
```

### Monitorar o CronJob

Ao executar o comando a seguir, você receberá uma lista dos Kubernetes CronJobs existentes. O **modo Watch** garantirá a atualização automática do resultado quando o status do CronJob for alterado.

```shell
kubectl get cronjob --watch
```

### Sintaxe de schedule no Kubernetes CronJob

A **sintaxe do campo “schedule”** do Kubernetes CronJob é baseada no clássico formato *cron* com cinco campos nesta ordem: minuto, hora, dia do mês, mês e dia da semana. Veja um resumo:

- Minuto (0–59)
- Hora (0–23)
- Dia do mês (1–31)
- Mês (1–12 ou Jan–Dec)
- Dia da semana (0–7 ou Sun–Sat)

Caracteres especiais:

- `*`: Cada valor válido para o campo
- `,`: Especificação de múltiplos valores
- `/`: Especificação dos passos

Exemplos:

`0   ****`: A cada hora `15 2  ***`: Diariamente às 2h15 `0 0 1  **`: No primeiro dia de cada mês à meia-noite `0 0  *3*`: Diariamente à meia-noite no mês de março `0 2  **  1`: Todas as segundas-feiras às 2h

### Política de simultaneidade do CronJobs

Uma política de simultaneidade pode ser especificada na configuração de um CronJob. Ela afeta a forma como *jobs* paralelos são executados dentro do mesmo Kubernetes CronJob.

- **Allow (padrão)**: Se a política de simultaneidade for definida como `__Allow__`, um novo *job* será iniciado mesmo se o anterior ainda não tiver sido concluído. Isso significa que diversas instâncias do mesmo *job* podem ocorrer ao mesmo tempo.
- **Forbid**: Com essa configuração, um novo *job* não é iniciado se o anterior ainda não tiver sido concluído. Isso garante que apenas uma instância do *job* seja executada em determinado momento.
- **Replace**: *Jobs* não concluídos são cancelados para que os novos possam continuar. Instâncias do mesmo *job* não podem ser executadas ao mesmo tempo.

### Definir prazo de execução

O campo `startingDeadlineSeconds` de um Kubernetes CronJob especifica o número máximo de segundos após o horário de execução agendado em que um *job* pode ser iniciado. Se não for executado dentro desse limite, considera-se que o *job \*\* \* falhou*\*.

```yaml
apiVersion: batch/v1 
kind: CronJob 
metadata: 
    name: novo_cronjob 
spec: 
    schedule: "0     ****    " 
    startingDeadlineSeconds: 300    
    jobTemplate: 
        spec: 
            template: 
                spec: 
                    containers: 
                    - name: container 
                        image:latest 
                        command: 
                     - /bin/sh
```

No exemplo acima, a tarefa definida no CronJob deverá começar até 300 segundos (cinco minutos) após o horário agendado. Do contrário, o *job* falhará.

### Limitar o histórico de jobs

As configurações `spec.successfulJobsHistoryLimit` e `spec.failedJobsHistoryLimit` de um Kubernetes CronJob permite limitar o número de *jobs* mantidos no histórico do CronJob. `spec.successfulJobsHistoryLimit` é um campo opcional que especifica quantos *jobs* concluídos devem ser salvos no histórico. Essa limitação é útil para controlar a **utilização de recursos** e assegurar que o histórico não fique sobrecarregado com um número excessivo de *jobs* concluídos. De forma similar, o campo `spec.failedJobsHistoryLimit` possibilita controlar o número de *jobs* que falharam.

```yaml
apiVersion: batch/v1beta1 
kind: CronJob 
metadata: 
    name: novo_cronjob 
spec: 
    schedule: "0     ****    " 
    successfulJobsHistoryLimit: 3    # Salva apenas os últimos 3 jobs concluídos no histórico. 
    failedJobsHistoryLimit: 1                    # Salva apenas o último job que falhou no histórico. 
    jobTemplate: 
        spec: 
            template: 
                spec: 
                    containers: 
                    - name: container 
                        image: latest 
                        command: 
                     - /bin/sh
```

No exemplo, especificamos que apenas os três últimos *jobs* concluídos e o último *job* com falha devem ser salvos no histórico do Kubernetes CronJob intitulado `novo_cronjob`.

## Problemas e soluções do Kubernetes Cronjob

Diversos erros podem acontecer com um Kubernetes CronJob, portanto, é importante que você conheça algumas **técnicas de resolução de problemas**. Listamos abaixo algumas causas de erros comuns e apresentamos dicas para resolvê-los:

### O job não inicia

Existem várias causas pelas quais um CronJob não inicia no Kubernetes, incluindo uma **imagem de contêiner incorreta** ou indisponível e ausência de autorizações para a conta de serviço do *pod*. Para diagnosticar o problema, examine os logs do contêiner com o comando `kubectl logs <nome-do-pod>`, os eventos do CronJob com `kubectl describe cronjob <nome-do-cronjob>` e os eventos do *pod* com `kubectl describe pod <nome-do-pod>`. Certifique-se de que a conta de serviço tenha as autorizações necessárias, verificando a função e a vinculação de função.

### Configuração incorreta do CronJob

Uma configuração incorreta do CronJob pode ocorrer devido a **erros de sintaxe no arquivo YAML** ou configurações incorretas nos campos “schedule” e “restartPolicy”. Para identificar esses problemas, acesse o arquivo YAML e verifique se sua sintaxe e configuração estão corretas. Você pode usar o comando `kubectl describe cronjob <nome-do-cronjob>` para obter informações detalhadas sobre a configuração e identificar possíveis erros ou inconsistências.

### Limite de recursos excedidos

Exceder os limites de recursos pode fazer com que os CronJobs não sejam executados corretamente. Para solucionar o problema, verifique os limites de recursos do CronJob e dos respectivos *pods* usando o comando `kubectl describe cronjob <nome-do-cronjob>` e `kubectl describe pod <nome-do-pod>`. Além disso, realizar o **monitoramento da utilização de recursos do cluster** com os comandos `kubectl top nodes` e `kubectl top pods` também traz insights valiosos. Se necessário, ajuste os limites de recursos no arquivo YAML.

Para dar os primeiros passos no gerenciamento de clusters no Kubernetes, recomendamos a leitura do [tutorial de Kubernetes](https://www.ionos.com/digitalguide/server/configuration/kubernetes-tutorial/ "Tutorial Kubernetes") no nosso Digital Guide.


This is a markdown version of: [https://www.ionos.com/pt-br/digitalguide/servidor/configuracao/kubernetes-cronjob/](https://www.ionos.com/pt-br/digitalguide/servidor/configuracao/kubernetes-cronjob/) for AI/LLM consumption.