Skip to content

Commit 81eb58a

Browse files
k8s-ci-robotk8s-ci-robot
authored
Merge pull request #19805 from joao-luna-98/translate-controllers
Add docs/concepts/architecture/controller.md in portuguese
2 parents 0a7e621 + 28eac8e commit 81eb58a

File tree

2 files changed

+186
-0
lines changed

2 files changed

+186
-0
lines changed

‎content/pt/docs/concepts/architecture/controller.md

Lines changed: 156 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,156 @@
1+
---
2+
title: Controladores
3+
content_template: templates/concept
4+
weight: 30
5+
---
6+
7+
{{% capture overview %}}
8+
9+
Em robótica e automação um _control loop_, ou em português _ciclo de controle_, é
10+
um ciclo não terminado que regula o estado de um sistema.
11+
12+
Um exemplo de ciclo de controle é um termostato de uma sala.
13+
14+
Quando você define a temperatura, isso indica ao termostato
15+
sobre o seu *estado desejado*. A temperatura ambiente real é o
16+
*estado atual*. O termostato atua de forma a trazer o estado atual
17+
mais perto do estado desejado, ligando ou desligando o equipamento.
18+
19+
{{< glossary_definition term_id="controller" length="short">}}
20+
21+
{{% /capture %}}
22+
23+
24+
{{% capture body %}}
25+
26+
## Padrão Controlador (Controller pattern)
27+
28+
Um controlador rastreia pelo menos um tipo de recurso Kubernetes.
29+
Estes [objetos](/docs/concepts/overview/working-with-objects/kubernetes-objects/#kubernetes-objects)
30+
têm um campo *spec* que representa o *estado desejado*.
31+
O(s) controlador(es) para aquele recurso são responsáveis por trazer o *estado atual*
32+
mais perto do *estado desejado*.
33+
34+
O controlador pode executar uma ação ele próprio, ou,
35+
o que é mais comum, no Kubernetes, o controlador envia uma mensagem para o
36+
{{< glossary_tooltip text="API server" term_id="kube-apiserver" >}} (servidor de API) que tem
37+
efeitos colaterais úteis. Você vai ver exemplos disto abaixo.
38+
39+
### Controlador via API server
40+
41+
O controlador {{< glossary_tooltip term_id="job" >}} é um exemplo de um
42+
controlador Kubernetes embutido. Controladores embutidos gerem estados através da
43+
interação com o *cluster API server*.
44+
45+
*Job* é um recurso do Kubernetes que é executado em um
46+
*{{< glossary_tooltip term_id="pod" >}}*, ou talvez vários *Pods*, com o objetivo de
47+
executar uma tarefa e depois parar.
48+
49+
(Uma vez [agendado](/docs/concepts/scheduling/), objetos *Pod* passam a fazer parte
50+
do *estado desejado* para um kubelet.
51+
52+
Quando o controlador *Job* observa uma nova tarefa ele garante que,
53+
algures no seu *cluster*, os kubelets num conjunto de nós (*Nodes*) estão correndo o número
54+
correto de *Pods* para completar o trabalho.
55+
O controlador *Job* não corre *Pods* ou *containers* ele próprio.
56+
Em vez disso, o controlador *Job* informa o *API server* para criar ou remover *Pods*.
57+
Outros componentes do plano de controle
58+
({{< glossary_tooltip text="control plane" term_id="control-plane" >}})
59+
atuam na nova informação (existem novos *Pods* para serem agendados e executados),
60+
e eventualmente o trabalho é feito.
61+
62+
Após ter criado um novo *Job*, o *estado desejado* é que esse Job seja completado.
63+
O controlador *Job* faz com que o *estado atual* para esse *Job* esteja mais perto do seu
64+
*estado desejado*: criando *Pods* que fazem o trabalho desejado para esse *Job* para que
65+
o *Job* fique mais perto de ser completado.
66+
67+
Controladores também atualizam os objetos que os configuram.
68+
Por exemplo: assim que o trabalho de um *Job* está completo,
69+
o controlador *Job* atualiza esse objeto *Job* para o marcar como `Finished` (terminado).
70+
71+
(Isto é um pouco como alguns termostatos desligam uma luz para
72+
indicar que a temperatura da sala está agora na temperatura que foi introduzida).
73+
74+
### Controle direto
75+
76+
Em contraste com *Job*, alguns controladores necessitam de efetuar
77+
mudanças fora do *cluster*.
78+
79+
Por exemplo, se usar um ciclo de controle para garantir que existem
80+
*{{< glossary_tooltip text="Nodes" term_id="node" >}}* suficientes
81+
no seu *cluster*, então esse controlador necessita de algo exterior ao
82+
*cluster* atual para configurar novos *Nodes* quando necessário.
83+
84+
Controladores que interagem com estados externos encontram o seu estado desejado
85+
a partir do *API server*, e então comunicam diretamente com o sistema externo para
86+
trazer o *estado atual* mais próximo do desejado.
87+
88+
(Existe um controlador que escala horizontalmente nós no seu *cluster*.
89+
Veja [Escalamento automático do cluster](/docs/tasks/administer-cluster/cluster-management/#cluster-autoscaling))
90+
91+
## Estado desejado versus atual {#desired-vs-current}
92+
93+
Kubernetes tem uma visão *cloud-native* de sistemas e é capaz de manipular
94+
mudanças constantes.
95+
96+
O seu *cluster* pode mudar em qualquer momento à medida que as ações acontecem e
97+
os ciclos de controle corrigem falhas automaticamente. Isto significa que,
98+
potencialmente, o seu *cluster* nunca atinge um estado estável.
99+
100+
Enquanto os controladores no seu *cluster* estiverem rodando e forem capazes de
101+
fazer alterações úteis, não importa se o estado é estável ou se é instável.
102+
103+
## Design
104+
105+
Como um princípio do seu desenho, o Kubernetes usa muitos controladores onde cada
106+
um gerencia um aspecto particular do estado do *cluster*. Comumente, um particular
107+
ciclo de controle (controlador) usa uma espécie de recurso como o seu *estado desejado*,
108+
e tem uma espécie diferente de recurso que o mesmo gere para garantir que esse *estado desejado*
109+
é cumprido.
110+
111+
É útil que haja controladores simples em vez de um conjunto monolítico de ciclos de controle
112+
que estão interligados. Controladores podem falhar, então o Kubernetes foi desenhado para
113+
permitir isso.
114+
115+
Por exemplo: um controlador de *Jobs* rastreia objetos *Job* (para
116+
descobrir novos trabalhos) e objetos *Pod* (para correr o *Jobs*, e então
117+
ver quando o trabalho termina). Neste caso outra coisa cria os *Jobs*,
118+
enquanto o controlador *Job* cria *Pods*.
119+
120+
{{< note >}}
121+
Podem existir vários controladores que criam ou atualizam a mesma espécie (kind) de objeto.
122+
Atrás das cortinas, os controladores do Kubernetes garantem que eles apenas tomam
123+
atenção aos recursos ligados aos seus recursos controladores.
124+
125+
Por exemplo, você pode ter *Deployments* e *Jobs*; ambos criam *Pods*.
126+
O controlador de *Job* não apaga os *Pods* que o seu *Deployment* criou,
127+
porque existe informação ({{< glossary_tooltip term_id="label" text="labels" >}})
128+
que os controladores podem usar para diferenciar esses *Pods*.
129+
{{< /note >}}
130+
131+
## Formas de rodar controladores {#running-controllers}
132+
133+
O Kubernetes vem com um conjunto de controladores embutidos que correm
134+
dentro do {{< glossary_tooltip term_id="kube-controller-manager" >}}.
135+
Estes controladores embutidos providenciam comportamentos centrais importantes.
136+
137+
O controlador *Deployment* e o controlador *Job* são exemplos de controladores
138+
que veem como parte do próprio Kubernetes (controladores "embutidos").
139+
O Kubernetes deixa você correr o plano de controle resiliente, para que se qualquer
140+
um dos controladores embutidos falhar, outra parte do plano de controle assume
141+
o trabalho.
142+
143+
Pode encontrar controladores fora do plano de controle, para extender o Kubernetes.
144+
Ou, se quiser, pode escrever um novo controlador você mesmo.
145+
Pode correr o seu próprio controlador como um conjunto de *Pods*,
146+
ou externo ao Kubernetes. O que encaixa melhor vai depender no que esse
147+
controlador faz em particular.
148+
149+
{{% /capture %}}
150+
151+
{{% capture whatsnext %}}
152+
* Leia mais sobre o [plano de controle do Kubernetes](/docs/concepts/#kubernetes-control-plane)
153+
* Descubra alguns dos [objetos Kubernetes](/docs/concepts/#kubernetes-objects) básicos.
154+
* Aprenda mais sobre [API do Kubernetes](/docs/concepts/overview/kubernetes-api/)
155+
* Se pretender escrever o seu próprio controlador, veja [Padrões de Extensão](/docs/concepts/extend-kubernetes/extend-cluster/#extension-patterns)
156+
{{% /capture %}}

‎content/pt/docs/reference/glossary/controller.md

Lines changed: 30 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,30 @@
1+
---
2+
title: Controlador
3+
id: controller
4+
date: 2020-03-23
5+
full_link: /docs/concepts/architecture/controller/
6+
short_description: >
7+
Um ciclo de controle que observa o estado partilhado do cluster através do API Server e efetua
8+
mudanças tentando mover o estado atual em direção ao estado desejado.
9+
10+
aka:
11+
tags:
12+
- architecture
13+
- fundamental
14+
---
15+
No Kubernetes, controladores são ciclos de controle que observam o estado do seu
16+
{{< glossary_tooltip term_id="cluster" text="cluster">}}, e então fazer ou requisitar
17+
mudanças onde necessário.
18+
Cada controlador tenta mover o estado atual do cluster mais perto do estado desejado.
19+
20+
<!--more-->
21+
22+
Controladores observam o estado partilhado do cluster através do
23+
{{< glossary_tooltip text="apiserver" term_id="kube-apiserver" >}} (parte do
24+
{{< glossary_tooltip term_id="control-plane" >}}).
25+
26+
Alguns controladores também correm dentro do plano de controle, fornecendo ciclos
27+
de controle que são centrais às operações do Kubernetes. Por exemplo: o controlador
28+
de *deployments*, o controlador de *daemonsets*, o controlador de *namespaces*, e o
29+
controlador de volumes persistentes (*persistent volumes*) (e outros) todos correm
30+
dentro do {{< glossary_tooltip term_id="kube-controller-manager" >}}.

0 commit comments

Comments
 (0)