# Controladores

LLMS index: [llms.txt](/llms.txt)

---

<!-- overview -->

Em robótica e automação um _control loop_, ou em português _ciclo de controle_, é
um ciclo não terminado que regula o estado de um sistema.

Aqui está um exemplo de um ciclo de controle: um termostato em uma sala.

Quando você define a temperatura, isso indica ao termostato
sobre o seu _estado desejado_. A temperatura ambiente real é o
_estado atual_. O termostato atua para trazer o estado atual
mais perto do estado desejado, ligando ou desligando o equipamento.

No Kubernetes, controladores são ciclos de controle que observam o estado do seu
<a class='glossary-tooltip' title='Um conjunto de servidores de processamento, também chamados de nós, que executam aplicações conteinerizadas. Todo cluster possui ao menos um servidor de processamento (worker node).' data-bs-toggle='tooltip' data-bs-placement='top' href='/pt-br/docs/reference/glossary/?all=true#term-cluster' target='_blank' aria-label='cluster'>cluster</a>, e então fazer ou requisitar
mudanças onde necessário.
Cada controlador tenta mover o estado atual do cluster mais perto do estado desejado.

<!-- body -->

## Padrão Controlador

Um controlador rastreia pelo menos um tipo de recurso Kubernetes.
Estes <a class='glossary-tooltip' title='An entity in the Kubernetes system, representing part of the state of your cluster.' data-bs-toggle='tooltip' data-bs-placement='top' href='/pt-br/docs/concepts/overview/working-with-objects/#kubernetes-objects' target='_blank' aria-label='objetos'>objetos</a>
têm um campo spec que representa o estado desejado. O(s)
controlador(es) para aquele recurso são responsáveis por fazer o estado atual
se aproximar daquele estado desejado.

O controlador pode executar a ação ele próprio; mais comumente, no Kubernetes,
um controlador enviará mensagens para o
<a class='glossary-tooltip' title='O componente da camada de gerenciamento que serve a API do Kubernetes.' data-bs-toggle='tooltip' data-bs-placement='top' href='/pt-br/docs/concepts/overview/components/#kube-apiserver' target='_blank' aria-label='servidor de API'>servidor de API</a> que têm
efeitos colaterais úteis. Você verá exemplos disso abaixo.



### Controle via servidor de API

O controlador <a class='glossary-tooltip' title='Uma tarefa finita ou em lotes que executa até finalizar.' data-bs-toggle='tooltip' data-bs-placement='top' href='/pt-br/docs/concepts/workloads/controllers/job' target='_blank' aria-label='Job'>Job</a> é um exemplo de um
controlador embutido do Kubernetes. Controladores embutidos gerenciam estado através da
interação com o servidor de API do cluster.

Job é um recurso do Kubernetes que executa um
<a class='glossary-tooltip' title='O menor e mais simples objeto Kubernetes. Um Pod representa um conjunto de contêineres em execução no seu cluster.' data-bs-toggle='tooltip' data-bs-placement='top' href='/pt-br/docs/concepts/workloads/pods/' target='_blank' aria-label='Pod'>Pod</a>, ou talvez vários Pods, para realizar
uma tarefa e depois parar.

(Uma vez [agendado](/docs/concepts/scheduling-eviction/), objetos Pod se tornam parte do
estado desejado para um kubelet).

Quando o controlador Job vê uma nova tarefa, ele garante que, em algum lugar
no seu cluster, os kubelets em um conjunto de Nodes estão executando o número
correto de Pods para realizar o trabalho.
O controlador Job não executa nenhum Pod ou contêiner
ele próprio. Em vez disso, o controlador Job informa o servidor de API para criar ou remover
Pods.
Outros componentes no
<a class='glossary-tooltip' title='A camada de gerenciamento de contêiner que expõe a API e as interfaces para definir, implantar e gerenciar o ciclo de vida dos contêineres.' data-bs-toggle='tooltip' data-bs-placement='top' href='/pt-br/docs/reference/glossary/?all=true#term-control-plane' target='_blank' aria-label='camada de gerenciamento'>camada de gerenciamento</a>
atuam na nova informação (existem novos Pods para serem agendados e executados),
e eventualmente o trabalho é feito.

Após criar um novo Job, o estado desejado é que esse Job seja completado.
O controlador Job faz com que o estado atual para esse Job esteja mais próximo do seu
estado desejado: criando Pods que fazem o trabalho que você queria para esse Job, para que
o Job esteja mais próximo da conclusão.

Controladores também atualizam os objetos que os configuram.
Por exemplo: uma vez que o trabalho de um Job está completo,
o controlador Job atualiza esse objeto Job para marcá-lo como `Finished`.

(Isso é um pouco como alguns termostatos desligam uma luz para
indicar que a sala está agora na temperatura que você definiu).

### Controle direto

Em contraste com Job, alguns controladores precisam fazer mudanças em
coisas fora do seu cluster.

Por exemplo, se você usar um ciclo de controle para garantir que existem
<a class='glossary-tooltip' title='Um Nó é uma máquina de trabalho no Kubernetes.' data-bs-toggle='tooltip' data-bs-placement='top' href='/pt-br/docs/concepts/architecture/nodes/' target='_blank' aria-label='Nodes'>Nodes</a> suficientes
no seu cluster, então esse controlador precisa de algo fora do
cluster atual para configurar novos Nodes quando necessário.

Controladores que interagem com estado externo encontram seu estado desejado a partir do
servidor de API, então comunicam diretamente com um sistema externo para trazer
o estado atual mais próximo da linha.

(Existe na verdade um [controlador](https://github.com/kubernetes/autoscaler/)
que escala horizontalmente os nodes no seu cluster.)

O ponto importante aqui é que o controlador faz algumas mudanças para trazer
seu estado desejado, e então relata o estado atual de volta ao servidor de API do seu cluster.
Outros ciclos de controle podem observar esses dados relatados e tomar suas próprias ações.

No exemplo do termostato, se a sala estiver muito fria, então um controlador diferente
pode também ligar um aquecedor de proteção contra geada. Com clusters Kubernetes, a camada de gerenciamento
indiretamente trabalha com ferramentas de gerenciamento de endereços IP, serviços de armazenamento,
APIs de provedores de nuvem, e outros serviços através de
[estender o Kubernetes](/docs/concepts/extend-kubernetes/) para implementar isso.

## Estado desejado versus atual {#desired-vs-current}

O Kubernetes tem uma visão cloud-native de sistemas, e é capaz de lidar com
mudanças constantes.

Seu cluster pode estar mudando a qualquer momento conforme o trabalho acontece e
ciclos de controle corrigem falhas automaticamente. Isso significa que,
potencialmente, seu cluster nunca atinge um estado estável.

Enquanto os controladores do seu cluster estiverem executando e forem capazes de fazer
mudanças úteis, não importa se o estado geral é estável ou não.

## Design

Como um princípio do seu design, o Kubernetes usa muitos controladores que cada um gerencia
um aspecto particular do estado do cluster. Mais comumente, um ciclo de controle particular
(controlador) usa um tipo de recurso como seu estado desejado, e tem um tipo diferente
de recurso que ele gerencia para fazer esse estado desejado acontecer. Por exemplo,
um controlador para Jobs rastreia objetos Job (para descobrir novo trabalho) e objetos Pod
(para executar os Jobs, e então ver quando o trabalho termina). Neste caso
algo mais cria os Jobs, enquanto o controlador Job cria Pods.

É útil ter controladores simples em vez de um conjunto monolítico de ciclos de controle
que estão interligados. Controladores podem falhar, então o Kubernetes foi projetado para
permitir isso.


<div class="alert alert-info" role="note"><h4 class="alert-heading">Nota</h4><p>Pode haver vários controladores que criam ou atualizam o mesmo tipo de objeto.
Nos bastidores, os controladores do Kubernetes garantem que eles apenas prestam atenção
aos recursos ligados ao seu recurso controlador.</p>
<p>Por exemplo, você pode ter Deployments e Jobs; ambos criam Pods.
O controlador Job não exclui os Pods que seu Deployment criou,
porque existe informação (<a class='glossary-tooltip' title='Marca os objetos com atributos de identificação que são significativos e relevantes para os usuários.' data-bs-toggle='tooltip' data-bs-placement='top' href='/pt-br/docs/concepts/overview/working-with-objects/labels' target='_blank' aria-label='labels'>labels</a>)
que os controladores podem usar para diferenciar esses Pods.</p>
</div>


## Formas de executar controladores {#running-controllers}

O Kubernetes vem com um conjunto de controladores embutidos que executam dentro do
<a class='glossary-tooltip' title='Componente da camada de gerenciamento que executa os processos de controle.' data-bs-toggle='tooltip' data-bs-placement='top' href='/pt-br/docs/reference/command-line-tools-reference/kube-controller-manager/' target='_blank' aria-label='kube-controller-manager'>kube-controller-manager</a>. Estes
controladores embutidos fornecem comportamentos centrais importantes.

O controlador Deployment e o controlador Job são exemplos de controladores que
vêm como parte do próprio Kubernetes (controladores "embutidos").
O Kubernetes permite que você execute uma camada de gerenciamento resiliente, para que se qualquer
um dos controladores embutidos falhar, outra parte da camada de gerenciamento assumirá o trabalho.

Você pode encontrar controladores que executam fora da camada de gerenciamento, para estender o Kubernetes.
Ou, se quiser, pode escrever um novo controlador você mesmo.
Você pode executar seu próprio controlador como um conjunto de Pods,
ou externamente ao Kubernetes. O que se encaixa melhor dependerá do que esse
controlador particular faz.

## Próximos passos

- Leia sobre a [camada de gerenciamento do Kubernetes](/docs/concepts/architecture/#control-plane-components)
- Descubra alguns dos [objetos Kubernetes](/docs/concepts/overview/working-with-objects/) básicos
- Saiba mais sobre a [API do Kubernetes](/docs/concepts/overview/kubernetes-api/)
- Se quiser escrever seu próprio controlador, veja
  [padrões de extensão do Kubernetes](/docs/concepts/extend-kubernetes/#extension-patterns)
  e o repositório [sample-controller](https://github.com/kubernetes/sample-controller)